数组

数组中的常用方法

push,pop,shift,unshift,concat,tostring,reverse,sort,join,indexof,lastindexof...

按照四个维度记忆:

• 方法作用
• 方法参数
• 返回值
• 是否改变原数组

push

• 作用：向数组“末尾”追加新的内容
• 参数：追加的内容（可以是一个，也可是多个）
• 返回值：新增后数组的长度
• 是否改变原数组：是

let ary = [12.23.34]
ary.push(100,{name:'xxx'});
ary:[12,23,34,100,100,{name:'xxx'}] //=>6

pop

• 作用：删除数组最后一项
• 参数：无
• 返回值：被删除的那一项内容
• 是否改变原数组：是

shift

• 作用：删除数组中的第一项
• 参数：无
• 返回值：被删除的那一项内容
• 是否改变原数组：是

unshift

• 作用：向数组开始位置追加新内容
• 参数：要新增的内容(可以是一个，也可是多个）
• 返回值：新增后数组的长度
• 是否改变原数组：是

let ary = [12,23,34]
ary.unshift(100,true)
console.log(ary) //=>(5)[100,true,12,23,34]

splice
基于 SPLICE可以对数组进行很多的操作

1. 删除指定位置的内容
2. 指定位置增加内容
3. 修改指定位置的信息

ary.splice(n,m)

• 作用：向数组指定位置追加删除指定个内容
• 参数：开始位置n，项数m(不指定或者为0则删除到数组最后一个)
• 返回值：删除部分项组成的数组
• 是否改变原数组：是

ary.splice(n,0,x,...)

• 作用：从索引n开始删除零项（没删除），把x或者更多需要插入的内容存放到数组中索引n的前面
• 参数：开始位置n，项数m(m=0),插入内容x
• 返回值：空数组(因为一项也没删除)
• 是否改变原数组：是

var ary=[12,23,34,45,56,67,78,89];
ary.splice(3,0,111,1111,222,222,null); =>0 //因为一项都没有删除，所以返回空数组
ary => [12, 23, 34, 111, 1111, 222, 222, null, 45, 56, 67, 78, 89]

ary.splice(n,m,x,...)

• 作用：从索引n开始删除m，把x或者更多需要插入的内容存放到数组中索引n的前面
• 参数：开始位置n，项数m(不能为0),插入内容x
• 返回值：删除部分项组成的数组
• 是否改变原数组：是

  var ary=[12,23,34,45,56,67,78,89];
  ary.splice(2,3,8888) //从第二项开始，删除3项，然后替换为888
  ary => [12, 23, 8888, 67, 78, 89]

Arry.slice([start [, end [, contentType]]])

• 作用：在一个数组中，按照条件查找出其中的部分内容
• 参数：

• start:可选，规定从何处开始选取，如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
• end:可选，规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。

• 返回值：查找的内容组成的新数组
• 是否改变原数组：否

let ary=[12,23,34,45,56,67,78,89,90];

ary.slice(2,7)
//=>(5) [34, 45, 56, 67, 78]

ary.slice(2)
//=>(7)[34,45,56,67,78,89,90] 
//如果不写end，则查找到数组末尾

ary.slice()和ary.slice(0) 
//数组深克隆

ary.slice(-3,-1) 
//(2)[78,89] 
//slice()方法的参数中有负数，则用数组长度加上该数来确定相应的位置。
//如果结束位置小于起始位置，则返回空数组。
// 7+(-3)=4  7+(-1)=6
//所以等同于ary.slice(4,6) 

Array.concat(value1[, value2[, ...[, valueN]]])

• 作用：多个数组(或者值)的拼接
• 参数：数组或者值
• 返回值：拼接后的新数组
• 是否改变原数组：否

var alpha = ['a', 'b', 'c'];

var alphaNumeric = alpha.concat(1, [2, 3]);

console.log(alphaNumeric); 
// results in ['a', 'b', 'c', 1, 2, 3]

var num1 = [[1]];
var num2 = [2, [3]];
var num3=[5,[6]];

var nums = num1.concat(num2);

console.log(nums);
// results is [[1], 2, [3]]

var nums2=num1.concat(4,num3);

console.log(nums2)
// results is [[1], 4, 5,[6]]

// 修改开始项
num1[0].push(4);

console.log(nums);
// results is [[1, 4], 2, [3]]

Array.toString()

• 作用：把数组转换为字符串
• 参数：无
• 返回值：数组中的每一项用逗号分隔的字符串
• 是否改变原数组：否

Array.join([separator])

• 作用：指定一个字符串来分隔数组的每个元素。如果没有separator，数组元素用逗号分隔。如果separator是空字符串(" ")，则所有元素之间都没有任何字符。
• 参数：
• 返回值：一个所有数组元素连接的字符串。如果 arr.length =0，则返回空字符串。
• 是否改变原数组：否

var a = ['Wind', 'Rain', 'Fire'];
var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
var myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"
var myVar3 = a.join(' + '); // myVar3的值变为"Wind + Rain + Fire"
var myVar4 = a.join('');    // myVar4的值变为"WindRainFire"

Array.reverse()

• 作用：方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。
• 参数：无
• 返回值：颠倒后的数组。
• 是否改变原数组：是

Array.sort([compareFunction])

• 作用：数组的元素进行排序
• 参数：用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
• 返回值：
• 是否改变原数组：

//为了实现排序，sort()方法会调用每个数组项的 toString()方法，然后比较得到的字符串，以确定如何排序。
//即使数组中的每一项都是数值，sort()方法比较的也是字符串
var ary=[1,3,2,4,5,6,7,9,8];
ary.sort(); 
//=>[1,2,3,4,5,6,7,8,9]

var values = [0, 1, 5, 10, 15]; 
values.sort(); 
alert(values); //0,1,10,15,5 
//字符串比较时，"10"则位于"5"的前面，于是数组的顺序就被修改了

//=>真实项目中，基于sort排序，我们都需要传递参数
var ary=[18,1,23,27,2,35,3,56];
ary.sort(function (a,b){
    return a-b;//=>升序  
        //return b-a; 降序
});
//实际上等同于利用了比较函数
function compare(value1, value2) { 
 if (value1 < value2) { 
   return -1;  
//第一个参数应该位于第二个之前则返回一个负数
 } else if (value1 > value2) { 
   return 1; 
//如果第一个参数应该位于第二个之后则返回一个正数
 } else { 
   return 0; 
//如果两个参数相等则返回 0
 } 
} 

Array.indexOf(searchElement[, fromIndex])

• 作用：返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1
• 参数：

• searchElement:要查找的元素
• fromIndex:开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。 注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0。

• 返回值：索引
• 是否改变原数组：否

indexOf实际是基于===运算符进行查找的

var numbers = [1,2,3,4,5,4,3,2,1]; 
alert(numbers.indexOf(4)); //3 
alert(numbers.lastIndexOf(4)); //5 
alert(numbers.indexOf(4, 4)); //5 
alert(numbers.lastIndexOf(4, 4)); //3 
var person = { name: "Nicholas" }; 
var people = [{ name: "Nicholas" }]; 
var morePeople = [person]; 
alert(people.indexOf(person)); //-1 
alert(morePeople.indexOf(person)); //0 

迭代方法

迭代方法中的函数会接收三个参数：

• 数组项的值
• 该项在数组中的位置
• 数组对象本身。

根据使用的方法不同，这个函数执行后的返回值可能
会也可能不会影响方法的返回值。
Array.forEach(callback(item[, index [, array]])[, thisArg])
对数组中的每一项运行给定函数。
这个方法没有返回值。

Array.map(callback(item[, index [, array]])[, thisArg])
对数组中的每一项运行给定函数
返回每次函数调用的结果组成的数组。

var numbers = [1,2,3,4,5,4,3,2,1]; 
var mapResult = numbers.map(function(item, index, array){ 
 return item * 2; 
}); 
alert(mapResult); //[2,4,6,8,10,8,6,4,2]

Array.filter(callback(item[, index [, array]])[, thisArg])
对数组中的每一项运行给定函数
返回该函数会返回 true 的项组成的数组。

var numbers = [1,2,3,4,5,4,3,2,1]; 
var filterResult = numbers.filter(function(item, index, array){ 
 return (item > 2); 
}); 
alert(filterResult); //[3,4,5,4,3] 

Array.some(callback(item[, index [, array]])[, thisArg])
对数组中的每一项运行给定函数
如果该函数对任一项返回 true，则返回 true。

var someResult = numbers.some(function(item, index, array){ 
 return (item > 2); 
}); 
alert(someResult); //true 

Array.every(callback(item[, index [, array]])[, thisArg])
对数组中的每一项运行给定函数
如果该函数对每一项都返回 true，则返回 true。

var numbers = [1,2,3,4,5,4,3,2,1]; 
var everyResult = numbers.every(function(item, index, array){ 
 return (item > 2); 
}); 
alert(everyResult); //false 

归并方法

Array.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

• 作用：数组中的每个元素执行一个由您提供的函数(升序执行)，将其结果汇总为单个返回值。
• 参数：

• accumulator:上一次调用回调时的返回值，或initialValue
• currentValue:数组中正在处理的元素。
• index:数组中正在处理的元素的索引。 如果提供了initialValue:则起始索引号为0，否则从索引1起始。
• array:调用函数的数组
• initialValue:作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用函数将报错。

var arr = [1, 2, 3, 4];
var sum = arr.reduce(function(prev, cur, index, arr) {
    console.log(prev, cur, index);
    return prev + cur;
})
console.log(arr, sum);
//1 2 1
//3 3 2
//6 4 3
//[1, 2, 3, 4] 10

var  arr = [1, 2, 3, 4];
var sum = arr.reduce(function(prev, cur, index, arr) {
    console.log(prev, cur, index);
    return prev + cur;
}，0) //注意这里设置了初始值
console.log(arr, sum);
//0 1 0
//1 2 1
//3 3 2
//6 4 3
//[1, 2, 3, 4] 10
//其实看cur就知道了，有initvalue的话cur从0开始，无Init从1开始