JAVASCRIPT 对象
Array 对象
数组属性
| 属性 | 描述 |
|---|---|
| constructor | 返回创建数组对象的原型函数。 |
| length | 设置或返回数组元素的个数。 |
| prototype | 允许你向数组对象添加属性或方法。 |
Array 对象方法
| 属性 | 描述 |
|---|---|
| concat() | 连接两个或更多的数组，并返回结果。 |
| copyWithin() | 从数组的指定位置拷贝元素到数组的另一个指定位置中。 |
| entries() | 返回数组的可迭代对象。 |
| every() | 检测数值元素的每个元素是否都符合条件。 |
| fill() | 使用一个固定值来填充数组。 |
| filter() | 检测数值元素，并返回符合条件所有元素的数组 |
| find() | 返回符合传入测试（函数）条件的数组第一个元素 |
| findIndex() | 返回符合传入测试（函数）条件的数组第一个元素索引 |
| forEach() | 数组每个元素都执行一次回调函数 |
| Array.from() | 通过给定的对象中创建一个数组 |
| includes() | 判断一个数组是否包含一个指定的值 |
| indexOf() | 搜索数组中的元素，并返回它所在的位置 |
| isArray() | 判断对象是否为数组 |
| join() | 把数组的所有元素放入一个字符串 |
| keys() | 返回数组的可迭代对象，包含原始数组的键(key) |
| lastIndexOf() | 搜索数组中的元素，并返回它最后出现的位置 |
| map() | 通过指定函数处理数组的每个元素，并返回处理后的数组 |
| pop() | 删除数组的最后一个元素并返回删除的元素 |
| push() | 向数组的末尾添加一个或更多元素，并返回新的长度 |
| reduce() | 将数组元素计算为一个值（从左到右） |
| reduceRight() | 将数组元素计算为一个值（从右到左） |
| reverse() | 反转数组的元素顺序 |
| shift() | 删除并返回数组的第一个元素 |
| slice() | 选取数组的一部分，并返回一个新数组 |
| some() | 检测数组元素中是否有元素符合指定条件。 |
| sort() | 对数组的元素进行排序 |
| splice() | 从数组中添加或删除元素 |
| toString() | 把数组转换为字符串，并返回结果 |
| unshift() | 向数组的开头添加一个或更多元素，并返回新的长度 |
| valueOf() | 返回数组对象的原始值。 |
| Array.of() | 将一组值转换为数组。 |
| Array.at() | 用于接收一个整数值并返回该索引对应的元素，允许正数和负数。负整数从数组中的最后一个元素开始倒数 |
| Array.flat() | 创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成 |
| Array.flatMap() | 使用映射函数映射每个元素，然后将结果压缩成一个新数组 |
concat() 方法
定义和用法
concat() 方法用于连接两个或多个数组。
该方法不会改变现有的数组，而是返回一个新的数组。
语法
array1.concat(array2, array3,..., arrayX)
| 参数 | 描述 |
|---|---|
| array2, array3,..., arrayX | 必需。需要连接的数组。 |
返回值
| Type | 描述 |
|---|---|
| Array 对象 | 返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。 |
示例
const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);
console.log(array3); // 输出：['a', 'b', 'c', 'd', 'e', 'f']
copyWithin() 方法
定义和用法
copyWithin() 方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中。
该方法会改变现有的数组。
语法
array.copyWithin(target, start, end)
| 参数 | 描述 |
|---|---|
| target | 必需。复制到指定目标索引位置。 |
| start | 可选。元素复制的起始位置。 |
| end | 可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。 |
示例
var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"];
fruits.copyWithin(2, 0, 2); //返回 Banana,Orange,Banana,Orange,Kiwi,Papaya
entries() 方法
定义和用法
entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
迭代对象中数组的索引值作为 key， 数组元素作为 value。
语法
array.entries()
没有参数
示例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
let fruit = fruits.entries();
let data
do {
//循环调用
data = fruit.next();
// {value:[0,"Banana"],done:false}
// {value:[1,"Orange"],done:false}
// {value:[2,"Apple"],done:false}
// {value:[3,"Mango"],done:false}
// {value:undefined,done:true}
console.log(data);
} while (!data.done);
every() 方法
定义和用法
every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
every() 方法使用指定函数检测数组中的所有元素：
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。
注意： every() 不会对空数组进行检测。
注意： every() 不会改变原始数组。
语法
array.every(function(currentValue,index,arr), thisValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 函数参数: | |
| 参数 | 描述 | |
| currentValue | 必须。当前元素的值 | |
| index | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined" | |
示例
var arr = [32,52,10,50];
// 下面的方法会执行4次
function arrfun (num) {
console.log(num);
return num > 5
}
console.log(arr.every(arrfun)) // true
fill() 方法
定义和用法
fill() 方法用于将一个固定值替换数组的元素。
注意: IE 11 及更早版本不支持 fill() 方法。
语法
array.fill(value, start, end)
| 参数 | 描述 |
|---|---|
| value | 必需。填充的值。 |
| start | 可选。开始填充位置。 |
| end | 可选。停止填充位置 (默认为 array.length) |
示例
var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"];
fruits.fill(2, 0, 2); //返回 2,2,Banana,Orange,Kiwi,Papaya
filter() 方法
定义和用法
filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进行检测。
注意： filter() 不会改变原始数组。
语法
array.filter(function(currentValue,index,arr), thisValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 函数参数: | |
| 参数 | 描述 | |
| currentValue | 必须。当前元素的值 | |
| index | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined" | |
示例
var fruits = [12,52,5,41,67];
function listfunc (num) {
return num >5
}
var b = fruits.filter(listfunc, this); //返回 [12, 52, 41, 67]
console.log(fruits); // [12,52,5,41,67]
find() 方法
定义和用法
find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。
find() 方法为数组中的每个元素都调用一次函数执行：
- 当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
- 如果没有符合条件的元素返回 undefined
注意: find() 对于空数组，函数是不会执行的。
注意: find() 并没有改变数组的原始值。
语法
array.find(function(currentValue,index,arr), thisValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 函数参数: | |
| 参数 | 描述 | |
| currentValue | 必须。当前元素的值 | |
| index | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined" | |
返回值
返回符合测试条件的第一个数组元素值，如果没有符合条件的则返回 undefined。
示例
var fruits = [12,52,5,41,67];
function listfunc (num) {
return num >50
}
var b = fruits.find(listfunc, this); // 52
console.log(fruits); // [12,52,5,41,67]
findIndex() 方法
定义和用法
findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。
findIndex() 方法为数组中的每个元素都调用一次函数执行：
- 当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。
- 如果没有符合条件的元素返回 -1
注意: findIndex() 并没有改变数组的原始值。
语法
array.findIndex(function(currentValue,index,arr), thisValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index,arr) | 必须。函数，数组中的每个元素都会执行这个函数 函数参数: | |
| 参数 | 描述 | |
| currentValue | 必须。当前元素的值 | |
| index | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined" | |
返回值
返回符合测试条件的第一个数组元素索引，如果没有符合条件的则返回 -1。
示例
var fruits = [12,52,5,41,67];
function listfunc (num) {
return num >50
}
var b = fruits.findIndex(listfunc, this);
console.log(b); // 1
forEach() 方法
定义和用法
forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。
语法
array.forEach(callbackFn(currentValue, index, arr), thisValue)
| 参数 | 描述 | |
|---|---|---|
| callbackFn(currentValue, index, arr) | 必须。数组中的每个元素都会执行这个函数 函数参数: | |
| 参数 | 描述 | |
| currentValue | 必须。当前元素的值 | |
| index | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined" | |
返回值
undefined
示例
var fruits = [12,52,5,41,67];
function listfunc (num) {
console.log(num)
}
fruits.forEach(listfunc, this);
forEach() 的 continue 与 break
forEach() 本身是不支持的 continue 与 break 语句的，我们可以通过 some 和 every 来实现。
使用 return 语句实现 continue 关键字的效果：
continue 实现
// forEach
var fruits = [12,52,5,41,67];
fruits.forEach((num)=>{
if(num === 5){
return;
}
console.log(num);
});
// 12
// 52
// 41
// 67
// some
var fruits = [12,52,5,41,67];
fruits.some((num)=>{
if(num === 5){
return;
}
console.log(num);
});
// 12
// 52
// 41
// 67
break 实现
// every
var fruits = [12,52,5,41,67];
let list = fruits.every(function(num){
console.log(num);
// 12
// 52
// 5
return num !== 5 ;
});
console.log(list); //false
from() 方法
定义和用法
from() 方法用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组。
如果对象是数组返回 true，否则返回 false。
语法
Array.from(object, mapFunction, thisValue)
| 参数 | 描述 |
|---|---|
| object | 必需，要转换为数组的对象。 |
| mapFunction | 可选，数组中每个元素要调用的函数。 |
| thisValue | 可选，映射函数(mapFunction)中的 this 对象 |
示例
let objArr = Array.from("RUNOOB")
console.log(objArr) // ["R","U","N","O","O","B"]
var setObj = new Set(["a", "b", "c"]);
var objlist = Array.from(setObj);
objlist[1] == "b"; // true
let obj = {
'0': 1,//'0':1中的'0'将转换为下标0,下面的key同理
'1': 2,
'3':3,
'length': 4,//length规定了转换的数组有多长
}
let newObj= Array.from(obj, item => {return item})
console.log(newObj); //输出:[ 1, 2, 3, undefined ]
includes() 方法
定义和用法
includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则false。
语法
arr.includes(searchElement)
arr.includes(searchElement, fromIndex)
| 参数 | 描述 |
|---|---|
| searchElement | 必须。需要查找的元素值。 |
| fromIndex | 可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。 |
注意：
如果fromIndex 大于等于数组长度 ，则返回 false 。该数组不会被搜索
如果 fromIndex 为负值，计算出的索引将作为开始搜索searchElement的位置。如果计算出的索引小于 0，则整个数组都会被搜索。
示例
var fruits = [12,52,5,41,67];
// --> 按这个方向开始搜索
console.log(fruits.includes(12,2)); //false
console.log(fruits.includes(5,-1)); //false
indexOf() 方法
定义和用法
indexOf() 方法可返回数组中某个指定的元素位置。
该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。
如果在数组中没找到指定元素则返回 -1。
提示如果你想查找字符串最后出现的位置，请使用 lastIndexOf() 方法。
语法
array.indexOf(item,start)
| 参数 | 描述 |
|---|---|
| item | 必须。需要查找的元素。 |
| start | 可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。 |
示例
var fruits = [12,52,5,41,67];
// --> 按这个方向开始搜索
console.log(fruits.indexOf(5,-1)); //-1
isArray() 方法
定义和用法
isArray() 方法用于判断一个对象是否为数组。
如果对象是数组返回 true，否则返回 false。
语法
Array.isArray(obj)
| 参数 | 描述 |
|---|---|
| obj | 必需，要判断的对象。 |
示例
var fruits = [12,52,5,41,67];
// --> 按这个方向开始搜索
console.log(Array.isArray(fruits)); //true
join() 方法
定义和用法
join() 方法用于把数组中的所有元素转换一个字符串。
元素是通过指定的分隔符进行分隔的。
语法
array.join(separator)
| 参数 | 描述 |
|---|---|
| separator | 可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符 |
返回值
| 类型 | 描述 |
|---|---|
| String | 返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。 |
示例
var fruits = [12,52,5,41,67];
let str = fruits.join("和")
console.log(str); // 12和52和5和41和67
keys() 方法
定义和用法
keys() 方法用于从数组创建一个包含数组键的可迭代对象。
语法
array.keys()
示例
var fruits = [12,52,5,41,67];
let str = fruits.keys();
do {
//循环调用
data = str.next();
// {value:0,done:false}
// {value:1,done:false}
// {value:2,done:false}
// {value:3,done:false}
// {value:4,done:false}
// {value:undefined,done:true}
console.log(data);
} while (!data.done);
lastIndexOf() 方法
定义和用法
lastIndexOf() 方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。
如果要检索的元素没有出现，则该方法返回 -1。
该方法将从尾到头地检索数组中指定元素 item。开始检索的位置在数组的 start 处或数组的结尾（没有指定 start 参数时）。如果找到一个 item，则返回 item 从尾向前检索第一个次出现在数组的位置。数组的索引开始位置是从 0 开始的。
如果在数组中没找到指定元素则返回 -1。
提示： 如果你想查找数组首次出现的位置，请使用 indexOf() 方法。
语法
array.lastIndexOf(item,start)
| 参数 | 描述 |
|---|---|
| item | 必须。需要查找的元素。 |
| start | 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的最后一个字符处开始检索。 |
返回值
如果在 stringObject 中的 fromindex 位置之前存在 searchvalue，则返回的是出现的最后一个 searchvalue 的位置。
示例
var fruits = [12,52,5,41,67];
// <-- 按这个方向开始搜索
console.log(fruits.lastIndexOf(5,1)); //-1
map() 方法
定义和用法
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map() 方法按照原始数组元素顺序依次处理元素。
注意： map() 不会对空数组进行检测。
注意： map() 不会改变原始数组。
语法
array.map(function(currentValue,index,arr), thisValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index, arr) | 必须。函数,数组中的每个元素都会执行这个函数 函数参数: | |
| 参数 | 描述 | |
| currentValue | 必须。当前元素的值 | |
| index | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，或者传入 null、undefined，那么回调函数的 this 为全局对象。 | |
返回值
返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
示例
var fruits = [12,52,5,41,67];
var list = fruits.map((num)=>num+1);
console.log(list) //[13, 53, 6, 42, 68]
pop() 方法
定义和用法
pop() 方法用于删除数组的最后一个元素并返回删除的元素。
注意：此方法改变数组的长度！
提示： 移除数组第一个元素，请使用 shift() 方法。
语法
array.pop()
返回值
返回删除的元素。
示例
const sites = ['Google', 'Runoob', 'Taobao', 'Zhihu', 'Baidu'];
console.log(sites.pop());
// 输出结果为: "Baidu"
console.log(sites);
// 输出结果为: ['Google', 'Runoob', 'Taobao', 'Zhihu']
sites.pop();
console.log(sites);
// 输出结果为: ["Google", "Runoob", "Taobao"]
push() 方法
定义和用法
push() 方法可向数组的末尾添加一个或多个元素，并返回新的长度。
注意： 新元素将添加在数组的末尾。
注意： 此方法改变数组的长度。
提示： 在数组起始位置添加元素请使用 unshift() 方法。
语法
array.push(item1, item2, ..., itemX)
| 参数 | 描述 |
|---|---|
| item1, item2, ..., itemX | 必须。必需。要添加到数组的元素。 |
返回值
返回数组新长度
示例
const sites = ['Google', 'Runoob', 'Taobao', 'Zhihu', 'Baidu'];
console.log(sites.push("alibaba"));
// 输出结果为: 6
console.log(sites);
// 输出结果为: ['Google', 'Runoob', 'Taobao', 'Zhihu', 'Baidu','alibaba']
reduce() 方法
定义和用法
reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
reduce() 可以作为一个高阶函数，用于函数的 compose。
注意: reduce() 对于空数组是不会执行回调函数的。
语法
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index, arr) | 必需。用于执行每个数组元素的函数。 函数参数: | |
| 参数 | 描述 | |
| total | 必需。初始值, 或者计算结束后的返回值。 | |
| currentValue | 必须。当前元素的值 | |
| currentIndex | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。传递给函数的初始值 | |
返回值
返回 计算后的结果
示例
var fruits = [12,52,5,41,67];
var list = fruits.reduce((total,num)=>tatal+num);
console.log(list) // 177
reduceRight() 方法
定义和用法
reduceRight() 方法的功能和 reduce() 功能是一样的，不同的是 reduceRight() 从数组的末尾向前将数组中的数组项做累加。
语法
array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index, arr) | 必需。用于执行每个数组元素的函数。 函数参数: | |
| 参数 | 描述 | |
| total | 必需。初始值, 或者计算结束后的返回值。 | |
| currentValue | 必须。当前元素的值 | |
| currentIndex | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。传递给函数的初始值 | |
返回值
返回 计算后的结果
示例
var fruits = [12,52,5,41,167];
var list = fruits.reduceRight(
(total,num)=>{
console.log(total);// 167 126 121 69
console.log(num); // 41 5 52 12
return total-num
});
console.log(list)//57
reverse() 方法
定义和用法
reverse() 方法用于颠倒数组中元素的顺序。
语法
array.reverse()
返回值
返回 颠倒顺序后的数组
示例
const sites = ['Google', 'Runoob', 'Taobao', 'Zhihu', 'Baidu'];
let resites= sites.reverse();// 原数组sites 的顺序也会颠倒
//返回颠倒后的数组
console.log(resites);
console.log(sites);
// 输出结果都为: [ 'Baidu','Zhihu', 'Taobao','Runoob', 'Google']
shift() 方法
定义和用法
shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。
注意： 此方法改变数组的长度。
提示： 移除数组末尾的元素可以使用 pop() 方法。
语法
array.shift()
返回值
返回 数组原来的第一个元素的值（移除的元素）。
示例
const sites = ['Google', 'Runoob', 'Taobao', 'Zhihu', 'Baidu'];
console.log(sites.shift()); // 输出结果为: Google
console.log(sites);
// 输出结果为: ['Runoob', 'Taobao', 'Zhihu', 'Baidu']
slice() 方法
定义和用法
slice() 方法可从已有的数组中返回选定的元素。
slice() 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。
注意： slice() 方法不会改变原始数组。
语法
array.slice(start, end)
| 参数 | 描述 |
|---|---|
| start | 可选。规定从何处开始选取。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。 |
| end | 可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。 |
返回值
返回 返回一个新的数组，包含从 start（包括该元素） 到 end （不包括该元素）的 arrayObject 中的元素。
示例
const sites = ['Google', 'Runoob', 'Taobao', 'Zhihu', 'Baidu'];
console.log(sites.slice(0,2));
// 输出结果为: ['Google', 'Runoob']
some() 方法
定义和用法
some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。
some() 方法会依次执行数组的每个元素：
- 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
- 如果没有满足条件的元素，则返回false。
注意： some() 不会改变原始数组。
语法
array.some(function(currentValue,index,arr),thisValue)
| 参数 | 描述 | |
|---|---|---|
| function(currentValue, index, arr) | 必须。数组中的每个元素都会执行这个函数 函数参数: | |
| 参数 | 描述 | |
| currentValue | 必须。当前元素的值 | |
| index | 可选。当前元素的索引值 | |
| arr | 可选。当前元素属于的数组对象 | |
| thisValue | 可选。对象作为该执行回调时使用，传递给函数，用作 "this" 的值。 如果省略了 thisValue ，"this" 的值为 "undefined" | |
返回值
布尔值。如果数组中有元素满足条件返回 true，否则返回 false
示例
var fruits = [12,52,5,41,67];
function listfunc (num) {
console.log(num) // 12 52 5
return num < 8
}
let boole = fruits.some(listfunc, this);
console.log(boole); // true
sort() 方法
定义和用法
sort() 方法用于对数组的元素进行排序。
排序顺序可以是字母或数字，并按升序或降序。
默认排序顺序为按字母升序。
注意：当数字是按字母顺序排列时"40"将排在"5"前面。
使用数字排序，你必须通过一个函数作为参数来调用。
函数指定数字是按照升序还是降序排列。
这些说起来可能很难理解，你可以通过本页底部实例进一步了解它。
注意： 这种方法会改变原始数组！
语法
array.sort(sortfunction)
| 参数 | 描述 |
|---|---|
| sortfunction | 可选。规定排序顺序。必须是函数 |
返回值
对数组的引用。请注意，数组在原数组上进行排序，不生成副本
示例
const sites = ['Google', 'Runoob', 'Taobao', 'Zhihu', 'Baidu'];
let list= sites.sort();
console.log(list) //['Baidu', 'Google', 'Runoob', 'Taobao', 'Zhihu']
[12,1,5,64,52,88,41,62].sort(function(a,b){
return a-b
}) //[1, 5, 12, 41, 52, 62, 64, 88]
splice() 方法
定义和用法
splice() 方法用于添加或删除数组中的元素。
注意： 这种方法会改变原始数组！
语法
array.splice(index,howmany,item1,.....,itemX)
| 参数 | 描述 |
|---|---|
| index | 必需。规定从何处添加/删除元素。 |
| 该参数是开始插入和（或）删除的数组元素的下标，必须是数字。 | |
| howmany | 可选。规定应该删除多少元素。必须是数字，但可以是 "0"。 |
| 如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。 | |
| item1, ..., itemX | 可选。要添加到数组的新元素 |
返回值
如果删除一个元素，则返回一个元素的数组。 如果未删除任何元素，则返回空数组。
示例
var arr = [1,2,3,4,5];
//添加
arr.splice(0,0,0);// [0,1,2,3,4,5]
//修改
arr.splice(0,1,23);// [23,1,2,3,4,5]
//删除
arr.splice(0,1);//[1,2,3,4,5]
toString() 方法
定义和用法
toString() 方法可把数组转换为字符串，并返回结果。
注意： 数组中的元素之间用逗号分隔。
语法
array.toString()
返回值
数组的所有值用逗号隔开
示例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.toString(); //Banana,Orange,Apple,Mango
unshift() 方法
定义和用法
unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
注意： 该方法将改变数组的数目。
提示: 将新项添加到数组末尾，请使用 push() 方法。
语法
array.unshift(item1,item2, ..., itemX)
| 参数 | 描述 |
|---|---|
| item1,item2, ..., itemX | 可选。向数组起始位置添加一个或者多个元素。 |
返回值
返回 数组新长度。
示例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon","Pineapple");
// Lemon,Pineapple,Banana,Orange,Apple,Mango
valueOf() 方法
定义和用法
valueOf() 方法返回 Array 对象的原始值。
该原始值由 Array 对象派生的所有对象继承。
valueOf() 方法通常由 JavaScript 在后台自动调用，并不显式地出现在代码中。
注意： valueOf() 方法不会改变原数组。
语法
array.valueOf()
返回值
返回 valueOf() 返回数组值
示例
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var v=fruits.valueOf();
// Banana,Orange,Apple,Mango
Array.of() 方法
定义和用法
of() 方法用于将一组值转换为数组，不考虑参数的数量或类型。
Array.of() 和 Array() 构造函数之间的区别在于对单个参数的处理：Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个 length 为 7 的空数组。
如果对象是数组返回 true，否则返回 false。
语法
Array.of(7); // [7]
Array(7); // [空属性 × 7]
Array.of(1, 2, 3); // [1, 2, 3]
Array(1, 2, 3); // [1, 2, 3]
示例
Array.of(1); // [1]
Array.of(1, 2, 3); // [1, 2, 3]
Array.of(undefined); // [undefined]
Array.at() 方法
定义和用法
at() 方法用于接收一个整数值并返回该索引对应的元素，允许正数和负数。负整数从数组中的最后一个元素开始倒数。
匹配给定索引的数组中的元素。如果找不到指定的索引，则返回 undefined。
在传递非负数时，at() 方法等价于括号表示法。例如，array[0] 和 array.at(0) 均返回第一个元素。但是，当你需要从数组的末端开始倒数时，则不能使用 Python 和 R 语言中支持的 array[-1]，因为方括号内的所有值都会被视为字符串属性，因此你最终读取的是 array["-1"]，这只是一个普通的字符串属性而不是数组索引。
通常的做法是访问 length 并将其减去从末端开始的相对索引。例如，array[array.length - 1]。at() 方法允许使用相对索引，因此上面的示例可以简化为 array.at(-1)。更正式地，当 index < 0 时，该方法将访问索引 index + array.length。
at() 方法是通用的。其仅期望 this 具有 length 属性和以整数为键的属性。
语法
Array.at(index)
示例
let list = [5,544,4,96,2,3]
// 与 list[1] 用法一样
list.of(1); // 545
flat() 方法
定义和用法
flat() 方法方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
flat() 方法返回一个包含将数组与子数组中所有元素的新数组。。
语法
flat()
flat(depth)
| 参数 | 描述 |
|---|---|
| depth | 指定要提取嵌套数组的结构深度，默认值为 1。 |
返回值
提取嵌套数组 的新数组
示例
const sites = [['Google', ['Runoob']], 'Taobao', 'Zhihu', 'Baidu'];
let list= sites.flat(1); // 提取一层
console.log(list)
// ['Google', [Runoob], 'Taobao', 'Zhihu', 'Baidu']
flatMap() 方法
定义和用法
flatMap() 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 连着深度值为 1 的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。
flatMap() 方法一个新的数组，其中每个元素都是回调函数的结果，并且结构深度 depth 值为 1。。
语法
// 箭头函数
flatMap((currentValue) => { /* … */ } )
flatMap((currentValue, index) => { /* … */ } )
flatMap((currentValue, index, array) => { /* … */ } )
// 回调函数
flatMap(callbackFn)
flatMap(callbackFn, thisArg)
// 行内回调函数
flatMap(function(currentValue) { /* … */ })
flatMap(function(currentValue, index) { /* … */ })
flatMap(function(currentValue, index, array){ /* … */ })
flatMap(function(currentValue, index, array) { /* … */ }, thisArg)
| 参数 | 描述 |
|---|---|
| callback | 可以生成一个新数组中的元素的函数，可以传入三个参数 currentValue 当前正在数组中处理的元素 index可选。数组中正在处理的当前元素的索引。 array可选。被调用的 map 数组 |
| thisArg | 可选的。执行 callback 函数时 使用的this 值 |
返回值
提取嵌套数组 的新数组
示例
map() 与 flatMap()
var arr1 = [1, 2, 3, 4];
arr1.map(x => [x * 2]);
// [[2], [4], [6], [8]]
arr1.flatMap(x => [x * 2]);
// [2, 4, 6, 8]
// only one level is flattened
arr1.flatMap(x => [[x * 2]]);