“我报名参加金石计划1期挑战——瓜分10万奖池，这是我的第2篇文章，点击查看活动详情”

改变原数组

改变原数组的有：push(),pop(),shift(),unshift(),soft(),revese(),splice()

push

push接收任意数量的参数，把它们逐个添加到数组末尾，并返回修改后数组的长度

var arr = ["1","2","3"]
var item = arr.push("4","5");
console.log(arr);  //["1", "2", "3", "4", "5"]
console.log(item); // 5    返回修改后数组的长度

pop

pop删除数组末尾最后一项，并返回删除元素的值

var arr = ["1","2","3"]
var item = arr.pop();
console.log(arr);  //["1", "2"]
console.log(item); //3   返回删除元素的值

shift

shift删除数组的第一项，并返回元素的值，如果数组为空就返回undenifed

var arr = ["1","2","3"]
var item = arr.shift();
console.log(arr);  //["2", "3"]
console.log(item); //1 f返回删除元素的值

unshift

unshift将参数添加到原数组开头，并返回数组的长度

var arr = ["1","2","3"]
var item = arr.shift();
console.log(arr);  //["2", "3"]
console.log(item); //1 f返回删除元素的值

soft

soft 默认按升序排列数组项，排序时会调用每个数组项的 toString() 转型方法，然后比较得到的字符串，以确定如何排序。即使数组中的每一项都是数值，sort() 方法比较的也是字符串(即按照UniCode码的顺序进行排序)

var arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort());     // ["a", "b", "c", "d"]
 
var arr2 = [13, 24, 51, 3];
console.log(arr2.sort());     // [13, 24, 3, 51]
console.log(arr2);  //(原数组被改变)         
//为了解决上述问题，sort() 方法可以接收一个比较函数作为参数
var arr2 = [13, 24, 51, 3];
console.log(arr2.sort((a,b) => {return b-a}));     // [51, 24, 13, 3]
//console.log(arr2.sort(function(a,b) {return b-a}));
console.log(arr2);

reverse

反转数组

var arr = [13, 24, 51, 3];
console.log(arr.reverse());        // [3, 51, 24, 13]
console.log(arr);                  // [3, 51, 24, 13](原数组改变)

splice

可以实现删除，插入，替换

删除：3 种参数：起始位置、要删除的项数和要插入的项（这里为空）。例如，splice(0,2) 会删除数组中的前两项

var arr = [1,2,3,4,5];
var arrRemoved = arr.splice(0,2);
console.log(arr);    //[3,4,5] 
console.log(arrRemoved); //[1,2]  返回删除两项的数组

插入：### 3 种参数：起始位置、要删除的项数（这里为0）和要插入的项。例如，splice(2,0,6,7) 会从当前数组的位置 2 开始插入6和7

var arr = [1,2,3,4,5]
var arrRemove2 = arr.splice(2,0,6,7);
console.log(arr); //[1, 2, 6, 7, 3, 4, 5]
console.log(arrRemove2); //[ ]

替换：3 种参数：起始位置、要删除的项数和要插入的项。例如，splice (1,1,6,7) 会删除当前数组位置 1 的项，然后再从位置 1 开始插入6和7。

var arr = [1,2,3,4,5];
var arrRemoved3 = arr.splice(1,1,6,7);
console.log(arr);              // [1, 6, 7, 3, 4, 5]
console.log(arrRemoved3);      // [2]

不会改变原数组

不会改变原数组的有：concat,silce,join,indexOf,lastIndexOf,forEach,map,filter,every,some,reduce,reduceRight

concat

var arr = [1,3,5,7];
var arrcopy = arr.concat(9,[11,13]);
console.log(arrcopy);   // [1, 3, 5, 7, 9, 11, 13]
console.log(arr);       // [1, 3, 5, 7](原数组未被修改)

slice

返回从原数组钟指定开始下标到结束下标的项组成的新数组,只有一个参数时，返回该参数位置开始到末尾的所有项

var arr = [1,3,5,7,9,11]
var arrCopy = arr.slice(1);
console.log(arrCopy);       // [3, 5, 7, 9, 11]
 
var arrCopy2 = arr.slice(1,4);
console.log(arrCopy2);      // [3, 5, 7]
 
var arrCopy3 = arr.slice(1,-2);
console.log(arrCopy3);      // [3, 5, 7]
 
var arrCopy4 = arr.slice(-4,-1);
console.log(arrCopy4);     // [5, 7, 9]

join

将数组的元素组成一个字符串，该方法之接受一个参数：分隔符（默认为逗号）

var arr = ["1","2","3"];
console.log(arr.join());    // 1,2,3
console.log(arr.join("-")); // 1-2-3
console.log(arr);    // [1, 2, 3]（原数组不变）

indexOf

var arr =[1,3,5,7,5,3,1];
console.log(arr.indexOf(5));    // 2
console.log(arr.indexOf(5,2));  // 2
console.log(arr.indexOf(5,3))   // 4

lastIndexOf

var arr = [1,3,5,7,5,3,1];
console.log(arr.lastIndexOf(5));   // 4
console.log(arr.lastIndexOf(5,4)); // 4
console.log(arr.lastIndexOf(5,3)); // 2
console.log(arr.lastIndexOf(5,2)); // 2
console.log(arr.lastIndexOf(5,1)); // -1

forEach

对数组进行遍历循环，参数是function类型，其中对应的参数是遍历的数组内容，对应的数组索引(可选)，数组本身(可选)

var arr = ["a","b","c"];
arr.forEach(function(x,index,a){
    console.log(x,index,a)
})

map

指“映射”，对数组中的每一项运行参数的函数，并返回每次函数调用的结果组成的数组

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(x){
    return x*x;
});
console.log(arr2);  // [1, 4, 9, 16, 25]

filter

指“过滤”，数组中的每一项运行参数的函数，并返回满足过滤条件组成的数组

var arr = [1,2,3,4,5]
var arr2 = arr.filter(function(x,index){
    return x > 3 || index < 2;
}) 
console.log(arr2); //[1,2,4,5]

every

判断数组中的每一项都是否满足条件，只有所有项都满足条件，才会返回true

var arr = [1,2,3,4,5];
var arr2 =arr.every((x) =>{
    return x<10;
});
console.log(arr2)  //true
 
var arr3 = arr.every((x) => {
    return x<3;
})
console.log(arr3)  //false

some

判断数组中是否存在条件的项，只要有一项满足，就会返回true

var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
    return x < 3;
}); 
console.log(arr2);  // true
 
var arr3 = arr.some(function(x) {
    return x < 1;
}); 
console.log(arr3);  // false

reduce

用来迭代一个数组，并且把它累积到一个值中

var  arr = [1, 2, 3, 4, 5];
sum = arr.reduce(function(prev, cur, index, arr) {
     //输出的是第一项的值或上一次叠加的结果，正在被处理的元素，正在被处理的元素的索引值
     console.log(prev, cur, index);  
     return prev + cur;
})
console.log(arr, sum); //输入数组本身和最后的结果
 
var numbers = [15.5, 2.3, 1.1, 4.7];
 
function getSum(total, num) {
    console.log("total, num="+total+" "+num)
    // total, num=0 15.5
    // total, num=16 2.3
    // total, num=18 1.1
    // total, num=19 4.7
    return total + Math.round(num);
}
function myFunction(item) {
    console.log(numbers.reduce(getSum, 0));//0  传递给函数的初始值
}
myFunction()//输出24

reduceRight

reduceRight 与reduce的方向反向

JavaScript -- 改变原数组&&不改变原数组