js数组的常见属性和方法

属性

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
  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值