JS数组

/*
* 修改原数组的方法
*
* pop() 删除数组的最后一个元素
* push()  在数组的尾部添加元素
* reverse() 颠倒数组中元素的位置
* shift() 删除数组中的第一个元素
* sort() 将数组中的元素排序
* splice() 将数组中插入,删除或替换元素
* unshift()  在数组的头部添加元素
*
* 不修改原数组的方法
*
* concat()  在数组的尾部添加元素，但该方法不修改原数组，返回一个新数组
* join(separator)   【separator 连接符】 将数组中的元素转换成字符串，并使用分隔符将这些元素连接起来
* slice()  获取数组中的一部分，并作为一个新数组返回
* toString() 将数组转换成，分隔的一个字符串
* valueOf() 返回数组对象中所存放的原始值
* indexOf() 返回数组对象中所存放的原始值
* lastIndexOf() 返回元素在数组中最后一次出现的位置
*
*
*
*
* */

//数组转换成字符串
console.log(list.toString()); //=>1,2,3,4,5,6

//通过连接符连接字符串
console.log(list.join("_")); //1_2_3_4_5_6

//在数组尾部添加元素
/*
concat(val1，val)  参数为值 参数按照出现次序添加数组的元素
                   参数为数组  将整个数组作为一个元素添加到数组之后
                   参数为数组，数组元素仍有数组



* */
console.log(list.concat(10,11,13)) //[1, 2, 3, 4, 5, 6, 10, 11, 13]
console.log(list.concat(temp)); //[1, 2, 3, 4, 5, 6, "a", "b", "c", "d"]
console.log(list.concat(tempList)); //[1, 2, 3, 4, 5, 6, Array(2), Array(2)]

//截取数组
/*
* slice(start,end) //start 数组开始下标，end数组结束上标
* */
console.log(list.slice(2,4));    // [3, 4]

//查找元素在数组中位置
/*
* indexOf  (查找的元素,查找的位置)
* lastIndexOf(查找的元素,查找的位置)
* */
console.log(list.indexOf(4,4)); //=>-1

//删除数组尾部元素
console.log(list,list.pop()); // [1, 2, 3, 4, 5]    6
//删除数组头部元素
console.log(list,list.shift())  //[2, 3, 4, 5]    1
//数组头部添加元素
console.log(list,list.unshift("unshift")) // ["unshift", 2, 3, 4, 5] 5
//数组尾部添加元素
console.log(list,list.push("push")) //["unshift", 2, 3, 4, 5, "push"] 6

//删除数组元素
/*
* splice(index,num) //index 删除元素的下标 ，num 从下标开始
* 要删除元素的个数，如果为0则不删除，如果省略删除从下标开始到结束的所有元素
* */
console.log(list,list.splice(0,1)) //[2, 3, 4, 5, "push"] ["unshift"]

//替换数组中的元素
/*
* splice(index,num,element) index 要替换元素的下标 num从下标开始要替换元素的个数 element 替换的元素
*
* */

console.log(list,list.splice(0,3,"替换")) //["替换", 5, "push"] (3) [2, 3, 4]

// 数组元素的排序

//颠倒数组元素
console.log(list,list.reverse()); //["push", 5, "替换"]

var listArray = [1,20,15,5,63,24];
console.log(listArray.sort(function (a,b) {
    console.log(a,b)
    return b-a;                                   //[63, 24, 20, 15, 5, 1]
}));
console.log(listArray.sort(function (a,b) {
    return a-b;                                   // [1, 5, 15, 20, 24, 63]
}));
//数组的遍历
/*

* every(callback,thisObjiect)
* 回调函数三个参数：元素值，元素索引，数组对象
*thisObjiect 定义函数的this对象
*
* 如果所有条件都满足条件则返回true,如果有一项不满足则不再检测，返回false
* */
var itemObj = listObj.every(function (item,index,list) {
    return item.age>0;
})

