javaScript基础数组属性方法

数组:

1.Array.push()

在数组末尾添加元素并返回新的长度

let arr = ["张三","李四","王五"];
console.log(arr.push("赵六"));  //lenght为4
console.log(arr);  //["张三", "李四", "王五", "赵六"]

2.Array.pop()

删除最后一个元素，返回值是删除的元素

let arr = [1,2,3];
console.log(arr.pop());  // 返回值为3
console.log(arr);  // [1, 2]

3.Array.unshift()

在数组头部添加元素并返回新的长度和.push()相反

let arr = ["张三","李四","王五"];
console.log(arr.unshift("赵六")); // 赵六
console.log(arr) // ["赵六","张三", "李四", "王五"]

4.Array.shift()

删除数组第一个元素并返回和.pop()相反

let arr = [1,2,3];
console.log(arr.shift()); // 返回值为1
console.log(arr)    　　　 // [2, 3]

5.Array.splice(index，num，item)

添加或删除数组的元素并返回删除的数组
index(开始位置的下标)
num(删除的个数)
item(插入的元素)

let arr1 = ['a', 'b', 'c', 'd'];
console.log(arr.splice(2,0,1)); // 返回值[](未删除)
console.log(arr)// ["a", "b", 1, "c", "d"]

6.Array.slice(index1，index2)

选取数组一部分并生成新数组（但是不会改变原数组）
index1（开始的下标）
index2（结束的下标）

let arr1 = ['a', 'b', 'c', 'd'];
console.log(arr1.slice(1, 3));//返回值 ["b", "c"]
console.log(arr1);//原数组 ["a", "b", "c", "d"]

7.Array.concat(arr1，arr2…)

连接多个数组并返回

let arr1 = [1, 2, 3],arr2 = [4, 5, 6];
let arr = arr1.concat(arr2);
console.log(arr); //返回[1, 2, 3, 4, 5, 6]

8.Array.join(指定分割符)

将数组的元素拼接成字符串并返回

let arr = ["a", 1, "b", 2];
console.log(arr.join())     // "a,1,b,2"
console.log(arr.join("-"))  // "a-1-b-2"
console.log(arr)            // ["a", 1, "b", 2]

9.Array.toString()

将数组的元素拼接成字符串并返回类似于.join()但是不支持指定字符串分割

let arr = [1, 2, 3, 4, 5];
console.log(arr.toString())// 1,2,3,4,5

10.Array.forEach(fn, thisValue)

fn(必传) 有三个值1–v:当前元素，2–i当前元素索引，3–arr数组
thisValue(选传) this的指向

注意，使用thisValue是不能使用箭头函数否则this指向错误
该方法没有返回值

let myArr = [1,5,8]
myArr.forEach((v,i,arr)=>{
　　console.log(v,i,arr)
})
//1  0  [1, 5, 8]
//5  1  [1, 5, 8]
//8  2  [1, 5, 8]

11.Array.map()

类似于.forEach(fn, thisValue)传参相同，但是.map()每次都会返回执行后结果组成的数组

let myArr = [1,5,8]
myArr.map((v,i,arr)=>{
　　console.log(v,i,arr)
})
//4 1 0  [1, 5, 8]
//4 5 1  [1, 5, 8]
//4 8 2  [1, 5, 8]
// [undefined, undefined, undefined]

12.Array.filter(判断条件)

对数组的每个元素判断，符合条件返回组成新的数组

let arr = [1, 2, 3, 4, 5]
let bigNum = value => value > 3
let newArr = arr.filter(bigNum)
console.log(newArr)
// [4, 5] 满足条件的元素返回为一个新的数组

13.Array.every(判断条件)

对数组的每个元素判断，全部符合条件才返回true

let arr = [1, 2, 3, 4]
let flage1= value => value > 3
let flage2= value => value < 5
console.log(arr.every(flage1))
//false  不是所有都大于3
console.log(arr.every(flage2))
//true   是所有都小于5

14.Array.some(判断条件)

对数组的每个元素判断，一个符合条件就返回true，并且直接返回不会再对剩下的元素进行判断

let arr= [1, 2, 3]
let flage= value => value == 3
console.log(arr.some(flage)) //true

15.Array.reduce()

计算数组的和从左到右

let arr = [1, 2, 3, 4]
let add = (a, b) => a + b
console.log(arr.reduce(add))  // 10

16.Array.reduceRight()

计算数组的和从右到左

let arr = [1, 2, 3, 4]
let add = (a, b) => a + b
console.log(arr.reduce(add))  // 10

17.Array.sort()

不传参按照字母顺序排列(字符串UniCode码)

该方法会改变原始数组

let arr = ["dfc", "cf", "lol", "anf"]
console.log(arr.sort());   // ["anf", "cf", "dfc", "lol"]
console.log(arr)   // ["anf", "cf", "dfc", "lol"]

