// Array
/*
(1) 转换方法
toString()
toLocaleString()
valueOf()
join(separator)
    Array.prototye.join.call(array_like_obj,separator)
    Array.prototye.join.call(string,separator)
(2) 栈方法
push(item…)
    合并数组 Array.prototype.push.apply(array1,array2) array1.push.apply(array1,array2)
    为对象添加元素，对象转换为类数组对象 [].prototype.push.apply(object,array)
pop()
(3) 队列方法
unshift(item…)
shift()
(4) 排序方法
reverse()
sort(compare)
(5) 连接方法
concat(item…)
    合并对象为数组 array.concat.call(object)
slice(start,end)
    类数组转换为数组 Array.prototype.slice.call(array_like_obj) Array.prototype.slice.applay(array_like_obj)
splice(start,deleteCount,item...)
(6) 位置方法
indexOf(item,start)
lastIndexOf(item,start)
(7) 迭代方法
every(fn)
some(fn)
filter(fn)
forEach(fn)
    Array.prototye.forEach.call(array_like_obj)
    Array.prototye.forEach.call(string)
map(fn)
    Array.prototye.map.call(array_like_obj)
    Array.prototye.map.call(string)
(8) 转换方法
reduce(fn)
reduceRight(fn)
(9)检测数组
Array.isArray()
注意：
位置方法、迭代方法、归并方法的浏览器支持性
pop() push() reverse() sort() splice() shift() unshift()会改变原数组
concat() slice() splice() 不会改变原数组
slice()左闭右开
sort()可传入比较函数
迭代方法可传入第二个参数作为函数运行的作用域
*/

// 检测数组
function isArray(value) {
    if (!Array.isArray) { //IE8-
        Array.isArray = function(value) {
            return Object.prototype.toString.call(value) === '[Object Array]';
        };
    }
    return Array.isArray(value);
}

// 统计元素item在数组arr中出现的次数
function countAllOccurrences(arr, item) {
    var count = 0;
    for (var i = 0, len = arr.length; i < len; i++) {
        if (arr[i] == item) {
            count++;
        }
    }
    return count;
}

function countAllOccurrences(arr, item) {
    return arr.filter(function(value) {
        return (value == item);
    }).length;
}

// 查找元素item在数组arr中的第一个位置
function indexOf(arr, item) {
    if (Array.prototype.indexOf) {
        return arr.indexOf(item);
    } else {
        for (var i = 0, len = arr.length; i < len; i++) {
            if (arr[i] === item) {
                return i;
            }
        }
    }
    return -1;
}

function indexOf(arr, item) {
    if (!Array.prototype.indexOf) { //IE8-
        Array.prototype.indexOf = function(searchElement, fromIndex) {
            var k;
            if (this == null) {
                throw new TypeError('"this" is null or not defined');
            }
            var o = Object(this);
            var len = o.length >>> 0;
            if (len === 0) {
                return -1;
            }
            var n = +fromIndex || 0;
            if (Math.abs(n) === Infinity) {
                n = 0;
            }
            if (n >= len) {
                return -1;
            }
            k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
            while (k < len) {
                if (k in o && o[k] === searchElement) {
                    return k;
                }
                k++;
            }
            return -1;
        };
    }
    return arr.indexOf(item);
}

// 查找元素item在数组arr中出现的所有位置
function getAllOccurrences(arr, item) {
    var result = [];
    for (var i = 0, len = arr.length; i < len; i++) {
        if (item == arr[i])
            result.push(i);
    }
    return result;
}

function getAllOccurrences(arr, item) {
    var result = [];
    arr.forEach(function(value, index) {
        if (value === item) {
            result.push(index);
        }
    });
    return result;
}

function getAllOccurrences(arr, item) {
    var index = arr.indexOf(item),
        result = [];
    while (index != -1) {
        result.push(index);
        index = arr.indexOf(item, index + 1);
    }
    return result;
}

// 移除数组arr中的所有值与item相等的元素。不要直接修改数组arr，结果返回新的数组。
function remove(arr, item) {
    var result = [];
    for (var i = 0, len = arr.length; i < len; i++) {
        if (arr[i] != item) {
            result.push(arr[i]);
        }
    }
    return result;
}

function remove(arr, item) {
    return arr.filter(function(value) {
        return (value !== item);
    });
}

// 移除数组arr中的所有值与item相等的元素，直接在给定的arr数组上进行操作，并将结果返回。
function remove(arr, item) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] == item) {
            //splice方法会改变数组长度，当删除一个元素后，后面的元素都会前移，因此需要相应减少i的值
            arr.splice(i, 1);
            i--;
        }
    }
    return arr;
}

