js数组方法解析

最新推荐文章于 2024-08-28 14:41:59 发布

尤雨溪般的艺术编程者

最新推荐文章于 2024-08-28 14:41:59 发布

阅读量318

点赞数 1

分类专栏： JS面试题前端知识前端基础知识文章标签： javascript 前端开发语言

本文链接：https://blog.csdn.net/solar7system/article/details/128424782

版权

前端知识同时被 3 个专栏收录

46 篇文章 0 订阅

订阅专栏

前端基础知识

35 篇文章 2 订阅

订阅专栏

JS面试题

15 篇文章 0 订阅

订阅专栏

一、检测方法

Array.isArray()

判断传入的值是否为数组

// 下面的函数调用都返回 true
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
Array.isArray(new Array('a', 'b', 'c', 'd'))
// 鲜为人知的事实：其实 Array.prototype 也是一个数组。
Array.isArray(Array.prototype); 

// 下面的函数调用都返回 false
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray('Array');
Array.isArray(true);
Array.isArray(false);
Array.isArray(new Uint8Array(32))
Array.isArray({ __proto__: Array.prototype });

二、创建数组方法

Array.from()

Array.from()方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。

返回值，一个新的数组实例

伪数组对象（拥有一个 length 属性和若干索引属性的任意对象）
可迭代对象（可以获取对象中的元素,如 Map和 Set 等）
undefined null 报错
’ ’ 123 NaN 结果为 [ ] 数组
‘foo’ 结果为 [“f”,“o”,“o”]

// 报错
Array.from(undefined)
// 报错
Array.from(null)
// ["f", "o", "o"]
console.log(Array.from('foo'))
// []
console.log(Array.from(''))
// []
console.log(Array.from(123))
// []
console.log(Array.from(NaN))
//[ ' ', ' ', ' ', ' ', ' ' ]
console.log(Array.from('     '))


// arguments对象转为数组
function foo() {
  const args = Array.from(arguments)
  //true
  console.log(Array.isArray(args))
}
foo(1, 2, 3)
// [ 1, 2, 3 ]

// NodeList对象转为数组
Array.from(document.querySelectorAll('p'))

//Set对象生成数组
const set = new Set(['foo', 'bar', 'baz', 'foo']);
Array.from(set);
// [ "foo", "bar", "baz" ]

// Map对象转为数组
const map = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(map);
// [[1, 2], [2, 4], [4, 8]]

const mapper = new Map([['1', 'a'], ['2', 'b']]);
Array.from(mapper.values());
// ['a', 'b'];

Array.from(mapper.keys());
// ['1', '2'];

Array.from()可以传入三个参数Array.from(arrayLike[, mapFn[, thisArg]])

第一个参数（必填）：想要转换成数组的类数组对象或可迭代对象。
第二个参数（可选）：数组中的每个元素会执行该回调函数。
第三个参数（可选）：执行第二个参数回调函数时需要绑定的this对象。

// 传入第二个参数回调函数：[2, 4, 6]
Array.from([1, 2, 3], x => x + x)

let obj = {
  num: 1,
  handle: function(value){
    return value + this.num
  }
}
// 传入第三个参数修改this指向：[2, 3, 4, 5, 6]
const arrs = Array.from([1, 2, 3, 4, 5], obj.handle, obj)


// 得到数组对象里的id属性：[1, 2]
const obj1 = [{id: 1,name: 'zhangsan'},{id: 2,name: 'lisi'}]
Array.from(obj1,(el) => {
  return el.id
})

from() 的 length 属性为 1 ，即 Array.from.length === 1。

数组去重合并

function combine(){ 
    let arr = [].concat.apply([], arguments);  //没有去重复的新数组 
    return Array.from(new Set(arr));
} 

var m = [1, 2, 2], n = [2,3,3]; 
console.log(combine(m,n));                     // [1, 2, 3]

Array.of()

Array.of() 方法创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。

Array.of() 和 Array 构造函数之间的区别在于处理整数参数：Array.of(7) 创建一个具有单个元素 7 的数组，而 Array(7) 创建一个长度为7的空数组（注意：这是指一个有7个空位(empty)的数组，而不是由7个undefined组成的数组）。

Array.of()                  // []
Array.of(undefined)         // [undefined]
Array.of(null)              // [null]
Array.of(NaN)               // [NaN]
Array.of(1)                 // [1]
Array.of(1, 2)              // [1, 2]
Array.of([1,2,3])           // [[1,2,3]]
Array.of({id: 1},{id: 2})   // [{id:1}, {id:2}]

三、操作数组方法

push()