利用特性升序排列(降序同理)

let arr = [4, 2, 3, 6, 9, 1]
console.log(arr.sort((a, b)=> a-b))
// [1, 2, 3, 4, 6, 9]　

18.Array.reverse()

将数组顺序翻转(会改变原始数组)

let arr = [11, 12, 14, 13]
console.log(arr.reverse())  // [13, 14, 12, 11]
console.log(arr)  // [13, 14, 12, 11]

19.Array.find(判断条件)

判断数组元素，当条件为true时结束循环，返回该元素

let arr = [1, 2, 3, 5, 7]
let num = a => a>3
console.log(arr.find(num))  // 5
console.log(arr) // [1, 2, 3, 5, 7]

20.Array.findIndex(判断条件)

判断数组元素，当条件为true时结束循环，返回该元素的 索引 如果没有符合条件的元素返回-1

let arr = [1, 2, 3, 5, 7]
let big3 = a => a>3
console.log(arr.findIndex(big3))  // 3
console.log(arr)  // [1, 2, 3, 5, 7]

21.Array.includes(item)

判断数组是否含有传入的判断元素，有返回true，没有返回false

[1, 2, 3].includes(2);     // true
[1, 2, 3].includes(4);     // false

22.Array.indexOf(item,index)

判断数组是否含有传入的判断元素，有返回该元素的索引，没有返回-1

let arr = ["a", "b", "c", "d"]
console.log(arr.indexOf("c"))       // 2
console.log(arr.indexOf("b", 2))    // -1

23.Array.lastIndexOf(item,index)

判断数组是否含有传入的判断元素，有返回该元素的索引最大值，没有返回-1

let arr = ["a", "b", "c", "d","c"]
console.log(arr.indexOf("c"))       // 4
console.log(arr.indexOf("c", 2))    // 2
console.log(arr.indexOf("c", 7))    // -1

24.Array.isArray()

判断对象是否为数组，是返回true，不是返回false

let obj = {}
let arr = []
Array.isArray(obj)  // false
Array.isArray(arr)  // true

25.Array.valueOf()

返回数组对象的原始值

let arr = [1,2,3]
console.log(arr.valueOf())  //  [1, 2, 3]

26.Array.entries()、27.Array.keys()、28.Array.values() 三种遍历方式

26.entries :键值对的遍历
27.keys:键名的遍历
28.values:值的遍历

let arr = ["a", "b", "c"]
let item = arr.entries()
console.log(item.next().value)  // [0, "a"]
console.log(item.next().value)  // [1, "b"]
console.log(item.next().value)  // [2, "c"]
console.log(item.next().value)  // undefined
 
let ikey = arr.keys()
console.log(ikey.next().value)  // 0
console.log(ikey.next().value)  // 1
console.log(ikey.next().value)  // 2
console.log(ikey.next().value)  // undefined
 
let ivalue = arr.values()
console.log(ivalue.next().value)  // a
console.log(ivalue.next().value)  // b
console.log(ivalue.next().value)  // c
console.log(ivalue.next().value)  // undefined

29.Array.flat(num)

将嵌套的数组分离成一个数组，num是嵌套的层次，num为Infinity就是不管嵌套几层

[1, 2, [3, 4]].flat()      // [1, 2, 3, 4]
[1, 2, [3, [4, 5]]].flat() // [1, 2, 3, [4, 5]]
[1, 2, [3, [4, 5]]].flat(2)// [1, 2, 3, 4, 5]
[1, [2, [3]]].flat(Infinity) // [1, 2, 3]
// 如果原数组有空位，flat()方法会跳过空位。
[1, 2, , 4, 5].flat()       // [1, 2, 4, 5]

30.Array.flatMap()

map()和flat()方法的结合，先执行map()后执行flat()

[2, 3, 4].flatMap((x) => [x, x * 2])
// [2, 4, 3, 6, 4, 8]

31.Array.fill()

将一个固定的元素替换数组

let arr = ["a", "b", "c", "d", "e"]
arr.fill("dd")
console.log(arr)  // ["dd", "dd", "dd", "dd", "dd"]
arr.fill("a", 1, 3)
console.log(arr)  // ["dd", "a", "a", "dd", "dd"]

32.Array.copyWithin()

将数组的指定索引位置复制到数组另外一个索引位置

• target：必需。复制到指定目标索引位置。
• start：可选。元素复制的起始位置。
• end：可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。

let arr = ["a", "b", "c", "d", "e", "f"];
arr.copyWithin(2, 0, 2);
console.log(arr)  // ["a", "b", "a", "b", "e", "f"]

33.Array.constructor

返回对象的构造函数

[1,2,3].constructor
// Array() { [native code] 

34.Array.form()

通过字符串创建一个数组。
用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组。如果对象是数组返回 true，否则返回 false。

Array.from("abcdef");
// ["a", "b", "c", "d", "e", "f"]