21、push() 的使用
push() 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。
语法：arr.push(element1, ..., elementN)
参数：
|--- elementN：被添加到数组末尾的元素。返回值：
|--- 当调用该方法时，新的length属性值将被返回。
实例1：添加元素到数组
var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");
console.log(sports); // ["soccer", "baseball", "football", "swimming"]
console.log(total); //4
实例2：合并两个数组
//注意：当第二个数组(如示例中的moreVegs)太大时不要使用这个方法来合并数组，
// 因为事实上一个函数能够接受的参数个数是有限制的。具体可以参考 apply() 。
var vegetables = ['parsnip', 'potato'];
var moreVegs = ['celery', 'beetroot'];
// 将第二个数组融合进第一个数组
// 相当于 vegetables.push('celery', 'beetroot');
Array.prototype.push.apply(vegetables, moreVegs);
console.log(vegetables);
// ['parsnip', 'potato', 'celery', 'beetroot']
实例3：像数组一样使用对象
var obj = {
length: 0,
addElem: function(elem){
// obj.length 长度自动递增
// 每次添加一个元素
[].push.call(this, elem);
}
};
// 添加一些空对象来说明。
obj.addElem({});
obj.addElem({});
console.log(obj.length);
// → 2
22、reduce() 的使用
reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。
语法：arr.reduce(callback(accumulator, currentValue[, index[, array]] ) [ , initialValue])
参数：
|--- callback：执行数组中每个值的函数，包含四个参数：
|--- accumulator：累计器，累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue；
|--- currentValue：数组中正在处理的元素；
|--- currentIndex：可选，数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则为1；
|--- array：调用reduce()的数组；
|---initialValue：可选，作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错；返回值：
|--- 函数累计处理的结果。注意：如果没有提供initialValue，reduce 会从索引1的地方开始执行 callback 方法，跳过第一个索引。如果提供initialValue，从索引0开始
描述
reduce为数组中的每一个元素依次执行callback函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：
- accumulator 累计器
- currentValue 当前值
- currentIndex 当前索引
- array 数组
回调函数第一次执行时，accumulator 和currentValue的取值有两种情况：如果调用reduce()时提供了initialValue，accumulator取值为initialValue，currentValue取数组中的第一个值；如果没有提供 initialValue，那么accumulator取数组中的第一个值，currentValue取数组中的第二个值。
提供初始值通常更安全，正如下面的例子，如果没有提供initialValue，则可能有三种输出：
var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x ); var maxCallback2 = ( max, cur ) => Math.max( max, cur ); // reduce() 没有初始值 var res1 = [ { x: 22 }, { x: 42 } ].reduce( maxCallback ); console.log(res1);// 42 var res2 = [ { x: 22 } ].reduce( maxCallback ); console.log(res2);// { x: 22 } [ ].reduce( maxCallback ); // TypeError // map/reduce; 这是更好的方案，即使传入空数组或更大数组也可正常执行 var res3 = [ { x: 22 }, { x: 42 } ].map( el => el.x ) .reduce( maxCallback2, -Infinity ); console.log(res3); //42reduce() 如何运行：
假如运行下段reduce()代码：[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array){ return accumulator + currentValue; });callback 被调用四次，每次调用的参数和返回值如下表：
callback accumulator currentValue currentIndex array return value first call 0 1 1 [0, 1, 2, 3, 4] 1 second call 1 2 2 [0, 1, 2, 3, 4] 3 third call 3 3 3 [0, 1, 2, 3, 4] 6 fourth call 6 4 4 [0, 1, 2, 3, 4] 10
实例1：数组里所有值的和
var sum = [0, 1, 2, 3].reduce(
( acc, cur ) => acc + cur , 0);
console.log(sum); // 和为 6
实例2：累加对象数组里的值
//要累加对象数组中包含的值，必须提供初始值，以便各个item正确通过你的函数。
var initialValue = 0;
var sum = [{x: 1}, {x:2}, {x:3}].reduce(
(acc, cur)=> acc + cur.x, initialValue)
console.log(sum) // logs 6
实例3：将二维数组转化为一维
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
( acc, cur ) => acc.concat(cur),[]
);
console.log(flattened);//[0, 1, 2, 3, 4, 5]
实例4：计算数组中每个元素出现的次数
var names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
var countedNames = names.reduce( (allNames, name) =>{
if (name in allNames) {
allNames[name]++;
}
else {
allNames[name] = 1;
}
return allNames;
}, {});
console.log(countedNames)
// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }
实例4：按属性对object分类
var people = [
{ name: 'Alice', age: 21 },
{ name: 'Max', age: 20 },
{ name: 'Jane', age: 20 }
];
function groupBy(objectArray, property) {
return objectArray.reduce( (acc, obj) =>{
var key = obj[property];
if (!acc[key]) {
acc[key] = [];
}
acc[key].push(obj);
return acc;
}, {});
}
var groupedPeople = groupBy(people, 'age');
console.log(groupedPeople);
/* 结果:
{
20: [
{ name: 'Max', age: 20 },
{ name: 'Jane', age: 20 }
],
21: [{ name: 'Alice', age: 21 }]
}
*/
实例5：使用扩展运算符和initialValue绑定包含在对象数组中的数组
var friends = [{
name: 'Anna',
books: ['Bible', 'Harry Potter'],
age: 21
}, {
name: 'Bob',
books: ['War and peace', 'Romeo and Juliet'],
age: 26
}, {
name: 'Alice',
books: ['The Lord of the Rings', 'The Shining'],
age: 18
}];
var allbooks = friends.reduce(
(prev, curr) => [...prev, ...curr.books], ['Alphabet']
);
console.log(allbooks);
/*
["Alphabet", "Bible", "Harry Potter", "War and peace",
"Romeo and Juliet", "The Lord of the Rings", "The Shining"]
*/
实例6：数组去重
let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
let result = arr.sort().reduce((init, current) => {
if(init.length === 0 || init[init.length-1] !== current) {
init.push(current);
}
return init;
}, []);
console.log(result); //[1,2,3,4,5]
实例7：按顺序运行Promise
/**
* 从可以返回的promises函数数组中运行promises
* 以链接的方式
*
* @param {array} arr - promise 数组
* @return {Object} promise 对象
*/
function runPromiseInSequence(arr, input) {
return arr.reduce(
(promiseChain, currentFunction) => promiseChain.then(currentFunction),
Promise.resolve(input)
);
}
// promise function 1
function p1(a) {
return new Promise((resolve, reject) => {
resolve(a * 5);
});
}
// promise function 2
function p2(a) {
return new Promise((resolve, reject) => {
resolve(a * 2);
});
}
// function 3 - will be wrapped in a resolved promise by .then()
function f3(a) {
return a * 3;
}
// promise function 4
function p4(a) {
return new Promise((resolve, reject) => {
resolve(a * 4);
});
}
const promiseArr = [p1, p2, f3, p4];
runPromiseInSequence(promiseArr, 10)
.then(console.log); // 1200
实例8：功能型函数管道
const double = x => x + x;
const triple = x => 3 * x;
const quadruple = x => 4 * x;
const pipe = (...functions) => input => functions.reduce(
(acc, fn) => fn(acc),
input
);
// 用于特定值乘法的组合函数
const multiply6 = pipe(double, triple);
const multiply9 = pipe(triple, triple);
const multiply16 = pipe(quadruple, quadruple);
const multiply24 = pipe(double, triple, quadruple);
// 使用
console.log(multiply6(6));; // 36
console.log(multiply9(9));; // 81
console.log(multiply16(16));; // 256
console.log(multiply24(10));; // 240
23、reduceRight() 的使用
reduceRight() 方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。
语法：arr.reduceRight(callback[, initialValue])
参数：
|--- callback：一个回调函数，用来操作数组中的每个元素，可接受四个参数：
|--- previousValue：上一次调用回调的返回值，或提供的 initialValue；
|--- currentValue：当前被处理的元素；
|--- index：当前处理元素的索引；
|--- array：调用 reduce 的数组；
|---initialValue：可作为第一次调用回调 callback 的第一个参数；返回值：
|--- 执行之后的返回值。
实例1：求一个数组中所有值的和
var total = [0, 1, 2, 3].reduceRight(
(a, b) => a + b
);
console.log(total); // total == 6
实例2：扁平化（flatten）一个元素为数组的数组
var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(
(a, b) => a.concat(b), []
);
console.log(flattened); //[4, 5, 2, 3, 0, 1]
实例3： reduce 与 reduceRight 之间的区别
var a = ['1', '2', '3', '4', '5'];
var left = a.reduce( (prev, cur) => prev + cur );
var right = a.reduceRight((prev, cur) => prev + cur);
console.log(left); // "12345"
console.log(right); // "54321"
24、reverse() 的使用
reverse() 方法将数组中元素的位置颠倒，并返回该数组。该方法会改变原数组。
语法：arr.reduceRight(callback[, initialValue])
参数：
|--- 无；返回值：
|---返回该数组。
实例1： 颠倒数组中的元素
//创建数组 sourceArray，其包含三个元素，然后颠倒该数组
var sourceArray = ['one', 'two', 'three'];
var reverseArray = sourceArray.reverse();
console.log(sourceArray ) // ['three', 'two', 'one']
console.log(sourceArray === reverseArray); // true
25、shift() 的使用
shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
语法：arr.shift()
参数：
|--- 无；返回值：
|---返回被删除的值。
实例1： 移除数组中的一个元素
let myFish = ['A', 'B', 'C', 'D'];
console.log('调用 shift 之前: ' + myFish);
// "调用 shift 之前: A,B,C,D"
var shifted = myFish.shift();
console.log('调用 shift 之后: ' + myFish);
// "调用 shift 之后: B,C,D
console.log('被删除的元素: ' + shifted);
// "被删除的元素: A"
26、slice() 的使用
slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。
语法：arr.slice([begin[, end]])
参数：
|--- begin：可选。提取起始处的索引，从该索引开始提取原数组元素，默认为 0。
如果该参数为负数，则表示从原数组中的倒数 第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
如果省略 begin，则 slice 从索引 0 开始。
如果 begin 大于原数组的长度，则会返回空数组。|--- end：可选。提取终止处的索引，在该索引处结束提取原数组元素，默认为 0。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。
slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引为 1, 2, 3的元素）。
如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。
如果 end 被省略，则slice 会一直提取到原数组末尾。
如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。返回值：
|--- 一个含有被提取元素的新数组。
实例1：返回现有数组的一部分
var fruits = ['A', 'B', 'C', 'D', 'E'];
var citrus = fruits.slice(1, 3);
console.log(citrus); //["B", "C"]
实例2：使用 slice
var myHonda = { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } };
var myCar = [myHonda, 2, "cherry condition", "purchased 1997"];
var newCar = myCar.slice(0, 2);
// 输出 myCar、newCar 以及各自的 myHonda 对象引用的 color 属性。
console.log(' myCar = ' + JSON.stringify(myCar));
console.log('newCar = ' + JSON.stringify(newCar));
console.log(' myCar[0].color = ' + JSON.stringify(myCar[0].color));
console.log('newCar[0].color = ' + JSON.stringify(newCar[0].color));
// 改变 myHonda 对象的 color 属性.
myHonda.color = 'purple';
console.log('The new color of my Honda is ' + myHonda.color);
//输出 myCar、newCar 中各自的 myHonda 对象引用的 color 属性。
console.log(' myCar[0].color = ' + myCar[0].color);
console.log('newCar[0].color = ' + newCar[0].color);
输出结果：
myCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2,
'cherry condition', 'purchased 1997']
newCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2]
myCar[0].color = red
newCar[0].color = red
The new color of my Honda is purple
myCar[0].color = purple
newCar[0].color = purple
实例3：类数组（Array-like）对象
/**
* slice 方法可以用来将一个类数组（Array-like）对象/集合转换成一个新数组。
* 只需将该方法绑定到这个对象上。
*/
function list() {
// return Array.prototype.slice.call(arguments);
//可以简单的使用 [].slice.call(arguments) 来代替Array.prototype
return [].slice.call(arguments);
}
var list1 = list(1, 2, 3);
console.log(list1); // [1, 2, 3]]
27、some() 的使用
some() 方法测试是否至少有一个元素可以通过被提供的函数方法。该方法返回一个Boolean类型的值。
语法：arr.some(callback(element[, index[, array]])[, thisArg])
参数：
|--- callback：用来测试每个元素的函数，接受三个参数：
|--- previousValue：数组中正在处理的元素；
|--- index ：可选。数组中正在处理的元素的索引值；
|--- array：可选。 some()被调用的数组；
|---thisArg：可选。执行 callback 时使用的 this 值；返回值：
|--- 如果回调函数返回至少一个数组元素的 truthy 值，则返回 true；否则为 false。
实例1：测试数组元素的值
/*
检测在数组中是否有元素大于 10
*/
function isBiggerThan10(element, index, array) {
return element > 10;
}
var t1 = [2, 5, 8, 1, 4].some(isBiggerThan10); // false
var t2 = [12, 5, 8, 1, 4].some(isBiggerThan10); // true
console.log(t1); // false
console.log(t2); // true
/******************************************************/
//箭头函数写法
[2, 5, 8, 1, 4].some(x => x > 10); // false
[12, 5, 8, 1, 4].some(x => x > 10); // true
实例2：判断数组元素中是否存在某个值
/*
模仿 includes()方法, 若元素在数组中存在, 则回调函数返回值为 true
*/
var fruits = ['A', 'B', 'C', 'D'];
function checkAvailability(arr, val) {
return arr.some(
arrVal => val === arrVal
);
}
console.log(checkAvailability(fruits, 'E')); // false
console.log(checkAvailability(fruits, 'C')); // true
实例3：将任意值转换为布尔类型
var TRUTHY_VALUES = [true, 'true', 1];
function getBoolean(value) {
'use strict';
if (typeof value === 'string') {
value = value.toLowerCase().trim();
}
return TRUTHY_VALUES.some(
t => t === value
);
}
getBoolean(false); // false
getBoolean('false'); // false
getBoolean(1); // true
getBoolean('true'); // true
28、sort() 的使用
sort() 方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的
由于它取决于具体实现，因此无法保证排序的时间和空间复杂性
语法：arr.sort([compareFunction])
参数：
|--- compareFunction：可选。用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
|--- firstEl：第一个用于比较的元素；
|--- secondEl：第二个用于比较的元素；返回值：
|---排序后的数组。请注意，数组已原地排序，并且不进行复制。
实例1：使用函数表达式书写
//要比较数字而非字符串，比较函数可以简单的以 a 减 b
var numbers = [4, 2, 5, 1, 3];
numbers.sort((a, b) => a - b);
console.log(numbers); // [1, 2, 3, 4, 5]
实例2：对象可以按照某个属性排序
var items = [
{ name: 'Edward', value: 21 },
{ name: 'Sharpe', value: 37 },
{ name: 'And', value: 45 },
{ name: 'The', value: -12 },
{ name: 'Magnetic' },
{ name: 'Zeros', value: 37 }
];
// 通过值排序
items.sort((a, b)=>(a.value - b.value));
// 通过名字排序
items.sort((a, b) => {
var nameA = a.name.toUpperCase(); // 忽略大小写
var nameB = b.name.toUpperCase(); // 忽略大小写
if (nameA < nameB) {
return -1;
}
if (nameA > nameB) {
return 1;
}
// 名字相同
return 0;
});
实例3：数字数组分别指定与不指定比较函数的结果
var stringArray = ["Blue", "Humpback", "Beluga"];
var numberArray = [40, 1, 5, 200];
var numericStringArray = ["80", "9", "700"];
var mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];
console.log('字符串数组：' + stringArray.join());//字符串数组：Blue,Humpback,Beluga
console.log('排序后的：' + stringArray.sort()); //排序后的：Beluga,Blue,Humpback
console.log('数字数组：' + numberArray.join());//数字数组：40,1,5,200
console.log('没有回调函数：'+ numberArray.sort());//没有回调函数：1,200,40,5
console.log('使用回调函数：'+ numberArray.sort((a,b) => a-b ));//使用回调函数：1,5,40,200
console.log('数字字符串数组：'+ numericStringArray.join());//数字字符串数组：80,9,700
console.log('没有回调函数：'+ numericStringArray.sort());//没有回调函数：700,80,9
console.log('使用回调函数：'+ numericStringArray.sort((a,b) => a-b ));//使用回调函数：9,80,700
console.log('混合数值数组: '+ mixedNumericArray.join());//混合数值数组: 80,9,700,40,1,5,200
console.log('没有回调函数：'+ mixedNumericArray.sort());//没有回调函数：1,200,40,5,700,80,9
console.log('使用回调函数：'+ mixedNumericArray.sort((a,b) => a-b ));//使用回调函数：1,5,9,40,80,200,700
实例4：使用映射改善排序
compareFunction 可能需要对元素做多次映射以实现排序，尤其当 compareFunction 较为复杂，且元素较多的时候，某些 compareFunction 可能会导致很高的负载。使用 map 辅助排序将会是一个好主意。基本思想是首先将数组中的每个元素比较的实际值取出来，排序后再将数组恢复。
// 需要被排序的数组
var list = ['Delta', 'alpha', 'CHARLIE', 'bravo'];
// 对需要排序的数字和位置的临时存储
var mapped = list.map( (el, i) =>(
{ id: i, value: el.toLowerCase() }
))
/*
0: {id: 0, value: "delta"}
1: {id: 1, value: "alpha"}
2: {id: 2, value: "charlie"}
3: {id: 3, value: "bravo"}
*/
// 按照多个值排序数组
mapped.sort(
(a, b) => (+(a.value > b.value) || +(a.value === b.value) - 1)
);
console.log(mapped);
/*
0: {id: 1, value: "alpha"}
1: {id: 3, value: "bravo"}
2: {id: 2, value: "charlie"}
3: {id: 0, value: "delta"}
*/
// 根据索引得到排序的结果
var result = mapped.map(
(el, index) => list[el.id]
);
console.log(result);
29、splice() 的使用
splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
语法：array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
参数：
|--- start：指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位；
|--- deleteCount：可选。整数，表示要移除的数组元素的个数。
如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
|--- item1, item2, ...：可选。要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。返回值：
|--- 由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
实例1：从第 2 位开始删除 0 个元素，插入“E”
var myFish = ["A", "B", "C", "D"];
var removed = myFish.splice(2, 0, "E");
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["A", "B", "E", "C", "D"]
// 被删除的元素: [], 没有元素被删除
实例2：从第 2 位开始删除 0 个元素，插入“E” 和 "F"
var myFish = ["A", "B", "C", "D"];
var removed = myFish.splice(2, 0, "E", "F");
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["A", "B", "E", "F", "C", "D"]
// 被删除的元素: [], 没有元素被删除
实例3：从第 3 位开始删除 1 个元素
var myFish = ['A', 'B', 'C', 'D', 'E'];
var removed = myFish.splice(3, 1);
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["A", "B", "C", "E"]
// 被删除的元素: ["D"]
实例4：从第 2 位开始删除 1 个元素，插入“E”
var myFish = ['A', 'B', 'C', 'D'];
var removed = myFish.splice(2, 1, "E");
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["A", "B", "E", "D"]
// 被删除的元素: ["C"]
实例5：从第 0 位开始删除 2 个元素，插入"E"、"F"和"G"
var myFish = ['A', 'B', 'C', 'D'];
var removed = myFish.splice(0, 2, 'E', 'F', 'G');
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["E", "F", "G", "C", "D"]
// 被删除的元素: ["A", "B"]
实例6：从第 2 位开始删除 2 个元素
var myFish = ['A', 'B', 'C', 'D', 'E'];
var removed = myFish.splice(myFish.length - 3, 2);
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["A", "B", "E"]
// 被删除的元素: ["C", "D"]
实例7：从倒数第 2 位开始删除 1 个元素
var myFish = ['A', 'B', 'C', 'D'];
var removed = myFish.splice(-2, 1);
//var removed = myFish.splice(myFish.length-2, 1);
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["A", "B", "D"]
// 被删除的元素: ["C"]
实例8：从第 2 位开始删除所有元素
var myFish = ['A', 'B', 'C', 'D'];
var removed = myFish.splice(2);
console.log(myFish);
console.log(removed);
// 运算后的 myFish: ["A", "B"]
// 被删除的元素: ["C", "D"]
30、toString() 的使用
toString() 返回一个字符串，表示指定的数组及其元素。
语法：arr.toString()
返回值：
|--- 一个表示指定的数组及其元素的字符串。
描述
Array对象覆盖了Object的toString方法。对于数组对象，toString方法连接数组并返回一个字符串，其中包含用逗号分隔的每个数组元素。当一个数组被作为文本值或者进行字符串连接操作时，将会自动调用其
toString方法。
实例1：
var array1 = [1, 2, 'a', '1a'];
console.log(array1.toString()); //1,2,a,1a
31、unshift() 的使用
unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。
语法：arr.unshift(element1, ..., elementN)
参数：
|---elementN：要添加到数组开头的元素或多个元素。返回值：
|--- 当一个对象调用该方法时，返回其 length 属性值。
实例1：
let arr = [1, 2];
arr.unshift(0); // 调用后，新的数组长度为3
// [0, 1, 2]
arr.unshift(-2, -1); // 新的数组长度为5
// [-2, -1, 0, 1, 2]
arr.unshift([-4, -3]); // t新的数组长度为 6
// [[-4, -3], -2, -1, 0, 1, 2]
arr.unshift([-7, -6], [-5]); // 新的数组长度为8
// [[-7, -6], [-5]，[-4, -3], -2, -1, 0, 1, 2]
31、values() 的使用
values() 方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
语法：arr.values()
实例1：使用 for...of 循环进行迭代
let arr = ['w', 'y', 'k', 'o', 'p'];
let eArr = arr.values();
// 您的浏览器必须支持 for..of 循环
// 以及 let —— 将变量作用域限定在 for 循环中
for (let letter of eArr) {
console.log(letter);
}
/*
w
y
k
o
p
*/
实例2：另一种迭代方式
let arr = ['w', 'y', 'k', 'o', 'p'];
let eArr = arr.values();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p
完结。