push()方法将一个或多个元素添加到数组的末尾。此方法更改原数组
返回值该数组的新长度

let arr=[1,2,3]

console.log(arr.push(2,1))  //5
console.log(arr)  //[ 1, 2, 3, 2, 1 ]

pop()

pop()方法从数组中删除最后一个元素，并返回该元素的值。此方法更改原数组
返回值删除的元素

let arr=[1,2,3]

console.log(arr.shift())  //1
console.log(arr)  //[ 2, 3 ]

shift()

shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改原数组
返回值删除的元素

let arr=[1,2,3]

console.log(arr.shift())  //1
console.log(arr)  //[ 2, 3 ]

unshift()

unshift()方法将一个或多个元素添加到数组的开头，并返回该数组的新长度此方法更改原数组
返回值该数组的新长度

let arr=[1,2,3]

console.log(arr.unshift(2,1))  //5
console.log(arr)  //[ 2, 1, 1, 2, 3 ]

concat()

concat()方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。如果省略参数，则concat会返回当前数组的浅拷贝。
返回值合并后的新数组

//都是简单数据类型 可以当作 深拷贝
let arr=[1,2,3]
let newArr=arr.concat()
console.log(newArr===arr)    //false
//有复杂数据类型  浅拷贝
let arr1=[1,2,{a:1}]
let newArr1=arr1.concat()
console.log(newArr1=arr1)  //[ 1, 2, { a: 1 } ]
arr1[2].b=2
console.log(newArr1)       //[ 1, 2, { a: 1, b: 2 } ]
//综上  省略参数  返回当前数组的浅拷贝

let obj1={a:1}
let obj2={b:2}

let arr = [1, 2, 3,obj1]
let newArr = arr.concat([1,2],obj2,100-1,'合并数组',undefined,null)
//数据类型如字符串，数字和布尔（不是String，Number 和 Boolean 对象）：
//concat将字符串和数字的值复制到新数组中。

console.log(newArr)
[1,2,3,{ a: 1 },1,2,{ b: 2 },99,'合并数组', undefined,null]

obj1.b=3
obj2.a=4
/*
对象引用（而不是实际对象）：concat将对象引用复制到新数组中。 
原始数组和新数组都引用相同的对象。 
也就是说，如果引用的对象被修改，则更改对于新数组和原始数组都是可见的。
 这包括也是数组的数组参数的元素。
 */

console.log(newArr)
[1,2,3,{ a: 1, b: 3 },1,2,{ b: 2, a: 4 },99,'合并数组',undefined,null]

详解
concat方法创建一个新的数组，它由被调用的对象中的元素组成，每个参数的顺序依次是该参数的元素（如果参数是数组）或参数本身（如果参数不是数组）。它不会递归到嵌套数组参数中。

concat方法不会改变this或任何作为参数提供的数组，而是返回一个浅拷贝，它包含与原始数组相结合的相同元素的副本。原始数组的元素将复制到新数组中，如下所示：

对象引用（而不是实际对象）：concat将对象引用复制到新数组中。原始数组和新数组都引用相同的对象。也就是说，如果引用的对象被修改，则更改对于新数组和原始数组都是可见的。这包括也是数组的数组参数的元素。
数据类型如字符串，数字和布尔（不是String，Number 和 Boolean 对象）：concat将字符串和数字的值复制到新数组中。

slice()

slice()方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。

返回值新的数组对象

参数 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 也会一直提取到原数组末尾。

let arr=[1,2,3,4,5]

//begin 参数

//1.
//如果省略 begin，则 slice 从索引 0 开始。
let newArr1=arr.slice()  

console.log(newArr1)  //[ 1, 2, 3, 4, 5 ]

//2.
//提取起始处的索引（从 0 开始），从该索引开始提取原数组元素
//如果 end 被省略，则 slice 会一直提取到原数组末尾。
let newArr2=arr.slice(1) //[ 2, 3, 4, 5 ]

console.log(newArr2)


//3.
//如果 begin 大于原数组的长度，则会返回空数组。
let newArr3=arr.slice(6)

console.log(newArr3) //[]


//4.
//如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取
//slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）
let newArr4=arr.slice(-2)

console.log(newArr4) //[ 4, 5 ]


//end  参数


//1.
// 提取终止处的索引（从 0 开始），
// 在该索引处结束提取原数组元素。
// slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。
let newArr5=arr.slice(1,2)

console.log(newArr5) //[ 2 ]


//2.
// 如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 
// slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。
let newArr6=arr.slice(-2,-1)

console.log(newArr6) //[ 4 ]