console.log(itemObj);
//判断是否是数组
console.log(isArray(listObj));
function isArray(array) {
    if(typeof Array.isArray == "undefined"){
        Array.isArray = function(array){
            return Object.prototype.toString.call(array) === "[object Array]";
        };
    }else{
       return Array.isArray(array);
    }
}
/*
* filter() 对每一项数组进行测试，根据函数结果构造一个新数组
* filter(callback,thisObjiect)
*
* */
var arrayTemp = listObj.filter(function (item,index,list) {
    if(item.age>2){
        return true;
    }else{
        return false;
    }
});
console.log("filter:",arrayTemp);

/*
* forEach()对每一项执行回调函数
*
* */

listObj.forEach(function (item,index,list) {

})

/*
*
* map()对数组中的每一项执行函数并构造一个新数组，其中包含与原始数组中的每一项的函数结果相对应
* 该方法遍历数组每一项，根据每一项返回值，该值将会被作为新数组的元素
* */

var mapTemp = listObj.map(function (item,index,list) {
    if(item.age>2){
        return {name:item.name,age:true};
    }else{
        return {name:item.name,age:false};
    }  
});
console.log("map:",mapTemp);


/*
*
* reduce()方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
* reduceRight() 方法从右到左
*
*
*
* */
var reduceList = [1,2,3,4,5,6];
var reduceTemp = reduceList.reduce(function (total,value,index,list) {
    console.log(total,value,index);
    return total*value;
});
console.log("reduce:",reduceTemp);


/*
*
* 数组去重
*
* */
//indexOf 去重
function uniquelList(array){
    var temp = [];
    for(var i=0;i<array.length;i++){
        if(temp.indexOf(array[i])===-1){
            temp.push(array[i]);
        }
    }
    return temp;
}
//indexOf方法：
Array.prototype.indexOf = function (item) {
    var result = -1;
    if(this.length==0){
        return result;
    };
    for(var i =0;i<this.length;i++){
        if(this[i]==item){
            result = i;
            break;
        }
    };
    return result;
}
//hash 或对象 去重法 速度快但占用内存大

function uniquelHash(array) {
    var tempObj= {};
    var result = [],val;
    for(var i =0;i<array.length;i++){
        val = array[i];
        if(!tempObj[val]){
            tempObj[val] = typeof val;
            result.push(val);
        }
    }
    return result;
}

//优化的方法
function unique(array) {
    var result = [];
    for(var i =0;i<array.length;i++){
        for(var j=i+1;j<array.length;j++){
            if(array[i]===array[j]){
                j=++i;
            }
        };
        result.push(array[i]);
    }

}

/*
*
* 类数组:拥有length属性，其它属性（索引）为非负整数(对象中的索引会被当做字符串来处理，这里你可以当做是个非负整数串来理解)
不具有数组所具有的方法
* */
//若是
Array.prototype.slice = function(start,end){
    var result = new Array();
    start = start || 0;
    end = end || this.length; //使用call之后this指向了类数组对象
    for(var i = start; i < end; i++){
        result.push(this[i]);
    }
    return result;
};

function toArray1(likeAry) {
    try {
        return Array.prototype.slice.call(likeAry);
    } catch (e) {
        var arr = [];
        for (var i = 0, len = likeAry.length; i < len; i++) {
            //arr.push(s[i]);
            arr[i] = likeAry[i];     //据说这样比push快
        }
        return arr;
    }
}



//ES5
function toArray2 (likeAry, start){
    start = start || 0
    var i = likeAry.length - start;
    var ary = new Array(i);
    while (i--) {
        ary[i] = likeAry[i + start]
    }
    return ary
}

//判断数组是否有重复的值
var isRepeat = function(arr) {  //arr是否有重复元素
    var hash = {};
    for (var i in arr) {
        if (hash[arr[i]]) {
            return true;
        }
        hash[arr[i]] = true;
    }
    return false;
};
//删除数组
function remove (arr, ele) {
    var index = arr.indexOf(ele);
    if(index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}