JavaScript常用数组操作方法，包含ES6方法

1. concat()

concat()方法用于连接两个或多个数组。该方法不会改变现有的数组，仅会返回被连接数组的一个副本

var arr1 = [1,2,3];
var arr2 = [4,5];
var arr3 = arr1.concat(arr2);
console.log(arr1); // [1,2,3]
console.log(arr3); // [1,2,3,4,5]

2. join()

join()方法用于把数组中所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的，默认使用’,'号分割，不改变原数组。

var arr = [1,2,3]
console.log(arr.join()) // 1,2,3
console.log(arr) // [1,2,3]

3. push()

push()方法可向数组的末尾添加一个或多个元素，并返回新的长度。末尾添加，返回的是长度，会改变原数组。

var a = [2,3,4];
var b = a.push(5);
console.log(a);  // [2,3,4,5]
console.log(b);  // 4

4. pop()

pop() 方法用于删除并返回数组的最后一个元素。返回最后一个元素，会改变原数组。

var arr = [2,3,4]
console.log(arr.pop()); // 4
console.log(arr); // [2,3]

5. shift()

shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的 值。返回第一个元素，改变原数组。

var arr = [2,3,4];
console.log(arr.shift()); //2
console.log(arr); // [3,4]

6. unshift()

unshift() 方法可向数组的开头添加一个或更多的元素，并返回新的长度。返回新的长度，改变原数组。

var arr = [2,3,4,5];
console.log(arr.unshift(3,6));  // 6
console.log(arr); // [3,6,2,3,4,5]

7. slice()

slice() 返回一个新的数组，包含从start 到 end(不包括该元素)的arrayObject中的元素。返回选定的元素，该方法不会修改原数组。

var arr = [2,3,4,5];
console.log(arr.slice(1,3)); // [3,4] 不包括 3
console.log(arr); // [2,3,4,5]

8. splice()

splice() 方法可以删除从index处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。如果从arrayObject中删除了元素，则返回的是含有被删除的元素的数组。splice()方法会直接对数组进行修改。

var a = [5,6,7,8];
console.log(a.splice(1,0,9)); // [] 从第 1开始删除，删除0个 替换成9
console.log(a); // [5,9,6,7,8]

var b = [5,6,7,8];
console.log(b.splice(1,2,3)); // [6,7] 从下表1开始删， 删除2个，替换成3
console.log(b) // [5,3,8]

9. substring() 和 substr()

相同点：如果只是写一个参数，两者的作用都一样：都是截取字符串从当前下标以后直到字符串最后的字符串片段

substr(startIndex);
substring(startIndex);
var str = '123456789';
console.log(str.substr(2)); // "3456789"
console.log(str.substring(2)); // "3456789"

不同点： 第二个参数
substr(startIndex,lenth): 第二个参数是截取字符串的长度（从起始点截取某个长度的字符串）；
substring(startIndex,endIndex)：第二个参数是截取字符串最终的下标（截取2个位置之间的字符串，“含头不含尾”）

var str = "123456789"
console.log(str.substr(2,5)); // "34567" // 从下标2开始截取 返回截取的5个数
console.log(str) // 123456789 不会改变原字符串

console.log(str.substring(2,5)); // "345" // 从下标2开始截取， 截取到下标5 不包括5
console.log(str) // 123456789 不会改变原字符串

10. sort排序

按照Unicode code 位置排序，默认升序

var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']

var scores = [1, 10, 21, 2];
scores.sort(); // [1, 10, 2, 21]

11. reverse()

reverse()方法用于颠倒数组中元素得顺序。返回得是颠倒后得数组，会改变原数组。

var arr = [2,3,4];
console.log(arr.reverse()); // [4,3,2]
conosle.log(arr); // [4,3,2]

12. indexOf 和 lastIndexOf

都接受两个参数:查找的值，查找起始位置
不存在，返回-1；存在返回位置。indexOf是从前往后查找，lastIndexOf是从后往前查找。
indexOf()

var a = [2,9,9]
a.indexOf(2); //0 查找的2 在下标0
a.indexOf(7); // -1 查找7没有 返回-1

if(a.indexOf(7) === -1){
	//元素在数组中不存在
}

lastIndexOf()

var numbers = [2,5,9,2];
number.lastIndexOf(2);  // 3从后往前数 在下标3
number.lastIndexOf(7);  // 从后往前数 没有7 返回-1
numbers.lastIndexOf(2, 3);  // 3
numbers.lastIndexOf(2, 2);  // 0
numbers.lastIndexOf(2, -2); // 0
numbers.lastIndexOf(2, -1); // 3

13. every

对数组的每一项都运行给定的函数，有一项为false就返回false,全为true 就返回true

function isBigEnough(element,index,array){
	return element < 10;
}
[2,5,8,3,4].every(isBigEnough); // true

// 数组如果有一个大于10就返回false
var arr = [2,5,8,3,11,4];
function isBigEnough(element,index,array){
    return element < 10;
}
var brr = arr.every(isBigEnough)
console.log(brr)

14. some

对数组的每一项都运行给定的函数，有一项为true，就为true,全没有就返回false。

function compare(element,index,array){
	return element > 10;
}
[2,5,8,1,4].some(compare); // false 全是false 返回false
[12,5,8,1,4].some(compare); // true 有一项是true 返回true