//3.
// 如果 end 被省略，则 slice 会一直提取到原数组末尾。
// 如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。
let newArr7=arr.slice(1)
let newArr8=arr.slice(1,6)

console.log(newArr7) //[ 2, 3, 4, 5 ]
console.log(newArr8) //[ 2, 3, 4, 5 ]



//补充  如果某元素是 对象引用 若该对象改变  新数组和原来数组的该元素也会改变

let obj={a:1}
let arr1=[1,2,obj]

let newArr = arr1.slice()

console.log(arr1,newArr)  //arr [ 1, 2, { a: 1 } ] newArr [ 1, 2, { a: 1 } ]
obj.b=2
console.log(arr1,newArr)  //arr [ 1, 2, { a: 1, b: 2 } ] newArr [ 1, 2, { a: 1, b: 2 } ]

详解
slice 不会修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。原数组的元素会按照下述规则拷贝：

如果该元素是个对象引用（不是实际的对象），slice 会拷贝这个对象引用到新的数组里。两个对象引用都引用了同一个对象。如果被引用的对象发生改变，则新的和原来的数组中的这个元素也会发生改变。

对于字符串、数字及布尔值来说（不是 String、Number 或者 Boolean 对象），slice 会拷贝这些值到新的数组里。在别的数组里修改这些字符串或数字或是布尔值，将不会影响另一个数组。

如果向两个数组任一中添加了新元素，则另一个不会受到影响。

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() 将只删除数组元素。

//start 参数

//1.指定修改的开始位置（从0计数）。
//只有  start 参数 从开始位置删除到数组末尾
let arr1=[1,2,3,4,5]
let newArr1=arr1.splice(2)

console.log(arr1) //改变原数组   [ 1, 2 ]
console.log(newArr1) //返回值 删除的元素组成的数组  [ 3, 4, 5 ]


//2.若省略start参数 返回 空数组[]
let arr2=[1,2,3,4,5]
let newArr2=arr2.splice()

console.log(arr2) // [ 1, 2, 3, 4, 5 ]
console.log(newArr2) //返回值  未删除元素返回空数组    []

//3.如果超出了数组的长度，则从数组末尾开始添加内容
let arr3=[1,2,3,4,5]
let newArr3=arr3.splice(10,0,1)

console.log(arr3) // [ 1, 2, 3, 4, 5, 1 ]
console.log(newArr3) //返回值    []

//4.如果是负值，则表示从数组末位开始的第几位
//（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）
let arr4=[1,2,3,4,5]
let newArr4=arr4.splice(-2)

console.log(arr4) // [ 1, 2, 3 ]
console.log(newArr4) //返回值    [ 4, 5 ]


//5.如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
let arr5=[1,2,3,4,5]
let newArr5=arr5.splice(-6)

console.log(arr5) // []
console.log(newArr5) //返回值    [ 1, 2, 3, 4, 5 ]


//deleteCount  参数  可选


//1.整数，表示要移除的数组元素的个数。
let arr6=[1,2,3,4,5]
let newArr6=arr6.splice(1,2)

console.log(arr6) // [ 1, 4, 5 ]
console.log(newArr6) //返回值    [ 2, 3 ]


//2.如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
let arr7=[1,2,3,4,5]
let newArr7=arr7.splice(1,10)

console.log(arr7) // [ 1 ]
console.log(newArr7) //返回值    [ 2, 3, 4, 5 ]

//3.如果 deleteCount 被省略了，或者它的值大于等于array.length - start
//(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
let arr8=[1,2,3,4,5]
let newArr8=arr8.splice(1,5)

console.log(arr8) // [ 1 ]
console.log(newArr8) //返回值    [ 2, 3, 4, 5 ]

let arr9=[1,2,3,4,5]
let newArr9=arr9.splice(1)

console.log(arr9) // [ 1 ]
console.log(newArr9) //返回值    [ 2, 3, 4, 5 ]

//4.如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
let arr10=[1,2,3,4,5]
let newArr10=arr10.splice(1,-1,100)

console.log(arr10) // [ 1, 100, 2, 3, 4, 5 ]
console.log(newArr10) //返回值    []



// item1, item2, ...  参数 可选
// 要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。
let arr11=[1,2,3,4,5]
let newArr11=arr11.splice(3,0,100,101,102)

console.log(arr11) // [ 1, 2, 3, 100,101,102, 4, 5 ]
console.log(newArr11) //返回值    []

copyWithin()

copyWithin() 方法浅复制数组的一部分到同一数组中的另一个位置在数组内部替换自身元素，并返回它，不会改变原数组的长度,改变原数组。

返回值改变后的数组

