有关数组的一些方法

1、有关修改的方法：

• pop()

删除数组的最后一个元素，并返回这个元素：

var a = [1,2,3,4];
a.pop();//去除了数组中的4
console.log(a);//返回值为 [1,2,3]

• push()

在数组的末尾增加一个或者多个元素，并返回数组的新长度

var a = [];
a.push(1,2,3);//返回数组长度
console.log(a);//[1,2,3]

• reverse()

颠倒数组中元素的排列顺序

var a = [1,2,3];
a.reverse();//[3,2,1]

• shift()

删除数组的第一个元素，并返回这个数组

var a = [1,2,3];
a.shift();    //1
console.log(a);    //[2,3]

• sort()

对数组元素进行排序，并返回当前数组

//数组是字母
var a = ['banana', 'cherry', 'apple']
a.sort()
console.log(a) // ['apple', 'banana', 'cherry']
// 数组是数字
var b = [33, 4, 1111, 222]
b.sort()
console.log(b) // [1111, 222, 33, 4] 首个数字进行排序

b.sort(function(a, b){
    return a-b
})
console.log(b) // [4, 33, 222, 1111] 从小到大排序

b.sort(function(a, b){
    return b-a
})
console.log(b) // [1111, 222, 33, 4] 从大到小排序

• splice()

在任意位置给数组添加或删除任意一个元素

var a = [1, 2, 3, 4, 5, 6, 7, 8]
a.splice(4) // [5, 6, 7, 8]
console.log(a) // [1, 2, 3, 4] 会改变原数组

var b = [1, 2, 3, 4]
b.splice(1, 2) // [2, 3]
console.log(b) // [1, 4]

var c = [1, 2, 3, 4, 5]
c.splice(2, 0, 'a', 'b') // []
console.log(c) // [1, 2, 'a', 'b', 3, 4, 5]

• unshift()

在数组的开头增加一个或者多个元素，并返回数组的新长度

var a = [1, 2, 3]
a.unshift(0) // 4
console.log(a) // [0, 1, 2, 3]

• copyWithin()

这是ES6中的方法，在数组内部，将一段元素序列拷贝到另外一段元素序列上，覆盖原有的值

var a = [1, 2, 3, 4, 5]
a.copyWithin(0, 3)
console.log(a) // [4, 5, 3, 4, 5]
// 可以接受三个参数 Array.copyWithin(target[, start][, end])
// target(必须): 从该位置开始替换数据, 如果为负数, 表示倒数
// start(可选): 从该位置开始读取数据,默认为0. 如果为负数, 表示倒数
// end(可选): 到该位置前停止读取数据, 默认等于数组长度. 如果为负值,表示倒数
var b = [1, 2, 3, 4, 5]
b.copyWithin(0, -2, -1)
console.log(b) // [4, 2, 3, 4, 5]

• fill()

ES6中的方法，将数组中指定区间的所有元素的值，都替换成某个固定的值

var a = ['a', 'b', 'c']
a.fill(7) // 传一个参数时, 数组内的每一项都会被7替换
console.log(a) // [7, 7, 7]

var b = ['d', 'e', 'f']
b.fill(7, 1) // 传两个参数, 第一个表示使用该参数去替换, 第二个表示从该索引开始直到最后
console.log(b) // ['d', 7, 7]

var c = ['g', 'h', 'i']
c.fill(7, 1, 2) // 传3个参数时, 第一个参数代表使用该参数去替换, 第二个参数表示从该索引开始, 
console.log (c) // ['c', 7, 'e']

2、访问的方法

• concat()

返回一个有当前数组和其他若干个数组或者若干个非数组值组合而成的新数组

var a =[1, 2, 3]
a.concat(4, 5) // [1, 2, 3, 4, 5]
console.log(a) // [1, 2, 3] 不会改变原数组
a.concat([4, 5]) // [1, 2, 3, 4, 5]
a.concat([4, 5], [6, 7]) // [1, 2, 3, 4, 5, 6, 7]
a.concat(4, [5, [6, 7]]) // [1, 2, 3, 4, 5, [6, 7]]

• includes()

ES6中的方法，判断当前数组是否包含某个指定的值，返回值为true或false

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

• indexOf()

返回数组中第一个与指定值相等的元素的索引，如果找不到则返回-1

var a = [0, 1, 2, 1, 0]；
var c = a.indexOf(5);
var b = a.indexOf(1)；
console.log(b)     // 1
console.log(c)    //-1

• join()

连接数组所有元素组成一个字符串

var a = [1, 2, 3]
a.join() // '1, 2, 3'
a.join('') // '123'
a.join(' ') // '1 2 3'

• slice()

抽取当前数组中的一段元素组合成一个新的数组

