数组的总结

一、数组的概念：数组是把数据有序的管理起来，数组是对象类型

二、数组的使用：

（1）、申明一个数组的两种语法:

       1、字面量创建：方括号申明（比较常用）

let Array=[a,b,c,d,]

      2、构造函数：  Array是内置的构造函数，用于创建数组，所有的数组都是new Array 得到的，

let arr = new Array()

（2）、数组中可以存放任何数据类型

例如：

let arr = [ 'Apple', { name: 'lisa' }, true, function() { alert('hello'); } ]

（3）、数组按顺序保存，每一个数据都有自己的编号，从数组中取值，通过下标，从0开始，依次递增，数组中有长度，length。

    1、数组的取值方法：数组名[下标]

let color=['red','blue','yellow','green']
alert(color[0])  // red
alert(color[1])  // blue
alert(color[2])  // yellow
alert(color[3])  // green

    2、length属性的值是数组中元素的总个数， 最大下标=Array.length-1

    3、取数组中的最后一个元素，利用长度:arr.[arr.length-1]

    4、替换元素：

color[2]='pink' // 现在变成了['red','blue','pink','green']

    5、增加元素： 

color[4]='black' // color=['red','blue','pink','green','black']

三、遍历数组的方法：

1、for循环：for（let i = 0，i<arr.length,i++）{数组名[i]}

2、forEach：arr.forEach(function(item,index,o){})=>item:代表每一项，index：代表下标，o：代表当前数组本身，forEach循环一旦开始，中间不能被停到

arr.forEach(function(item, index, array) {
  // ... do something with item
});
["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
  alert(`${item} is at index ${index} in ${array}`);
});

3、find：返回数组中首次满足条件的元素，可遍历可按条件查找，（用法同上）

let result = arr.find(function(item, index, array) {
  // 如果返回 true，则返回 item 并停止迭代
  // 对于假值（falsy）的情况，则返回 undefined
});
let users = [
  {id: 1, name: "John"},
  {id: 2, name: "Pete"},
  {id: 3, name: "Mary"}
];

let user = users.find(item => item.id == 1);

alert(user.name); // John

4、findIndex：返回数组中首次满足条件的元素的索引值，可遍历可按条件查找

5、some：（找满足条件的元素时用some）查找满足条件的元素，有一个满足条件的就返回true，否则为false（有一个满足即可，满足条件即可），在找到对应的项之后，可以通过return true固定的语法，来终止some循环

6、every：查找满足条件的元素，都满足条件返true，有一个不满足false

7、filter：遍历筛选元素，把满足条件的元素筛选出来放回新数组

let results = arr.filter(function(item, index, array) {
  // 如果 true item 被 push 到 results，迭代继续
  // 如果什么都没找到，则返回空数组
});
let users = [
  {id: 1, name: "John"},
  {id: 2, name: "Pete"},
  {id: 3, name: "Mary"}
];

// 返回前两个用户的数组
let someUsers = users.filter(item => item.id < 3);

alert(someUsers.length); // 2

8、map：把每一项都遍历一遍回调函数，把最终的结果放在新数组里

let result = arr.map(function(item, index, array) {
  // 返回新值而不是当前元素
})
let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length);
alert(lengths); // 5,7,6

四、数组的方法：

（1）concat(), 合并两个数组，成为新数组

arr.concat(arg1, arg2...)
let arr = [1, 2];

// create an array from: arr and [3,4]
alert( arr.concat([3, 4]) ); // 1,2,3,4

// create an array from: arr and [3,4] and [5,6]
alert( arr.concat([3, 4], [5, 6]) ); // 1,2,3,4,5,6

// create an array from: arr and [3,4], then add values 5 and 6
alert( arr.concat([3, 4], 5, 6) ); // 1,2,3,4,5,6

（2）push（），尾部添加，返回值是新数组的长度，改变原数组

（3）unshift（），头部添加，返回值是新数组的长度，改变原数组

（4）pop(),尾部删除，返回删除后的数，

（5）shift（），头部删除，返回删除的数

（6）reverse(),反转数组

let arr = [1, 2, 3, 4, 5];
arr.reverse();

alert( arr ); // 5,4,3,2,1

（7）splice（startIndex，deleteCount，addElement），动态添加或删除，第一个参数表示从哪个坐标开始，第二个参数表示删除的数量，第三个表示添加的元素，返回值是删除的数组成的数组

arr.slice([start], [end])
let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s（复制从位置 1 到位置 3 的元素）

alert( arr.slice(-2) ); // s,t（复制从位置 -2 到尾端的元素）

（8）indexOf（），查找，查找数组里某个元素首次出现的位置，找到了就返回索引值，找不到就返回-1（只能找基础类型）

arr.indexOf(item, from) 从索引 from 开始搜索 item，如果找到则返回索引，否则返回 -1
let arr = [1, 0, false];

alert( arr.indexOf(0) ); // 1
alert( arr.indexOf(false) ); // 2
alert( arr.indexOf(null) ); // -1

（9）lastIndexOf(),查找，查找数组某个元素最后出现的位置，找到了就返回索引值，找不到就返回-1

arr.lastIndexOf(item, from) —— 和上面相同，只是从右向左搜索。

（10）join(),连接数组的每个元素成为字符串

let arr = ['Bilbo', 'Gandalf', 'Nazgul'];

let str = arr.join(';'); // 使用分号 ; 将数组粘合成字符串

alert( str ); // Bilbo;Gandalf;Nazgul

（11）sort(),对原数组单元值排序 arr.sort(function(a,b){return(a-b)})正着排序

let arr = [ 1, 2, 15 ];

// 该方法重新排列 arr 的内容
arr.sort();

alert( arr );  // 1, 15, 2

（12）reduce()方法：累加器，把每一次的循环结果累加起来，对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值，

语法：arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

let value = arr.reduce(function(accumulator, item, index, array) {
  // ...
}, [initial]);

（13）includes(item,from),从索引from开始搜索item，如果有就返回true，如果没有则返回false，合适基础数据类型

arr.includes(item, from) —— 从索引 from 开始搜索 item，如果找到则返回 true（译注：如果没找到，则返回 false）

（14）str.split(delim) 它通过给定的分隔符 delim 将字符串分割成一个数组

let names = 'Bilbo, Gandalf, Nazgul';

let arr = names.split(', ');

for (let name of arr) {
  alert( `A message to ${name}.` ); // A message to Bilbo（和其他名字）
}

五、数组的解构（本质是变量赋值）

（1）、变量少，值多，一一对应，只取前面的

（2）、变量对，值少，一一对应，剩下的变量只定义不赋值，就是undefined

（3）、剩余值取法：eg：...c =>c保存剩下的所有数值，是个数组

（4）、按需取值：取谁给谁赋值，剩下的用逗号占位

六、判断是否是数组的方法：

1、Array.isArray（）,判断是否属于数组

2、instanceof，判断是否是数组

3、伪数组转化为真数组Array.from，伪数组必须有length