js 文档学习

concat() 方法用于连接两个或多个数组。

该方法不会改变现有的数组，而是返回一个新的数组。

opyWithin() 方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中。
复制数组的前面两个元素到第三和第四个位置上：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”, “Kiwi”, “Papaya”];
fruits.copyWithin(2, 0, 2);
输出结果：

Banana,Orange,Banana,Orange,Kiwi,Papaya

复制数组的前面两个元素到后面两个元素上：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.copyWithin(2, 0);
fruits 输出结果：

Banana,Orange,Banana,Orange

entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
迭代对象中数组的索引值作为 key， 数组元素作为 value。
var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.entries();
res
[0, “Banana”]
[1, “Orange”]
[2, “Apple”]
[3, “Mango”]

fill() 方法用于将一个固定值替换数组的元素。
填充 “Runoob” 到数组的最后两个元素：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.fill(“Runoob”, 2, 4);
输出结果：

Banana,Orange,Runoob,Runoob

使用固定值填充数组：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.fill(“Runoob”);
fruits 输出结果：

Runoob,Runoob,Runoob,Runoob

every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。

every() 方法使用指定函数检测数组中的所有元素：

如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。
注意： every() 不会对空数组进行检测。

注意： every() 不会改变原始数组。

        let list = tab.filter(x => x.currId == currId && x.tranDate == tranDate
                                    && x.class == item);

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。

注意： filter() 不会对空数组进行检测。

注意： filter() 不会改变原始数组。

findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。

findIndex() 方法为数组中的每个元素都调用一次函数执行：

当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。
如果没有符合条件的元素返回 -1
注意: findIndex() 对于空数组，函数是不会执行的。

注意: findIndex() 并没有改变数组的原始值。
返回符合大于输入框中数字的数组索引：

var ages = [4, 12, 16, 20];

function checkAdult(age) {
return age >= document.getElementById(“ageToCheck”).value;
}

function myFunction() {
document.getElementById(“demo”).innerHTML = ages.findIndex(checkAdult);
}
forEach() 的 continue 与 break
forEach() 本身是不支持的 continue 与 break 语句的，我们可以通过 some 和 every 来实现。

使用 return 语句实现 continue 关键字的效果：

continue 实现
实例
var arr = [1, 2, 3, 4, 5];

arr.forEach(function (item) {
if (item === 3) {
return;
}
console.log(item);
});

from() 方法用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组。

如果对象是数组返回 true，否则返回 false。
var arr = Array.from([1, 2, 3], x => x * 10);
// arr[0] == 10;
// arr[1] == 20;
// arr[2] == 30;

Array.from() 可以将一个伪数组转换为数组，如下所示：

let obj = {
‘0’: 1,//‘0’:1中的’0’将转换为下标0,下面的key同理
‘1’: 2,
‘2’:3,
‘length’: 4,//length规定了转换的数组有多长
}
let newObj= Array.from(obj, item => {return item})
console.log(newObj); //输出:[ 1, 2, 3, undefined ]

定义和用法
includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。

参数 描述
searchElement 必须。需要查找的元素值。
fromIndex 可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true

indexOf() 方法
查找数组中 “Apple” 的元素, 在数组的第四个位置开始检索：

var fruits=[“Banana”,“Orange”,“Apple”,“Mango”,“Banana”,“Orange”,“Apple”];
var a = fruits.indexOf(“Apple”,4);

把数组中的所有元素转换为一个字符串：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
var energy = fruits.join();
energy输出结果：

Banana,Orange,Apple,Mango

使用不同的分隔符：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
var energy = fruits.join(" and ");
energy 结果输出：

Banana and Orange and Apple and Mango

从数组 fruit 创建一个数组迭代对象， 该对象包含了数组的键：
0 1 23 就是键

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.keys();
// Expected output: 0
// Expected output: 1
// Expected output: 2

lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。

如果要检索的元素没有出现，则该方法返回 -1。
var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
var a = fruits.lastIndexOf(“Apple”);
a 输出结果：