var a = [1, 2, 3, 4, 5]
a.slice(0, 3) // [1, 2, 3] 第一个参数是索引,第二个参数为正数n,代表截取n个
a.slice(3) // [4, 5] 只传一个参数m,代表从索引从m开始截取,到最后
a.slice(1, -1) // [2, 3, 4] 如果第二个参数为负数-n,则代表从截取到倒数n+1个

• lastIndexOf()

返回数组中的最后一个（从右边数第一个）与指定值相等的元素的索引，如果找不到，则返回-1

var a = [0, 1, 2, 1, 0]
var b = a.lastIndexOf(1)
console.log(b) // 3

• toLocaleString()

返回一个由所有数组元素组合而成的本地化后的字符串，遮蔽了原型链上的

var a = [1, 2, 3]
a.toLocaleString() // '1, 2, 3'
console.log(a) // [1, 2, 3] 不改变原数组

var b = [1, [2, 'c']]
b.toLocaleString() // '1, 2, c'
console.log(b.toLocaleString());

• toString()

返回一个由所有数组元素组合而成的字符串，遮蔽了原型链上的

var a = [1, 2, 3]
a.toString() // '1, 2, 3'
console.log(a) // [1, 2, 3] 不改变原数组

var b = [1, [2, 'c']]
b.toString() // '1, 2, c

3、迭代方法

• entries()

返回一个数组迭代器对象, 该迭代器会包含所有数组元素的键值对

var a = ['apple', 'banana', 'cherry']
// a.entries() 返回Iterator遍历器对象, 可以使用for...of循环遍历
for(let [index, item] of a.entries()){
    console.log(index, item)
}
// 0 'apple'
// 1 'banana'
// 2 'cherry'

• every()

如果数组中的每个元素都满足测试函数, 则返回 true, 否则返回 false

var a = [1, 2, 3, 4, 5]
var b = a.every(function(item){
    return item < 10
})
console.log(b) // true

• filter()

将所有在过滤函数中返回 true 的数组元素放进一个新数组中,并返回

var a = [1, 2, 3, 4]
var b = a.filter(function(item){
    return item > 2
})
console.log(b) // [3, 4]

• find()

找到第一个满足测试函数的元素并返回那个元素的值, 如果找不到, 则返回 undefined

var a = [1, 2, 3, 4, 5]
a.find(function(item){
    return item > 2
}) // 3

• findIndex()

找到第一个满足测试函数的元素并返回那个元素的索引, 如果找不到, 则返回-1

var a = [5, 2, 7, 8, 9]
a.findIndex(function(item){
    return item > 5
}) // 2

• forEach()

为数组中的每个元素执行一次回调函数

// 将a内的每一项相加
var a = [1, 2, 3, 4, 5]
var sum = 0;
a.forEach(function(value){
    sum += value
})
console.log(sum) // 15

var b = []
a.forEach(function(value, index){
    b[index] = value
})
console.log(b) //

• keys()

返回一个数组迭代器对象, 该迭代器会包含所有数组元素的键

var a = ['apple', 'banana']
// a.keys 返回Iterator遍历器对象,可以使用for...of遍历
for(let index of a.keys()){
    console.log(index)
}
// 0
// 1

• map()

返回一个由调函数的返回值组成的新数组

var a = [1, 2, 3]
b = a.map(function(item){
    return item * item
})
console.log(b) // [1, 4, 9]

• reduce()

从左到右为每个数组元素执行一次回调函数, 并把上次回调函数的返回值放在一个暂存器中传给下次回调函数, 并返回最后一次回调函数的返回值

var a = [1, 2, 3, 4]
var sum = a.reduce(function(x, y){
    return x + y
}, 5)
console.log(sum) // 15 如果传入第二个参数,则第二个参数也会执行回调函数

• reduceRight()

从右到左为每个数组元素执行一次回调函数, 并把上次回调函数的返回值 放在一个暂存器中传给下次回调函数,并返回最后一次回调函数的返回值

var a = [2, 3, 4] // 计算2^(3^4)
var b = a.reduceRight(function(a, b){
    return Math.pow(b, a)
})
console.log(b) // 2.4178516392292583e+24

• some()

如果数组中至少有一个元素满足测试函数, 则返回 true, 否则返回 false

var a = [1, 2, 3, 4, 5]
var b =a.some(function(item){
    return item % 2 ===0 
})
console.log(b) // true

• values()

返回一个数组迭代器对象, 该迭代器会包含所有数组元素的值

var a = ['apple', 'banana']
// a.values 返回Iterator遍历器对象,可以使用for...of遍历
for(let item of a.values()){
    console.log(item)
}
// 'apple'
// 'banana'