15. filter

对数组的每一项都运行给定的函数，返回结果为true的项 组成的数组

var words = ["spray", "limit", "elite", "exuberant", "destruction", "present", "happy"];
var longWords = words.filter(item=>{
	return item.length > 6;
})
// 过滤完 每个字符串的长度大于6的有 ["exuberant", "destruction", "present"];

16. map

对数组的每一项都运行给定的函数，返回每次函数调用的结果组成一个新数组, 不会改变老的数组

var numbers = [1,5,10,15]
var doubles = numbers.map(item=>{
	return item * 2;
})
// double [2,10,20,30] 新的 数组
// number [1,5,10,15] 老的数组

17. forEach数组遍历

const items = ['item1', 'item2', 'item3'];
const copy = [];
items.forEach(item=>{
	copy.push(item)
});

ES6新增新操作数组的方法

1. find():

传入一个回调函数，找到数组中符合当前搜索规则的第一个元素，返回它，并且终止搜索。

const arr = [1,"2",3,3,"2"]
console.log(arr.find(n => typeof n === "number")) // 1

const arr = ["2",5,3,3,"2"]
console.log(arr.find(n => typeof n === "number")) // 5

const arr = ["2",5,3,3,"2"]
console.log(arr.find(n => typeof n === "string"))  // 2

2. findIndex():

传入一个回调函数，找到数组中符合当前搜索规则的第一个元素，返回它的下标，终止搜索。

const arr = [1, "2", 3, 3, "2"]
console.log(arr.findIndex(n => typeof n === "number")) // 0

const arr = ["2",5,3,3,"2"]
console.log(arr.findIndex(n => typeof n === "number")) // 1

const arr = ["2",5,3,3,"2"]
console.log(arr.findIndex(n => typeof n === "string"))  // 0

3. fill():

用新元素替换掉数组内的元素，可以指定替换下标范围

arr.fill(value,start,end)

var arr = [1,2,3,4,5,6] 
var brr = arr.fill(9,1,3)
console.log(arr) // [1,9,9,4,5,6]  会改变原数组 
console.log(brr) // [1,9,9,4,5,6]  从start下标开始替换，提到到end 不包括end

4. copyWithin():

选择数组的某个下标，从该位置开始复制数组元素，默认从0开始复制。也可以指定要复制的元素范围。

// arr.copyWithin(target,start,end) // 目标 开始 结束
const arr = [1,2,3,4,5,6]
console.log(arr.copyWithin(3)) // [1,2,3,1,2,3] 从下标为3的元素开始，复制数组，所以4,5,6被替换成1,2,3

const arr1 = [1,2,3,4,5]
console.log(arr1.copyWithin(3,1)) // [1,2,3,2,3] 从下标为3的元素开始，复制数组，指定复制的第一个元素下标为1，所以4,5被替换成2,3

const arr2 = [1,2,3,4,5]
console.log(arr2.copyWithin(3,1,2)) // [1,2,3,2,5] 从下标为3的元素开始，复制数组，指定复制的第一个元素下标为1，结束位置为2，所以4被替换成2

5. from

将类似数组的对象 (array-like object) 和可遍历(iterable)的对象转为真正的数组

const bar = ["a","b","c"];
var arr = Array.from(bar);
console.log(arr) // ["a","b","c"]

var crr = Array.from('hello world')
console.log(crr) // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d"]

6. of()

用于将一组值，转换为数组。这个方法的主要目的，是弥补数组构造函数 Array()的不足。因为参数个数的不同，会导致Array()的行为有差异。

Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]
Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

7. entries() 返回迭代器：返回键值对

// 数组
const arr = ['a','b','c'];
for(let v of arr.entries()){
    console.log(v)
} 
// [0, 'a'] [1, 'b'] [2, 'c']

// Set
const arr = new Set(['a','b','c']);
for(let v of arr.entries()){
    console.log(v)
}
// ['a', 'a'] ['b', 'b'] ['c', 'c']

// Map
const arr = new Map();
arr.set('a','a');
arr.set('b','b');
for(let v of arr.entries()){
    console.log(v)
}
// ['a', 'a'] ['b', 'b']

8. values() 返回迭代器：返回键值对的value

// 数组
const arr = ['a','b','c'];
for(let v of arr.values()){
    console.log(v)
}
// 'a' 'b' 'c'

// Set
const arr = new Set(['a','b','c']);
for(let v of arr.values()){
    console.log(v)
}
// 'a' 'b' 'c'

//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.values()) {
  console.log(v)
}
// 'a' 'b'

9. keys() 返回迭代器：返回键值对的key

// 数组
const arr = ['a','b','c'];
for(let v of arr.keys()){
    console.log(v)
}
// 0 1 2

//Set
const arr = new Set(['a', 'b', 'c']);
for(let v of arr.keys()) {
  console.log(v)
}
// 'a' 'b' 'c'

//Map
const arr = new Map();
arr.set('a', 'a');
arr.set('b', 'b');
for(let v of arr.keys()) {
  console.log(v)
}
// 'a' 'b'

10. includes

判断数组中是否存在该元素，参数：查找的值、起始位置，可以替换ES5 时代的indexOf判断方式。indexOf判断元素是否为 NaN, 会判断错误。

var a = [1, 2, 3];
a.includes(2); // true
a.includes(4); // false