// 在数组arr的index处添加元素item。不要直接修改数组arr，结果返回新的数组。
function insert(arr, item, index) {
    var result = arr.slice(0);
    result.splice(index, 0, item);
    return result;
}

// 在数组arr末尾添加元素item。不要直接修改数组arr，结果返回新的数组。
function append(arr, item) {
    var len = arr.length,
        result = [];
    for (var i = 0; i < len; i++) {
        result.push(arr[i]);
    }
    result.push(item);
    return result;
}

function append(arr, item) {
    var result = arr.slice(0);
    result.push(item);
    return result;
}

function append(arr, item) {
    return arr.concat(item);
}

// 在数组arr开头添加元素item。不要直接修改数组arr，结果返回新的数组。
function prepend(arr, item) {
    var len = arr.length,
        result = [];
    result.push(item);
    for (var i = 0; i < len; i++) {
        result.push(arr[i]);
    }
    return result;
}

function prepend(arr, item) {
    var result = arr.slice(0);
    result.unshift(item);
    return result;
}

function prepend(arr, item) {
    return [item].concat(arr);
}

// 删除数组arr最后一个元素。不要直接修改数组arr，结果返回新的数组。
function truncate(arr) {
    return arr.slice(0, arr.length - 1);
}

// 删除数组arr第一个元素。不要直接修改数组arr，结果返回新的数组。
function curtail(arr) {
    return arr.slice(1);
}

// 找出数组arr中重复出现过的元素
function duplicate(arr) {
    var result = [],
        len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        for (var j = i + 1; j < len; j++) {
            if (arr[i] == arr[j]) {
                if (isIn(result, arr[i]))
                    result.push(arr[i]);
            }
        }
    }
    return result;
}

function isIn(arr, item) {
    for (var i = 0, len = arr.length; i < len; i++) {
        if (arr[i] == item) {
            return true;
        }
    }
    return false;
}

function duplicate(arr) {
    var temp,
        a = [],
        b = [];
    for (var i = 0, aLen = arr.length; i < aLen; i++) {
        temp = arr[i];
        if (!b[temp]) {
            b[temp] = 1;
            continue;
        }
        b[temp]++;
    }
    for (i = 0, bLen = b.length; i < bLen; i++) {
        if (b[i] > 1) {
            a.push(i);
        }
    }
    return a;
}

function duplicate(arr) {
    var temp,
        result = [],
        len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        temp = arr[i];
        for (var j = i + 1; j < len; j++) {
            if (temp == arr[j] && result.indexOf(temp) == -1) {
                result.push(temp);
            }
        }
    }
    return result;
}

function duplicate(arr) {
    var result = [];
    arr.forEach(function(item) {
        if (arr.indexOf(item) != arr.lastIndexOf(item) && result.indexOf(item) == -1) {
            result.push(item);
        }
    });
    return result;
}
// console.log(duplicate([1, 1, 2, 3, 4, 4, 4, 5]));

// 删除数组arr中重复出现的元素。
function distinct(arr) {
    var i,
        j,
        result = [],
        len = arr.length;

    for (i = 0; i < len; i++) {
        for (j = i + 1; j < len; j++) {
            if (arr[i] === arr[j]) {
                break;
            }
        }
        if (j === len) {
            result.push(arr[i]);
        }
    }
    return result;
}

function distinct(arr) {
    for (var i = 0, len = arr.length; i < len - 1; i++) {
        for (var j = i + 1; j < len; j++) {
            if (arr[i] === arr[j]) {
                arr.splice(j, 1);
                i--;
                j--;
                len--;
            }
        }
    }
    return arr;
}

function distinct(arr) {
    var i,
        obj = {},
        result = [],
        len = arr.length;

    for (i = 0; i < len; i++) {
        if (!obj[arr[i]]) {
            obj[arr[i]] = 1;
            result.push(arr[i]);
        }
    }
    return result;
}

function distinct(arr) {
    var result = [],
        len = arr.length;
    arr.forEach(function(item, index, arr) {
        if (arr.indexOf(item, index + 1) === -1) {
            result.push(item);
        }
    });
    return result;
}

function distinct(array) {
    return Array.from(new Set(array));
}

// console.log(distinct([1, 2, 3, 4, 4, 1, 1, 2, 1, 1, 1]));

// 为数组arr中的每个元素求二次方。不要直接修改数组arr，结果返回新的数组。
function square(arr) {
    var result = [];
    for (var i = 0, len = arr.length; i < len; i++) {
        result[i] = arr[i] * arr[i];
    }
    return result;
}