2

map
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。

map() 方法按照原始数组元素顺序依次处理元素。

注意： map() 不会对空数组进行检测。

注意： map() 不会改变原始数组。
const users=res.items.map(item => ({
url: item.html_url,
img: item.avatar_url,
name: item.login,
})
);

var ls = [‘1’, ‘2’, ‘3’].map(parseInt)
console.log(ls)
// ls => [1, NaN, NaN]

pop() 方法用于删除数组的最后一个元素并返回删除的元素。
提示： 移除数组第一个元素，请使用 shift() 方法。
var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.pop();

定义和用法
reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

reduce() 可以作为一个高阶函数，用于函数的 compose。

注意: reduce() 对于空数组是不会执行回调函数的。

//获取年龄最大的Person
const max = data.reduce((prev, current) => (prev.y > current.y) ? prev : current)

简洁的ES6(Babel)
const maxValueOfY = Math.max(…arrayToSearchIn.map(o => o.y), 0);

reduceRight() 方法接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）将其减少为单个值。
const array1 = [[0, 1], [2, 3], [4, 5]];

const result = array1.reduceRight((accumulator, currentValue) => accumulator.concat(currentValue));

console.log(result);
// Expected output: Array [4, 5, 2, 3, 0, 1]

reverse() 方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。
const array1 = [‘one’, ‘two’, ‘three’];
console.log(‘array1:’, array1);
// Expected output: “array1:” Array [“one”, “two”, “three”]

const reversed = array1.reverse();
console.log(‘reversed:’, reversed);
// Expected output: “reversed:” Array [“three”, “two”, “one”]

// Careful: reverse is destructive – it changes the original array.
console.log(‘array1:’, array1);
// Expected output: “array1:” Array [“three”, “two”, “one”]

var fruits = [“Banana”, “Orange”, “Lemon”, “Apple”, “Mango”];
var citrus = fruits.slice(1,3);
citrus 结果输出:

Orange,Lemon

数字排序 (字母和降序):

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.sort();
fruits.reverse();
fruits输出结果：

Orange,Mango,Banana,Apple

var arr = [9,7,2];

arr.sort(function(a,b){
if(a>b) // 如果 a 大于 b,位置互换
return 1;
else //否则，位置不变
return -1;
});首先，第一个参数并不是在第二个参数前面，恰恰相反，参数 b 始终在参数 a 的前面。
即第一比较 a>b 其实比较的是 7>9。

第一次比较：7>9，结果为 false，即 return -1，此时 a 会换到 b 前面，即 7 在 9 之前，所以位置互换，并不是这位网友说的 a>b 位置互换，而是 a<b 位置互换。

但是最后输出的结果一样，是因为 a、b 循序理解反了，然后关于 return 结果导致位置交换的概念也弄反了，反反得正，结果就一样了。

去重升序：

var arr = [23,43,54,656,45,53,43,23,4,5,6,4,5]
var s = new Set(arr)
s = […s]
// console.log(s)
s.sort((a,b)=>(a-b))
console.log(s) // [ 4, 5, 6, 23, 43, 45, 53, 54, 656 ]

https://www.runoob.com/jsref/jsref-some.html
some
function myFunction() {
document.getElementById(“demo”).innerHTML = ages.some(v => {return v>document.getElementById(“ageToCheck”).value});
}

splice() 方法用于添加或删除数组中的元素。

注意：这种方法会改变原始数组。

数组中添加新元素：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.splice(2,0,“Lemon”,“Kiwi”);
fruits 输出结果：

Banana,Orange,Lemon,Kiwi,Apple,Mango

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.toString();
fruits将输出：

Banana,Orange,Apple,Mango

将新项添加到数组起始位置:

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.unshift(“Lemon”,“Pineapple”);
fruits 将输出：

Lemon,Pineapple,Banana,Orange,Apple,Mango

尝试一下 »
定义和用法
unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

注意： 该方法将改变数组的数目。

提示: 将新项添加到数组末尾，请使用 push() 方法。