参数 arr.copyWithin(target[, start[, end]])

target

0 为基底的索引，复制序列到该位置。如果是负数，target 将从末尾开始计算。
如果 target 大于等于 arr.length，将会不发生拷贝。如果 target 在 start 之后，复制的序列将被修改以符合 arr.length。
start

0 为基底的索引，开始复制元素的起始位置。如果是负数，start 将从末尾开始计算。
如果 start 被忽略，copyWithin 将会从0开始复制。
end

0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。如果是负数， end 将从末尾开始计算。
如果 end 被忽略，copyWithin 方法将会一直复制至数组结尾（默认为 arr.length）。
返回值

//1.
//target 参数  从0开始   复制序列到该位置  
//start 参数  默认为0
//end 参数  默认  复制至数组结尾（默认为 arr.length）
let arr1=[1,2,3,4,5]

let newArr1=arr1.copyWithin(2)

//从索引2开始替换  从索引0到数组结尾复制数据
console.log(arr1)  //改变原数组  [ 1, 2, 1, 2, 3 ]
console.log(newArr1)  //返回改变后的数组  [ 1, 2, 1, 2, 3 ]

//2.
//target 可以是 负数
let arr2=[1,2,3,4,5]

let newArr2=arr2.copyWithin(-2)

//从倒数第二个元素开始替换  从索引0到数组结尾复制数据
console.log(arr2)  //改变原数组  [ 1, 2, 3, 1, 2 ]
console.log(newArr2)  //返回改变后的数组  [ 1, 2, 3, 1, 2 ]


//3.

//start参数  0 为基底的索引，开始复制元素的起始位置。如果是负数，start 将从末尾开始计算。

//end参数    0 为基底的索引，开始复制元素的结束位置。copyWithin 将会拷贝到该位置，但不包括 end 这个位置的元素。
//如果是负数， end 将从末尾开始计算。

let arr3=[1,2,3,4,5]

let newArr3=arr3.copyWithin(1,-3,-1)

//从索引为1开始替换  从倒数第三个元素到最后一个元素复制数据
console.log(arr3)  //改变原数组  [ 1, 3, 4, 4, 5 ]
console.log(newArr3)  //返回改变后的数组  [ 1, 3, 4, 4, 5 ]

四、查询方法

includes()

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

参数 arr.includes(valueToFind[, fromIndex])

valueToFind 需要查询的值
fromIndex 从该位置开始查找默认为0 可以为负值

//1.
//valueToFind 需要查找的元素值
//查找某个元素是否存在   存在返回true 不存在返回 false
let arr=[1,2,3]

console.log(arr.includes(1))//true
console.log(arr.includes(4))//false

//2.
//fromIndex   搜索的起始位置 默认为 0 可以设置负值
let arr1=[1,2,3,4,5]

console.log(arr1.includes(1))// 默认为0  true
console.log(arr1.includes(1,1)) //  false
console.log(arr1.includes(3,-2))//可以为负值  false

//3.
//fromIndex 大于等于数组长度
// 如果 fromIndex 大于等于  数组的长度，则会返回 false，且该数组不会被搜索。
let arr3=[1,2,3,4,5]

console.log(arr3.includes(1,5)) //false
console.log(arr3.includes(1,100)) //false

//4.
//如果 fromIndex 为负值，如果计算出的索引小于 0，则整个数组都会被搜索。
let arr4=[1,2,3,4,5]

console.log(arr4.includes(5,-100))//true fromIndex 为负值-n 按倒数第n个元素计算  该位置索引小于0  整个数组被搜索

//5.
//作为通用方法的 includes()

// includes() 方法有意设计为通用方法。它不要求this值是数组对象，
// 所以它可以被用于其他类型的对象 (比如类数组对象)。
// 下面的例子展示了 在函数的 arguments 对象上调用的 includes() 方法。

;(function() {
    console.log([].includes.call(arguments, 'a')); // true
    console.log([].includes.call(arguments, 'd')); // false
  })('a','b','c');       //自执行函数 与之前的js 代码  之间需要用 分号 ;  隔开 否则报错

indexOf、lastIndexOf()

indexOf()方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。

lastIndexOf() 方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从 fromIndex 处开始。

返回值索引或者-1 不改变原数组

参数 arr.indexOf(searchElement[, fromIndex])
参数 arr.lastIndexOf(searchElement[, fromIndex])

searchElement
要查找的元素

fromIndex 可选

indexOf

开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。
如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找，以此类推。
注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。
如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.
lastIndexOf

从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。
如果该值大于或等于数组的长度，则整个数组会被查找。
如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。
如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。

