js数组方法

1.Array.from()

console.log(Array.from('foo'));
// ["f", "o", "o"]

console.log(Array.from([1, 2, 3], x => x + x));
// [2, 4, 6]

1. 参数
   – 伪数组对象 -> 拥有一个 length 属性和若干索引属性的任意对象
2. 返回值
   – 新的数组
3. form的length属性为 1

详情查看此链接 - 转自

2.Array.isArray() 常用

Array.isArray(new Array('a', 'b', 'c', 'd'))

// 下面的函数调用都返回 false Array.isArray(); Array.isArray({}); ```

1. 返回值  true /  false

判断是不是一个数组 - 详情- 转自

3.Array.of()

1. 参数
   – 任意的类型
2. 返回值
   – 组成数组

Array.of(1);         // [1]
Array.of(1, 2, 3);   // [1, 2, 3]
Array.of(undefined); // [undefined]

转成一个数组 - 详情- 转自

4.Array.concat()

1. 参数
2. 返回值
   – 原数组不会改变

 1. tip  改变引用类型对象的值对应的 数组也会改变

5.Array.every() 常用

1. 每一项都是true 则返回 true   反之 - 返回 false ```

---

6.Array.some() 常用

1. 任意一项是true 则返回 true     反之 - 返回 false ```

---

7.Array.filter() 常用

`返回值

一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组

var filtered = [12, 5, 8, 130, 44].filter(item => item > 11)  // [12, 130, 44] // 不会改变原数组 ```

---

8.Array.find() Array.findIndex() 常用

 var inventory = [ {name: 'apples', quantity: 2}, {name: 'bananas', quantity: 0},  {name:'cherries',quantity: 5} ];

 function findCherries(fruit) { 
    return fruit.name === 'cherries'; 
 }

 console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 } ```

>
```javascript 
const ary = [5, 12, 8, 130, 44];

const found = ary.find(item => item > 10);

console.log(found); // 12

目的： 数组中寻找符合条件的值 找到并返回对应的值 终止循环

区别在于 findIndex 返回的是 符合条件的索引 具体情况看下边的链接
详情查看 - 转自

9.Array.slice() 常用

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

1. slice() 方法返回一个新的数组对象，
2. 这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括
   begin，不包括end)
3. 原始数组不会被改变
4. 如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素
5. 如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）

10.Array.splice()

1. var myFish = ["angel", "clown", "mandarin", "sturgeon"];
2. var removed = myFish.splice(2, 0, "drum");

// 运算后的 myFish: ["angel", "clown", "drum", "mandarin", "sturgeon"]
// 被删除的元素: [], 没有元素被删除

1. var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
2. var removed = myFish.splice(2, 0, 'drum', 'guitar');

// 运算后的 myFish: ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]
// 被删除的元素: [], 没有元素被删除

1. var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
2. var removed = myFish.splice(3, 1);

// 运算后的 myFish: ["angel", "clown", "drum", "sturgeon"]
// 被删除的元素: ["mandarin"]

1. var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
2. var removed = myFish.splice(2, 1, "trumpet");

// 运算后的 myFish: ["angel", "clown", "trumpet", "sturgeon"]
// 被删除的元素: ["drum"]

1. var myFish = ['angel', 'clown', 'trumpet', 'sturgeon'];
2. var removed = myFish.splice(0, 2, 'parrot', 'anemone', 'blue');

// 运算后的 myFish: ["parrot", "anemone", "blue", "trumpet", "sturgeon"]
// 被删除的元素: ["angel", "clown"]

1. var myFish = ['parrot', 'anemone', 'blue', 'trumpet', 'sturgeon'];
2. var removed = myFish.splice(myFish.length - 3, 2);

// 运算后的 myFish: ["parrot", "anemone", "sturgeon"]
// 被删除的元素: ["blue", "trumpet"]

1. var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
2. var removed = myFish.splice(-2, 1);

// 运算后的 myFish: ["angel", "clown", "sturgeon"]
// 被删除的元素: ["mandarin"]

1. splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,
2. 并以数组形式返回被修改的内容
3. 改变原数组

10.Array.includes() 常用

作用 - 判断数组中是否存在 某个值 存在 返回true 反之 返回 - false

11.Array.indexOf() 常用

作用 1. 判断某个值 在不在数组中 如果存在 返回下标（索引） 反之 - 返回 -1

12.Array.join() 常用

作用 1. 数组按制定 字符 转化成 -> 字符串

---

13.Array.map()常用

返回值 ：有返回值  return 什么返回的就是什么 对比 Array.forEach()

---

14.Array.forEach()

作用 ： 循环数组 返回值 ： undefined

---

15 Array.reduce() 常用

const array1 = [1, 2, 3, 4];
const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));
// expected output: 10

// 5 + 1 + 2 + 3 + 4
console.log(array1.reduce(reducer, 5));
// expected output: 15

[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array){
  return accumulator + currentValue;
});

var maxCallback = ( acc, cur ) => Math.max( acc.x, cur.x );
var maxCallback2 = ( max, cur ) => Math.max( max, cur );

// reduce() 没有初始值
[ { x: 22 }, { x: 42 } ].reduce( maxCallback ); // 42
[ { x: 22 }            ].reduce( maxCallback ); // { x: 22 }
[                      ].reduce( maxCallback ); // TypeError

// map/reduce; 这是更好的方案，即使传入空数组或更大数组也可正常执行
[ { x: 22 }, { x: 42 } ].map( el => el.x )
                        .reduce( maxCallback2, -Infinity );

以上均参看这个地址

1. 参数
   Accumulator (acc) (累计器)
   Current Value (cur) (当前值)
   Current Index (idx) (当前索引)
   Source Array (src) (源数组)

常用的没什么好介绍

1. Array.shift() // 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度
2. Array.unshift() // 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)
3. Array.pop() // 方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度
4. Array.push() // 方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度
5. Array.reverse() // 方法将数组中元素的位置颠倒。改变原数组
6. Array.sort() // 排序
7. new set() // ES7 快速去重