Array 数组
最后更新于：2022-04-02 03:25:05
[TOC]
## 静态方法
### `Array.isArray()`
### `from` 把可转数组的伪数组转数组
```
Array.from('foo'); // [ "f", "o", "o" ]
const set = new Set(['foo', 'bar', 'baz', 'foo']);
Array.from(set); // [ "foo", "bar", "baz" ]
Array.from([1, 2, 3], x => x + x); // [2, 4, 6]
```
## 实例方法
### `push()`后添加，`pop()`后删除
```
var arr = [];
arr.push(1) // 1
arr.push('a') // 2
arr.push(true, {}) // 4
arr // [1, 'a', true, {}]
```
### `shift()` 前删除，`unshift()` 前添加
### `join()` 数组转字符串
```
var a = [1, 2, 3, 4];
a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
```
可以打包类似数组的
```
Array.prototype.join.call('hello', '-') ;// "h-e-l-l-o"
var obj = { 0: 'a', 1: 'b', length: 2 };
Array.prototype.join.call(obj, '-') ; // 'a-b'
```
### `concat()` 并接数组
```
[].concat(['1','3',['4','6']],'2'); //[ '1', '3', [ '4', '6' ], '2' ]
```
对象是浅拷贝
```
var b={};
var a=[];
var c = a.concat(b);
b.h='hello';
c[0].h;//hello
```
### `reverse()`颠倒元素排列
### `slice(start,end)` 截取元素,返回新数组
### `splice()` 删除原始数组一部分,并添加新数组,返回值是被删元素
```
var my = new Array ("1", "2", "3", "4", "5");
my.splice(1,2,"a","b","c") // ["2", "3"]
my //["1", "a", "b", "c", "4", "5"]
```
### `sort()`排序
自定义排序函数
```
var myArray = new Array("Wind", "Rain", "Fire");
myArray.sort(); // [ "Fire", "Rain", "Wind" ]
[{ name: "张三", age: 30 },
{ name: "李四", age: 24 },
{ name: "王五", age: 28 }
].sort(function (o1, o2) {
return o1.age - o2.age;
})
// [
// { name: "李四", age: 24 },
// { name: "王五", age: 28 },
// { name: "张三", age: 30 }
// ]
```
### `map()` 遍历数组方法 ,返回新数组
```
var a=[4,5,67]
var new_a = a.map(function (t,index,arr) {
console.log(arr);//[ 4, 5, 67 ]
return t+a[index+1];
})
console.log(new_a);//[ 9, 72, NaN ]
```
map 可传入第二个参数,可通过this调用
```
var arr = ['a', 'b', 'c'];
[1, 2].map(function (e) {
console.log(this);//[ 'a', 'b', 'c' ]
return this[e];
}, arr)
```
### `forEach()` 无返回值
与`map`类似,但是没有返回值
`forEach()` 无法中断 `break`
### `filter()`
回调函数可传入三个参数,当前成员，当前位置和整个数组
```
a.filter(function (t) {
return t>6
})//[ 56, 7, 8 ]
a//[ 3, 4, 56, 7, 8 ]
```
`filter`方法还可以接受第二个参数,使过滤函数可扩展
```
var a=[1,2,3,4];
var b={max:3}
a.filter(function (t) {
return t > this.max
}, b);//[ 4 ]
a;//[ 1, 2, 3, 4 ]
```
### `some()`,`every()` 至少一个ture/所有多为true
`some`至少一个true,返回true，`evety()`每个为`true` 则为`true`
1. 回调函数可接受三个参数(当前元素,元素位置,整个数组)
2. 可接受第二参数, 可用`this `调用
```
var a=[1,2,3,4];
a.some(function (t) {
return t > 1
});//true
a.every(function (t) {
return t > 1
});//false
```
### `reduce()`，`reduceRight()`
reduce与reduceRight 支持四个参数
1. 累积变量，默认为数组的第一个成员 (必须)
2. 当前变量，默认为数组的第二个成员 (必须)
3. 当前位置（从0开始）
4. 原数组
```
var a=[1,2,3,4];
a.reduce(function (a, b) {
// a 为上次结果的值
// b 为第二个结果开始
return a + b
});//10
```
如果传入第二个参数,则 第一次的a为传入的值,b从0 位置开始
```
var a=[1,2,3,4];
a.reduce(function (a, b) {
// a 为上次结果的值
// b 为第二个结果开始
console.log('a',a);
return a + b
},100);//110
```
由于可以遍历数组,则可做此相关操作,如找出最大字符
```
var a=['12132222','213213','a']
console.log(a.reduce(function (b, c) {
return b.length > c.length ? b : c;
}));
```
### `indexOf()`，`lastIndexOf()`
```
var a = ['a', 'b', 'a', 'b', 'a'];
console.log(a.indexOf('b')); // 1
console.log(a.indexOf('b', 2)); // 3
```
### `find()`,`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 }
```
### `entries()`数组转 Iterator
```
const array1 = ['a', 'b', 'c'];
const iterator1 = array1.entries();
console.log(iterator1.next().value);
// expected output: Array [0, "a"]
console.log(iterator1.next().value);
// expected output: Array [1, "b"]
```
### `find()` 返回符合函数的第一个值
```
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 }
```
### `flat()` 二维数组平摊成一维
```
var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]
```
### `includes()` 是否存在值
```
const array1 = [1, 2, 3];
console.log(array1.includes(2));
// expected output: true
```
### 链式使用
```
var users = [
{name: 'tom', email: 'tom@example.com'},
{name: 'peter', email: 'peter@example.com'}
];
users
.map(function (user) {
return user.email;
})
.filter(function (email) {
return /^t/.test(email);
})
.forEach(function (email) {
console.log(email);
});
// "tom@example.com"
```
### 字符串转字符
```
Array.prototype.forEach.call("a string", function(chr) {
console.log(chr);
});
```
';