let arr=[1,99,2,3,99,4,5,1]


//indexOf   正向开始查找
//lastIndexOf   逆向开始查找
//searchElement  被查找的元素

console.log(arr)
console.log(arr.indexOf(99))  //1   正向查找到  第一个 所查元素 的索引值
console.log(arr.lastIndexOf(99))  //4   逆向查找到 第一个 所查元素 的索引值
console.log(arr.indexOf(100),arr.lastIndexOf(100))//-1 -1   如果不存在返回-1

//1.fromIndex 开始查询的位置  默认值为 0 
console.log(arr.indexOf(99,2))   //4 从该位置正向查找
console.log(arr.lastIndexOf(99,2))    //1 从该位置逆向查找

//2.fromIndex  大于数组索引
console.log(arr.indexOf(99,8))  //-1   indexOf 不会查找返回-1
console.log(arr.lastIndexOf(99,8))   //4   lastIndexOf  整个数组会被查找

//3.fromIndex 可以是负值  
//当值是负值时不改变查询元素的方向   -n表示倒数第n个位置 
console.log(arr.indexOf(99,-5))  // 4
console.log(arr.lastIndexOf(99,-5))   // 1

//如果是负值  且超出数组长度 

console.log(arr.indexOf(99,-9))  //1  indexOf  表示查询整个数组
console.log(arr.lastIndexOf(99,-9))  //-1  lastIndexOf  数组不会被查找


//注意复杂类型 问题
let obj={b:1}
let arr1=[1,2,{a:1},obj]

console.log(arr1.indexOf({a:1}))  //-1
console.log(arr1.indexOf(obj))  //3

五、排序方法

sort
sort()方法用原地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的,默认排序顺序是根据字符串Unicode码点。改变原数组

返回值排序后的数组。请注意，数组已原地排序，并且不进行复制。

reverse

六、转换方法

toLocaleString()

toString()

join()

七、迭代（遍历）方法

迭代
定义：
1、迭代（iterate），指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。
2、循环（loop），指的是在满足条件的情况下，重复执行同一段代码。比如，while语句。
3、遍历（traversal），指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次。
4、递归（recursion），指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列。

forEach()

var num = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var number = num.forEach(function(item,index){
      console.log(item);   // [1, 2, 3, 4, 5, 6, 7, 8, 9]
})

map()

通过计算原数组中的项，来组成新的数组

var num = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var number = num.map(function(item,index){
      return item - 1;   // 判断传入的值哪些项大于5
})
console.log(number);   // [0, 1, 2, 3, 4, 5, 6, 7, 8]

filter()

筛选符合条件的项，组成新数组

var num = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var number = num.filter(function(item,index){
      return (item > 5);   // 判断传入的值哪些项大于5
})
console.log(number);   // [6, 7, 8, 9]

some()

查询数组中每项满足某些条件

var num = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var number = num.every(function(item,index){
      return (item > 5);   // 判断传入的值哪些项大于5
})
console.log(number);   // false 只要有一个满足就为true

every()

用来查询数组中的每一个是否都满足某一条件

var num = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var number = num.every(function(item,index){
      return (item > 5);   // 判断传入的值是否全部都大于5
})
console.log(number);   // false 只要有一个不满足就为 false

find()

find()方法用于查找数组中符合条件的第一个元素，如果没有符合条件的元素，则返回undefined

let arr1 = [1, 2, 3, 4, 5];
let num = arr1.find(item => item > 1);
console.log(num)  //輸出的結果是2

findIndex()

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

array.findIndex(function(currentValue,index,arr),thisValue)

const arr = [1, 2, 3, 4, 5, 3, 3, 2, 4, 5 ]
 
// 可以这么写
 
const index = arr.findIndex(item => {
    return item > 2
})
 
console.log(index) // 2
 
// 也可以这么写
 
const index = arr.findIndex(item => item > 2)
 
console.log(index) // 2

entries()
bject.entries方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键值对数组。

const obj = { a: "aaa", b: 1};
Object.entries(obj)  // [ ["a", "aaa"], ["b", 1] ]

keys()
ES5 引入了Object.keys方法，返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键名。

const obj = { a: "aaa", b: 1};
Object.keys(obj)  // ["a", "b"]

values()
Object.values方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键值。

const obj = { a: "aaa", b: 1};
Object.values(obj)  // ["aaa",1]

八、归并方法

reduce()

数组的前项和后项进行累计值计算

var num = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var number = num.reduce(function(prev,cur,index){
      return prev + cur;
})
console.log(number);   // 1+2+3...+9 = 45 本质上就是数组中的项 累计运算的过程