属性
length 是Array的实例属性。返回或设置一个数组中的元素个数。该值是一个无符号 32-bit 整数，并且总是大于数组最高项的下标，不只是可读。
Array.prototype 属性表示 Array 构造函数的原型，并允许您向所有Array对象添加新的属性和方法。
检查数组
Array.isArray()：最终判断这个值是不是数组
转换方法
valueof()：返回的还是数组本身
toString()：返回的由每个值的字符串形式拼接而成的一个以逗号分隔的字符串
join(),通过使用这个方法则可以使用不同的分隔符来构造这个字符串
alert()：输出数组的时候会自动的调用toString();
栈方法（对数组的本身的修改）
push:代表后进,后面再添加是所以叫后进
push(),把参数渐渐添加的末尾，并且返回添加后的数值长度
pop(),从数组末尾移除最后一项,返回移除的项
从而待到了先进后出，后进push先出pop
队列方法(对数组的修改)
push(),把参数渐渐添加的末尾，并且返回添加后的数值长度
shift(),从数组的前端移除一项，返回移除的项
从而达到了后进push后出也就是前面的先出shift()
外加
unshift()可以在数组前端添加任意个项,并返回数组的长度
重排序方法
reverse():反转
sort():应为这个得到的是toString后的数组的值全是字符串的比较，所以字符串的比较（字符编码值）而不是数值的字面量
所以有了给sort()添加一个比较函数的方法
操作方法
concat()：在没有参数的情况下复制一个原来的数组，如果有参数，则会吧参数（字符串）添加到数组中，就算参数是一个数组也是一项，一项的加载末尾，对原数组无印象
slice（指定的开始位置，结束的位置）：这里面的位置代表的是数组项所在的位置从0开始，该方法会返回一个在这个区间之间的项，不包括最后一项，这个方法不印象原数组
splice（要删除或插入第一项的位置，要删除的项数，和插入任意数量的项）
从而可以达到删除，插入，替换的能力
位置方法
indexOf(要查找的项（全等比较），查找的启始的位置)
在没找的情况下返回-1，如果有就返回找到项所在的位置
迭代和归并的方法
下面是具体是案例操作
创建数组的基本方式有两种
1.使用Array()构造函数
var colors = new Array(20);
console.log(colors.length);//20
创建3个字符串
var colors = new Array("z","q","x");
当Array的参数为一个数，为数值和为其他是不同的
var colors = new Array(3);
console.log(colors.length);//3
var colors =new Array("zqx");
console.log(colors.length);//1这里也说明了数组不等同于变量不会提前编译;
2.数组字变量表示法(与对象一样，在使用数值字面量表示法时，也不会调用Array构造函数)
var colors = ["z","q","x"];//创建一个3个字符串的数组
console.log(colors);//3
与对象一样,在使用数组字面量的表示法时,也不会调用Array构造函数
var colors = [];//创建以个空数组
console.log(colors);//0
var colors = [1,2,]//不可以这样！这样会创建一个包含2或3项的数组，chrome浏览器是显示3;
console.log(colors);//2
在读取和设置数组的值时，用[key]可以显示，修改，新增
var colors = ["red","blue","green"];
console.log(colors[0])//显示第一项"red"
colors[2] = "black"; //修改
console.log(colors[2])//"black"
colors[3] = "brown"; //新增
console.log(colors[3])//"brown"
注：length并不是只读的可以从数组的末尾或向数组中添加新项
var colors = ["red","blue","green"];
colors.length = 2; //去除
console.log(colors[2]); //undefined;
var colors = ["red","blue","green"];
colors.length = 4; //添加
console.log(colors[4]); //undefined;
给数组最后一项添加一个值
var colors = ["red","blue","green"];
colors.length = 4; //添加
colors[colors.length] = "black"//给数组最后一项添加值
检查数组
Array.isArray()
if(Array.isArry(value)){}//IE9以上支持
转换方法
每个对象都具有 toLocaleString()，toString(),valueOf();
其中调用valueOf()返回的还是数组的本身，
toString()方法会返回由数组中每个值的字符串形式(就算原来的是数值)拼接而的一个以逗号分隔的字符串；
var colors = ["red","blue","green",5];
console.log(colors.toString());//""red","blue","gree","5""
console.log(colors.valueOf());//(4) ["red", "blue", "green", 5]返回数组本身
插曲：由于alert()要接受字符串参数所以他会在后台调用toString()方法
join():数组的链接符
如果使用join()方法，则使用不同的分隔符来构造这个字符串
var colors = ["red","blue","green",];
console.log(colors.join(","));//"red,blue,green"
console.log(colors.join("||"));//"red||blue||green"
这里用的是toString()方式输出
栈方法：是一种可以限制插入和删除的数据结构(后进先出)，栈的方法走插入和移除只发生在一个位置——栈的顶部
push()和pop()
push():方法可以接收任意数量的参数，把他们逐个添加到数组的末尾，并返回修改后数组的长度;
pop():方法则从末尾移除最后一项(不管怎么样就是最后一项),减少数组的length，返回移除的值;
var colors = ["red","green"]
var cd = colors.push("brown");//返回数值最新长度
console.log(colors[colors.length-1]);//brown
console.log(colors[cd-1]);//brown 这里说明了push()返回的是数值的长度
var move = colors.pop();//返回移除的值
console.log(move);//brown
队列方法(先进先出):
shift(),他能够移除数值中的第一个项，同时将数组长度减1,返回移除的第一项
var colors = new Array();
var count = colors.push("red","green");//返回修改后的长度
console.log(count);//2
count = colors.push("black");
var item = colors.shift();//返回移除的第一项
console.log(item);//"red"
外加
unshift()可以在数组前端添加任意个项,并返回数组的长度
总结：
添加的都是返回添加后的数组长度;移除的都是返回移除的项
重新排序的方法
1.reverse()方法会反转数值项的顺序;
var values = [1,2,3,4,5];
console.log(values.reverse());//(5) [5, 4, 3, 2, 1]
2.sort()方法按升序排列数组项-即最小的在最前面会调用toString()转型的方法，然后比较得到的字符串，
以确定如何排序
var values = [2,3,14,141,5];
console.log(values.sort());//返回升序[14, 141, 2, 3, 5]
但sort()可以添加参数：一个比较函数compare();//具体怎么用还没搞明白
function compare(value1 , value2){
if(value1 < value2){
return -1;
} else if(value1 > value2){
return 1;
} else{
return 0;
}
}
var value = [8,0,1,5,10];
value.sort(compare); //其实就是要移动是时候给sort函数返回一个为正的参数值,的这样一个机理
console.log(value);//[0, 1, 5, 8, 10]
reverse()和sort()返回的都是经过了排序后的数组
数组的操作方法
1.concat():返回基于当前数组所复制的一个新数组，当方法有参数的时候是向新数组的某位添加数组项，而push()是返回原数组添加后的长度,因为实际他就是在复制一个数值的同时,判断他是否要在末尾添加一些项
var values = [1,2,3,4,5];
console.log(values.push("1213",12,"zqx"));//8
var values = [1,2,3,4,5];
console.log(values.concat("1213",12,"zqx"));
//0: 1
//1: 2
//2: 3
//3: 4
//4: 5
//5: "1213"
//6: 12
//7: "zqx"
//length: 8
2.slice():他能基于当前数组中的一个或多个来创建一个新的数值,并不影响原来的数组
参数是数值在数组中的位置,该方法返回包含起始项,但不包含结尾项的新数组
0 1 2 3 4
var colors = ["red","green","blue","yellow","purple"];
var colors3 = colors.slice(1,4);
console.log(colors3);//["green", "blue", "yellow"]有第1项没第4项
3.splice():他可以向数组中部插入项，但使用这种方式有3中情况,
返回的值是删除的项的数组,如果没有删除项,那么返回一个空数值,所以对实际的数组有影响
参数3个：第一要删除的插入的(数组项所在的)位置，第二要删除的项数，第三和要查入的项
删除：splice(0,1)，从第一项开始删除一项
var colors = ["red","green","blue"]
console.log(colors.splice(0,1));//["red"]
console.log(colors);// ["green", "blue"]
插入：splice(0,0,"red","blue"),从第一项开始删除零项，在第一项后面插入"red","blue";
var colors = ["red","green","blue"]
console.log(colors.splice(0,0,"reg","red"));//[]因为没有删除项
console.log(colors);//["reg", "red", "red", "green", "blue"]
替换：splice(0,2,"red","blue")，从第一项开始删除二项，在第一项后面插入"red","blue"，相当于替换;
var colors = ["red","green","blue"]
console.log(colors.splice(0,2,"reg","red"));// ["red", "green"]
console.log(colors);//["reg", "red", "blue"]
数组的位置方法
indexOf()和lastIndexOf()都接收俩个参数：要查找的项和表示查找位置的索引，索引代表从什么位置开始找
返回项所在数组中的位置，当搜索不到的时候返回-1
删除：splice(0,1)，从第一项开始删除一项
var colors = ["red","green","blue"]
console.log(colors.splice(0,1));//["red"]
console.log(colors);// ["green", "blue"]
插入：splice(0,0,"red","blue"),从第一项开始删除零项，在第一项后面插入"red","blue";
var colors = ["red","green","blue"]
console.log(colors.splice(0,0,"reg","red"));//[]因为没有删除项
console.log(colors);//["reg", "red", "red", "green", "blue"]
替换：splice(0,2,"red","blue")，从第一项开始删除二项，在第一项后面插入"red","blue"，相当于替换;
var colors = ["red","green","blue"]
console.log(colors.splice(0,2,"reg","red"));// ["red", "green"]
console.log(colors);//["reg", "red", "blue"]
关键（引用类型的位置值的比较）
：在比较第一个参数的时候与数值中的每一项的时候，会使用全等符号
关于引用类型的比较,查找，因为为全等所以,不但值要相同，而且值所在的位置也要相同
var person = { name: "Nicholas" };
var people = [{ name: "Nicholas" }];
var morePeople = [person];
console.log(people.indexOf(person))//-1找不到返回-1
console.log(morePeople.indexOf(person))//0，第0位
为什么会找不到返回-1呢？因为值一样但不是同一个对象，相当于person的值在另一个对象的里面，但people对象中有一个一样的值，但二者不相同对象不一样所以===比较的时候就会返回flast；
补充ES6 2019.4.16
扩展运算符
扩展运算符用三个点(...)表示,从字面上理解，它的功能就是把数组扩展开来,具体形式如下：
let arr = [1, 2, 3];
console.log(...arr); //打印结果 1 2 3
//等价于
console.log(1,2,3);
本质：他可以吧数组以join(",")的形式分开
作用1：可以用这个扩展运算符把数组里面的元素展开，分别传给函数的形参
let arr = [4, 5, 6];
function Fn(a, b, c) {
console.log(a);
console.log(b);
console.log(c);
return a + b + c;
}
result = Fn(...arr);
console.log(result);
其实这个也没必要我们可以用解析赋值，其实在这个情况下会更简单
扩展运算符可以和正常参数结合起来使用，非常的灵活（根据K值一一对应）
let arr = [4, 5, 6];
function Fn(a, b, c, d, e, f) {
console.log(a);
console.log(b);
console.log(c);
console.log(d, e, f)
}
Fn(1,...arr, 2, 3); //注意一一对应关系：1->a;...arr->b,c,d;2->e; 3->f
但是需要注意的是：在解析赋值的时候扩展运算符只可以放最后
作用2：复制数组
如果把一个数组直接赋值给另一个数组，那么会产生引用，相互影响，在es5中，只能通过变通的方式复制数组，但在es6中，我们可以通过扩展运算符来实现数组复制
//直接赋值 产生引用
let arr = [1, 2, 3];
let arr2 = arr;
arr2.push(4);
console.log(arr) // [1, 2, 3, 4]
//es5 中复制数组
let arr3 = arr.concat();
console.log(arr3)
//es6中复制数组
let arr4 = [...arr];
arr4.push(5);
console.log("arr4",arr4); //[1,2,3,5]
console.log("arr",arr) //[1,2,3] 和arr4并不会相互影响
作用3：合并数组
let arr = [1, 2, 3];
let arr2 = [4, 5, 6];
console.log([...arr,...arr2]) // [1, 2, 3, 4, 5, 6]
作用4：和解构赋值结合,用于生成数组，但是这里的数组必须放在最后
let [a, b, ...rest] = [1, 2, 4, 5, 6, 7]
console.log(rest); //[4, 5, 6, 7]
Array.from
本质：Array.from可以把类数组转成真正的数组
<ul>
<li>nodeing_1</li>
<li>nodeing_2</li>
<li>nodeing_3</li>
<li>nodeing_4</li>
<li>nodeing_5</li>
<li>nodeing_6</li>
</ul>
<script>
let aLi = document.getElementsByTagName('li')
for(let i in aLi){
aLi[i].style.color = "red" //执行报错
}
</script>
这里的aLi并不是真正的数组他只是包含了0，1，2....但是他还有length属性，也就是因为他有length属性所以i就会有可能等于length就会报错，也同时当我们用遍历的时候虽然他不是数组但是也可以返回length的长度，所以也说明了不是说可以返回length长度的值就说明有是一个数组
我们就可以使用.from()方法
let aLi = document.getElementsByTagName('li')
for(let i in Array.from(aLi)){
aLi[i].style.color = "red"
}
Array.of
本质：这个方法可以将一组数值转换成数组
let arr = Array.of(1, 2, 3,4)
console.log(arr) // [1,2,3,4]
题外话：不知道大家这里有没有注意到这里的Array没有new 为什么没有nwe呢？其实就是因为他其实就已经是返回了一个对象了，那个对象是会根据我们的参数返回一个数组给我们，new(工厂模式）其实效果是一样的，没有什么区别
当构造函数自己有return的时候：当构造函数中自身的retuen的是数值那么只是会结束函数执行，但是返回值还是那个定义的{}，如果自带的return是一个函数，那么返回的是那个自带的函数
但是这里我们直接用Array()不就好了吗？为什么还要of?其实这里只是为了解决一个冲突，只有在Array的参数大于2个的时候，才是返回数组的，当参数为1个的时候是返回length为多少的数组，而of就完美的解决了这个冲突
//Array的行为不统一，根据参数的不同返回的结果不一样
let arr = Array(4)
let arr2 = Array(1, 3)
let arr3 = Array(1,3,4,5);
console.log(arr, arr2, arr3) // [empty × 4] 、[1, 3]、 [1, 3, 4, 5]
let arr = Array.of(4)
let arr2 = Array.of(1, 3)
let arr3 = Array.of(1,3,4,5)
console.log(arr, arr2, arr3) // [4] [1, 3] [1, 3, 4, 5]
copyWithin
本质：将数组内部指定位置的元素复制，在替换掉指定的目标
let arr = [1, 2, 3, 4, 5]
//第一个参数为目标起始位置 第二个参数为被复制元素的开始位置，第三个参数为被复制元素的结束位置
//将下标3到4的元素 复制到下标为1的位置 原来位置的元素被覆盖
arr.copyWithin(0, 3, 4) //[4,2,3,4,5]
console.log(arr)
find和findIndex
find方法用来查找数组中符合条件的第一个元素，接收一个回调函数，返回那个值
findIndex的用法和find类似，返回的是索引位置，而不是具体的值
let arr = [1, 2, 3, 4, 5]
let num = arr.find(function (v,i,a) {
return v > 3
})
console.log(num) //4
let arr = [1, 2, 3, 4, 5]
let num = arr.findIndex(function (v,i,a) {
return v > 3
})
console.log(num) //3
fill
本质：填充吧数组中是全部项都改为fill中参数的值
let arr = [1,2,8,8,8]
arr.fill(1)
console.log("arr",arr)
.entries、keys和values
let arr = [1, 2, 3, 4, 5];
//遍历键名
for(let index of arr.keys()){
console.log(index)
}
//遍历值
for(let v of arr.values()){
console.log(v)
}
//遍历键/值对
let arr = [1, 2, 3, 4, 5];
for(let index of arr.keys()){
console.log(index)
}
解释：这个也就是for in 与 for of 的区别 这里大家打印一下就知道3种的区别了
includes
本质：判断是否含有某一个值,返回boolear
区别：比indexOf好，至少再语义化上
let arr = [1, 2, 3, 4, 5];
console.log(arr.includes(7)) //false
console.log(arr.includes(1)) //true
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
