一、数组的创立
1、应用 Array 构造函数
const arr1 = new Array(); // 创立一个空数组
const arr2 = new Array(20); // 创立一个蕴含 20 项的数组
const arr3 = new Array("lily","lucy","Tom"); // 创立一个蕴含 3 个字符串的数组 2、应用数组字面量表示法
const arr4 = []; // 创立一个空数组
const arr5 = [20]; // 创立一个蕴含 1 项的数组
const arr6 = ["lily","lucy","Tom"]; // 创立一个蕴含 3 个字符串的数组 二、数组的办法
0、Array.isArray()
用于判断一个对象是否为数组，如果对象是数组返回 true 否则返回 false
const arr=[]
const obj={}
const str=''
console.log(Array.isArray(arr),Array.isArray(obj),Array.isArray(str)) // true,false,false1、join() 不会扭转原数组
join() 办法用于把数组中的所有元素放入一个字符串。
元素是通过指定的分隔符进行分隔的。该办法只接管一个参数：分隔符（默认为逗号）如果省略该参数，则默认应用逗号作为分隔符。
留神，返回值是拼接后的字符串！！类型为字符串！！！
const arr = [1,2,3];
console.log(arr.join('') // 123
console.log(arr.join()); 这就相当于 console.log(arr.join(',')); // 1,2,3
console.log(arr.join("-")); // 1-2-3
console.log(arr); // [1, 2, 3]（原数组不变）// 空数组的状况
console.log([].join()) // '' 不论用什么分隔符都是空字符串 2、push() 会扭转原数组
接管任意个数的元素，把它们一一增加到数组开端，返回值是批改后数组的长度
const arr = ["a","b","c"];
const item = arr.push("d","e");
console.log(item); // 5
console.log(arr); // ["a", "b", "c", "d", "e"]
// 空数组的状况
console.log([].push('a')) // 'a' 3、pop() 会扭转原数组，如果数组曾经为空，则 pop() 不扭转数组，并返回 undefined 值。\
删除数组开端最初一项，返回值是被删除元素的值
const arr = ["a","b","c"];
const item = arr.pop();
console.log(item); // c
console.log(arr); // ["a", "b"]
// 空数组的状况
console.log([].pop()) // undefined 4、shift() 会扭转原数组，如果数组曾经为空，则 shift() 不扭转数组，并返回 undefined 值。\
删除数组第一项，并返回删除元素的值
const arr = ["a","b","c"];
const item = arr.shift();
console.log(item); // a
console.log(arr); // ["b", "c"]
// 空数组的状况
console.log([].shift()) // undefined5、unshift() 扭转原数组，返回值是更改后数组的长度 \
将参数增加到原数组结尾，并返回数组的长度
const arr = ["a","b","c"];
const count = arr.unshift("d","e");
console.log(count); // 5
console.log(arr); //["d", "e", "a", "b", "c"]
// 空数组的状况
const testArr=[]
console.log(testArr.unshift('aa')) // 1
console.log(testArr) // aa6、sort() 扭转原数组，是在原数组上进行排序
语法：arrayObject.sort(sortby)
sortby 可选。规定排序程序。必须是函数。 如果调用该办法时没有应用参数，将按字母程序对数组中的元素进行排序，说得更准确点，是依照 字符编码 的程序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比拟。
如果想依照其余规范进行排序，就须要提供比拟函数，该函数要比拟两个值，而后返回一个用于阐明这两个值的绝对程序的数字。比拟函数应该具备两个参数 a 和 b，其返回值如下：
- 若 a 小于 b，在排序后的数组中 a 应该呈现在 b 之前，则返回一个小于 0 的值。
- 若 a 等于 b，则返回 0。
<!—->
- 若 a 大于 b，则返回一个大于 0 的值。
默认按升序排列数组项，排序时会调用每个数组项的 toString() 转型办法，而后比拟失去的字符串，以确定如何排序。即便数组中的每一项都是数值，sort() 办法比拟的也是字符串，因而会呈现以下的这种状况
const arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort()); // ["a", "b", "c", "d"]
const arr2 = [13, 24, 51, 3];
console.log(arr2.sort()); // [13, 24, 3, 51]
console.log(arr2); // 13, 24, 3, 51
为了解决上述问题，sort() 办法能够接管一个比拟函数作为参数
const arr2 = [13, 24, 51, 3];
/ 比拟函数：function(a,b){return b-a} b-a 代表依照降序进行排序 a-b 则依照升序进行
console.log(arr2.sort(function(a,b){return b-a})); // [51, 24, 13, 3]
console.log(arr2); 原数组被扭转了 // [51, 24, 13, 3]
// 空数组的状况
const testArr=[]
console.log(testArr.sort()) // []
console.log(testArr) // []\
7、reverse() 会扭转原来的数组
reverse() 办法用于颠倒数组中元素的程序。返回值就是扭转程序后的数组
const arr = [13, 24, 51, 3];
console.log(arr.reverse()); // [3, 51, 24, 13]
console.log(arr); // [3, 51, 24, 13]
// 空数组的状况
const testArr=[]
console.log(testArr.reverse()) // []
console.log(testArr) // []\
8、concat() 该办法不会扭转现有的数组，而仅仅会返回被连贯数组的一个正本。\
将一个参数或者多个参数连贯到原数组的正本中，没参数时只是复制以后数组并返回正本。
const arr = [1,3,5,7];
const arrConcat = arr.concat(9,[11,13],{a:'bb'});
console.log(arrConcat); // [1, 3, 5, 7, 9, 11, 13,{a:'bb'}]
console.log(arr); // [1, 3, 5, 7]9、slice() 不会扭转原数组，返回值是选定元素组成的新数组
返回从原数组中指定开始下标到完结下标之间的项组成的新数组
只有首个参数时，返回从该参数地位开始到开端的所有项 (如果是正数，那么它规定从数组尾部开始算起的地位。也就是说，-1 指最初一个元素，-2 指倒数第二个元素，以此类推。)
如果有两个参数，返回起始和完结地位之间的项（但不包含完结地位的项；如果是正数，那么它规定从数组尾部开始算起的地位。也就是说，-1 指最初一个元素，-2 指倒数第二个元素，以此类推。）
const arr = [1,3,5,7,9,11];
console.log(arr.slice()) // [1,3,5,7,9,11]
const arrCopy = arr.slice(1);
console.log(arrCopy); // [3, 5, 7, 9, 11]
const arrCopy2 = arr.slice(1,4);
console.log(arrCopy2); // [3, 5, 7]
const arrCopy3 = arr.slice(1,-2);
console.log(arrCopy3); // [3, 5, 7]
const arrCopy4 = arr.slice(-4,-1);
console.log(arrCopy4); // [5, 7, 9]
/ 留神当只有 start 参数时，负数与正数的区别
const testArr=[1,2,3,4]
console.log(testArr.slice(2)) //[4]
console.log(testArr.slice(3)) // []
console.log(testArr.slice(-1)) // [4]
console.log(testArr.slice(-1,-2)) // []
console.log(testArr.slice(-2,-1)) //[3]
// 空数组的状况
const testArr=[]
console.log(testArr.slice()) // []
console.log(testArr) // []10、splice() 会扭转原始数组，返回值是 蕴含被删除我的项目的新数组（如果有的话）, 空数组调用此办法不会有操作，也不会报错
能够对数组元素实现删除、插入和替换性能
删除：2 个参数：起始地位、要删除的项数和要插入的项（这里为空）。例如，splice(0,2) 会删除数组中的前两项
const arr = [1,2,3,4,5];
const arrRemoved = arr.splice(0,2);
console.log(arr); // [3, 4, 5]
console.log(arrRemoved); // [1, 2]插入：3 个参数：起始地位、要删除的项数（这里为 0）和要插入的项。例如，splice(2,0,6,7) 会从以后数组的地位 2 开始插入 6 和 7
const arr = [1,2,3,4,5];
const arrRemoved2 = arr.splice(2,0,6,7);
console.log(arr); // [1, 2, 6, 7, 3, 4, 5]
console.log(arrRemoved2); // [] 这里因为没有被删除的我的项目，所有返回值为空数组 替换：3 个参数：起始地位、要删除的项数和要插入的项。例如，splice (1,1,6,7) 会删除以后数组地位 1 的项，而后再从地位 1 开始插入 6 和 7。
const arr = [1,2,3,4,5];
const arrRemoved3 = arr.splice(1,1,6,7);
console.log(arr); // [1, 6, 7, 3, 4, 5]
console.log(arrRemoved3); // [2] 这里是有删除我的项目，所以返回的值是被替换的那个被删除我的项目的新数组 splice() 办法始终都会返回一个数组，该数组中蕴含从原始数组中删除的项，如果没有删除任何项，则返回一个空数组 11、indexOf() 不会扭转原数组，可返回数组中某指定元素的索引，如果在数组中没有找到则返回 -1
接管两个参数：要查找的那个数组元素和起始地位（默认从 0 开始），查找方向从左往右
const arr = [1,3,5,7,5,3,1];
console.log(arr.indexOf(5)); // 2
console.log(arr.indexOf(5,2)); // 2
console.log(arr.indexOf(5,3)); // 4
/ 空数组状况
console.log([].indexOf(9)) // -112、lastIndexOf() 不会扭转原数组，和 indexOf 相似，区别在于查找办法从右到左
接管两个参数：要查找的项和起始地位（默认从开端开始），查找方向从右往左
const arr = [1,3,5,7,5,3,1];
console.log(arr.lastIndexOf(5)); // 4
console.log(arr.lastIndexOf(5,4)); // 4
console.log(arr.lastIndexOf(5,3)); // 2
console.log(arr.lastIndexOf(5,2)); // 2
console.log(arr.lastIndexOf(5,1)); // -113、forEach() 可能会扭转原数组，在原数组的根底上进行遍历，遍历过程中能够操作原数组外部元素
对数组进行遍历循环，对数组中的每一项运行参数的函数。参数都是 function 类型，其中对应的参数别离为：遍历的数组内容，对应的数组索引，数组自身
const arr = ["a", "b", "c"];
arr.forEach(function(x, index,a){console.log(x,index,a);
});
// a 0 ["a", "b", "c"]
// b 1 ["a", "b", "c"]
// c 2 ["a", "b", "c"]
留神：return 无奈使 forEach 进行遍历 14、map() 不会扭转原数组，返回的是一个新数组，新数组中的元素为原始数组元素调用函数解决后的值
指“映射”，对数组中的每一项运行参数的函数，并返回每次函数调用的后果组成的数组
留神：map() 不会对空数组进行检测
const arr = [1, 2, 3, 4, 5];
const arr2 = arr.map(function(x){return x*x;});
console.log(arr2); // [1, 4, 9, 16, 25]
# 空数组状况
map 不会对空数组进行检测 留神一种状况
const arr1=[1,2,3,4,5,6]
const arr2=[3,4,5]
# map 办法是 return 前面跟的后果是什么就把这个值增加进新数组里
const arr3=arr1.map(item=>{return arr2.includes(item)
})
console.log(arr3) // [false,false,true,true,true,false]
const arr4=arr1.map(item=>{return item<3})
console.log(arr4) // [true, true, false, false, false, false]
# filter 办法是 return 前面的判断条件为 true 时，会把以后 item 返回到新数组里
const arr5=arr1.filter(item =>{return arr2.includes(item)
})
console.log(arr5) // [3, 4, 5]15、filter() 不会扭转原始数组，返回值是满足筛选条件的新数组
filter() 办法创立一个新的数组，新数组中的元素是通过查看指定数组中符合条件的所有元素。
留神：filter() 不会对空数组进行检测
指“过滤”，数组中的每一项运行参数的函数，并返回满足过滤条件组成的数组
const arr = [1, 2, 3, 4, 5];
const arr2 = arr.filter(function(x, index) {return x > 3 || index < 2;});
console.log(arr2); // [1, 2, 4, 5]16、every() 不会扭转原数组，返回值为 true 或 false
判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回 true。
留神：every() 不会对空数组进行检测
const arr = [1, 2, 3, 4, 5];
const arr2 = arr.every(function(x) {return x < 10;});
console.log(arr2); // true
const arr3 = arr.every(function(x) {return x < 3;});
console.log(arr3); // false
// 空数组状况
every 不会对空数组进行检测 17、some() 不会扭转原数组
判断数组中是否存在满足条件的项，只有有一项满足条件，就会返回 true。
留神：不会对空数组进行检测
const arr = [1, 2, 3, 4, 5];
const arr2 = arr.some(function(x) {return x < 3;});
console.log(arr2); // true
const arr3 = arr.some(function(x) {return x < 1;});
console.log(arr3); // false18、reduce() 对于空数组是不会执行回调函数的
实现迭代数组的所有项，而后构建一个最终返回的值。reduce() 接管两个参数：在每一项上调用的函数，作为归并根底的初始值。其中函数接管 4 个参数：前一个值、以后值、项的索引和数组对象
const values = [1,2,3,4,5];
const sum = values.reduce(function(prev, x, index, array){return prev + x;},10);
console.log(sum); // 2519、reduceRight()
与 reduce() 同理，但遍历是从右往左，与 reduce() 反向
20、valueOf() 不会扭转原数组
valueOf() 办法返回 Array 对象的原始值
const arr=['aa','bb','cc']
console.log(arr.valueOf()) // ['aa','bb','cc']
console.log(arr) // ['aa','bb','cc']21、toString() 不会扭转原数组
toString() 办法可把数组转换为字符串，返回值是用逗号连贯的字符串！！类型为字符串！！！
const arr=[1,2,3,4,5]
const arr1=arr.toString()
console.log(arr1,arr) // '1,2,3,4,5' [1,2,3,4,5]
空数组状况
const arr2=[]
console.log(arr2.toString()) // ''22、Array.from() 返回的是真正的数组
Array.from() 办法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。那么什么是类数组对象呢？所谓类数组对象，最根本的要求就是具备 length 属性的对象。
22.1、将类数组对象转换为真正数组：
let arrayLike = {
0: 'tom',
1: '65',
2: '男',
3: ['jane','john','Mary'],
'length': 4
}
let arr = Array.from(arrayLike)
console.log(arr) // ['tom','65','男',['jane','john','Mary']]
let arrayLike2 = {
'0': 'a',
'1': 'b',
'2': 'c',
length: 3
};
// ES5 的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']
// ES6 的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']那么，如果将下面代码中 length 属性去掉返回的是一个长度为 0 的空数组。如下：
const arrLike={0:'a',1:'b',2:'c'}
console.log(Array.from(arrLike)) // []
然而，针对 set 构造的数据能够间接转为数组，eg：const arr=['a','b','c','d']
const setArr=new Set(arr) / 打印出的 setArr 是：Set(4) {"a", "b", "c", "d"}
console.log(Array.from(setArr)) // ['a','b','c','d']这里将代码再改一下，就是具备 length 属性，然而对象的属性名不再是数字类型的，而是其余字符串型的，代码如下：
let arrayLike = {
'name': 'tom',
'age': '65',
'sex': '男',
'friends': ['jane','john','Mary'],
length: 4
}
let arr = Array.from(arrayLike)
console.log(arr) // [undefined, undefined, undefined, undefined]
#只有 length 属性的对象
let arrayLike = {length: 4}
let arr = Array.from(arrayLike)
console.log(arr) // [undefined, undefined, undefined, undefined]会发现后果是长度为 4，元素均为 undefined 的数组
由此可见，要将一个类数组对象转换为一个真正的数组，必须具备以下条件：
1、该类数组对象必须具备 length 属性，用于指定数组的长度。如果没有 length 属性，那么转换后的数组是一个空数组。
2、该类数组对象的属性名必须为数值型或字符串型的数字
ps: 该类数组对象的属性名能够加引号，也能够不加引号
22.2、将 Set 构造的数据转换为真正的数组：
let arr = [12,45,97,9797,564,134,45642]
let set = new Set(arr)
console.log(set) //
console.log(Array.from(set)) // [12, 45, 97, 9797, 564, 134, 45642]Array.from 还能够承受第二个参数，作用相似于数组的 map 办法，用来对每个元素进行解决，将解决后的值放入返回的数组。如下：
let arr = [12,45,97,9797,564,134,45642]
let set = new Set(arr)
console.log(Array.from(set, item => item + 1)) // [13, 46, 98, 9798, 565, 135, 45643]22.3、将字符串转换为数组：
let str = 'hello world!';
console.log(Array.from(str)) // ["h", "e", "l", "l", "o", "","w","o","r","l","d","!"]22.4、Array.from 参数是一个真正的数组：
console.log(Array.from([12,45,47,56,213,4654,154])) // [12,45,47,56,213,4654,154]像这种状况，Array.from 会返回一个截然不同的新数组
23、Array.of()
用于将一组值，转换为数组。
Array.of(3, 11, 8) // [3, 11, 8]
Array.of(3) // [3]
与 Array() 的行为有所区别
Array(3, 11, 8) // [3, 11, 8]
Array(3) // [, , ,] ----Array(3) 含意是创立一个长度为三且每个元素都为 undefined 的数组;
Array 和 new Array 用法一样，性能也一样 24、find() 不会扭转原数组
留神：对于空数组，函数不会执行
用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员顺次执行该回调函数，直到找出第一个返回值为 true 的成员，而后返回该成员。如果没有符合条件的成员，则返回 undefined
[1, 5, 10, 15].find(function(value, index, arr) {return value > 9;}) // 1025、findIndex() 不会扭转原数组
留神：对于空数组，函数不会执行
用法与 find 办法十分相似，返回第一个符合条件的数组成员的地位，如果所有成员都不符合条件，则返回 -1。
[1, 5, 10, 15].findIndex(function(value, index, arr) {return value > 9;}) // 226、fill() 会扭转原数组，返回更改后的数组
应用给定值，填充一个数组
留神：对空数组不进行执行
['a', 'b', 'c'].fill(7) // [7, 7, 7] 只传一个参数就是数组有几个就替换为 fill 括号里的
如果承受第二个和第三个参数，用于指定填充的起始地位和完结地位
['a', 'b', 'c'].fill(7, 1, 2) // ['a', 7, 'c']
下面代码示意，fill 办法从索引 1 开始，向原数组填充 7，到索引 2 之前完结 27、includes()
语法：arr.includes(searchElement) searchElement：必须。须要查找的元素值。arr.includes(searchElement, fromIndex) fromIndex：可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜寻。默认为 0。如果 fromIndex 大于等于数组长度，则返回 false。该数组不会被搜寻:
const arr = ['a', 'b', 'c'];
arr.includes('c', 3); //false
arr.includes('c', 100); // false
计算出的索引小于 0
如果 fromIndex 为负值，计算出的索引将作为开始搜寻 searchElement 的地位。如果计算出的索引小于 0，则整个数组都会被搜寻。// 数组长度是 3
// fromIndex 是 -100
// computed index 是 3 + (-100) = -97
const arr = ['a', 'b', 'c'];
arr.includes('a', -100); // true
arr.includes('b', -100); // true
arr.includes('c', -100); // true判断数组是否蕴含给定的值，返回布尔值
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, NaN].includes(NaN); // true
第二个参数示意搜寻的起始地位（默认为 0）[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true三、遗留问题：
1、哪些办法会扭转原数组，哪些办法会返回新数组？
2、map 和 filter 在 return 时候的区别？
3、如果数组为空，这些办法又会如何执行？