js数组Array原型方法分析,可以复制过去跑一下

// Array.from(),可传3个值，第一个为可迭代对象，第二个为map函数，第三个为执行第二个map函数的this指向
// var a = [1, 2, 3, 4, 5, 6, 7, { name: 3 }]
// function from(a) {
//     var args = Array.from(a, function (item, index) {
//         // return item  //浅拷贝
//         return JSON.parse(JSON.stringify(item))//深拷贝
//     }, window)
//     return args
// }
// console.log(from(a));
// var a1 = from(a)
// a1[7].name = 444
// console.log(a1);
// console.log(from(a));

// Array.isArray() 传入一个参数，看是否是数组
var b = [1, 2, 3, 4, 5, 6, 7, { name: 3 }]
console.log(Array.isArray(b));

//Array.of()创建一个长度为多少的数组，并把它们作为传入的参数，第一个为长度及第一个参数
var b1 = Array.of(10, 20, [...b])
console.log(b1);

//Array.prototype.concat() 合并数组
var a2 = [1, 2]
var b2 = [4, 5]
var c = Array.prototype.concat(a2, b2)
console.log(c);
var c1 = a2.concat(b2) //不会影响原数组
console.log(c1);

//Array.prototype.copyWithin() 使用截取一部分元素 去替换数组中的其他字符串  获取第二个参数到第三个参数的元素从第一个元素开始替换
var a3 = [1, 2, 3, 4, 5, 6]
var c2 = a3.copyWithin(0, a3.length - 3, a3.length)
console.log(c2);

//Array.protptype.entries() 返回一个新的array lterator对象 该对象的为每个元素下标和值的键值对
var a4 = [1, 2, 3, 4]
var c3 = a4.entries()
for (var i = 0; i < a4.length + 1; i++) {
    var tem = c3.next(); // 每次迭代时更新next
    console.log(tem);
}

//Array.prototype.every()//测试一个数组是不是所有的元素都可以满足条件 返回boolean
var a5 = [1, 2, 3, 4]
console.log(a5.every((item, index) => {
    return item < 5
}));
console.log(a5.every((item, index) => {
    return item > 5
}));

//Array.prototype.fill()//用一个固定的值填充起始索引之间的所有元素，不包括终止索引
var a6 = new Array(5);
var c6 = a6.fill(16, 1, a6.length)
a6[0] = 10
console.log(a6);

//Array.protopy.filter()返回满足条件的数组
var a7 = [1, 2, 3, 4]
var c7 = a7.filter((item) => {
    return item > 2
})
console.log(c7);

//Array.prototype.find() 返回满足条件的第一个元素不是数组
var a8 = [0, 1, 20, 4, 3, 60]
var c8 = a8.find((item, index) => {
    return item > index * 2
})
console.log(c8);

//Array.prototype.findindex() 返回满足条件的第一个元素的下标
var a9 = [0, 1, 20, 4, 3, 60]
var c9 = a9.findIndex((item, index) => {
    return item > index * 2
})
console.log(c9);

//Array.prototype.flat()数组扁平化方法 不传值是为1，也可以传Infinity无穷大
var a10 = [0, [1, [20], 4], 3, 60]
var c10 = a10.flat()
var c11 = a10.flat(Infinity)
console.log(c10);
console.log(c11);

//Array.prototype.flatMap() flat和map的结合 不过flat值不可设置。只能为1
var a12 = [1, [2]]
var c12 = a12.flatMap((item, index) => {
    return [index, item]
})
console.log(c12);

//Array.ptototype.forEach() 遍历数组 没有返回值
var a13 = [1, [2], 3]
var c13 = a13.forEach((item, index) => {
    console.log(item * 2);
})

//Array,prototype.includes()判断数组中有没有该元素 返回boolean
var a14 = [1, 2, 3]
var c14 = a14.includes(1)
var c15 = a14.includes(10)
console.log(c14);
console.log(c15);

//Array.prototype.indexof 返回数组中第一个满足条件的元素下标
var a16 = [1, 2, 3, 4, 1]
var c16 = a16.indexOf(1)
console.log(c16);

//Array.prototype.lastindexof 返回数组中最后一个满足条件的元素下标
var a16 = [1, 2, 3, 4, 1]
var c16 = a16.lastIndexOf(1)
console.log(c16);

//Array.prototype.join() 把数组所有元素都转换成一个字符串 填值可以用来替换逗号
var a17 = [1, 2, 3, 4]
var c17 = a17.join()
var c18 = a17.join('-')
var c19 = c18.split('-')
console.log(c17);
console.log(c18);
console.log(c19);

//Array.prototype.keys() 返回一个包含数组中每个索引的Array lterator对象 不过只能遍历下标
var a20 = [1, 2, 3, 4]
var c20 = [...a20.keys()]
var c21 = Object.keys(a20)
console.log(c21);
console.log(c20);

//Array.priototype.map() 返回一个新数组并可以对值进行处理，不会影响到原数组,如果原数组没有用了也可以给原数组赋值
var a22 = [1, 2, 3, 4, 5]
a22 = a22.map((item) => {
    return item * 2
})
console.log(a22);

//Array.prototype.push/pop/unshift/shift() 分别为从数组尾部添加、从数组尾部删除、从数组头部添加、从数组头部删除元
var a23 = [1, 2, 3, 4, 5]
a23.push(2)
console.log(a23);
a23.pop()
console.log(a23);
a23.unshift(6)
console.log(a23);
a23.shift()
console.log(a23);

//Array.prototype.reduce()
//pre代表上一次的返回值，如果有初始值第一次为初始值init
//cur代表正在操作的元素，如果没有初始值则为数组第二个元素
//index 下标，arr旧数组，init，初始值
var a24 = [1,2,3,4,1,5,5]
let c24 = a24.reduce((pre,cur)=>{
    if(pre.includes(cur)){
        // console.log(cur+"重复了");
        pre
    }else{
        pre.push(cur)
    }
    return pre
},[])
console.log(c24);

//Array.prototype.reduceRight()
//pre代表上一次的返回值，如果有初始值第一次为初始值init
//cur代表正在操作的元素，如果没有初始值则为数组第二个元素
//index 下标，arr旧数组，init，初始值
var a25 = [1,2,3,4,1,5,5]
let c25 = a25.reduceRight((pre,cur)=>{
    if(pre.includes(cur)){
        // console.log(cur+"重复了");
        pre
    }else{
        pre.push(cur)
    }
    return pre
},[])
console.log(c25);

//Array.prototype.reverse() 反转数组
var a26=["d","a","f"]
var c26=a26.reverse()
console.log(c26);

//Array.prototype.slice() 从数组中提取若干个元素,不包含结束
var a27=[0,1,2,3]
var c27=a27.slice(1,3)
console.log(c27);

//Array。prototype.some() 检查数组中是否最少有一个满足函数中的条件，返回boolean值
var a28=[0,1,2,3]
var c28=a28.some((item)=>{
   return item>4
})
var c29=a28.some((item)=>{
    return item>2
 })
 console.log(c28);
 console.log(c29);

 //Array.prototype.sort() 通过返回值为正数或负数来判断哪个元素在前哪个元素在后，排序
 var a29=[0,1,3 , 3,2]
var c29=a29.sort((num,num1)=>{
   return num-num1
})
 console.log(c29);

 //Array.prototype.splice() 从数组中删除或添加若干个元素
 //第一个元素为操作起点
 //第二个元素为删除多少个元素
//之后的则为添加元素
var a30=[0,1,3,3,2]
a30.splice(1,3)
console.log(a30);
a30.splice(1,0,2,3)
console.log(a30);

//Array.prototype.toLocaleString/toString() 把数组中的元素变成字符串表示出来，用逗号分隔
var a31=[0,1,3,3,2]
var c31=a31.toString()
var c32=a31.toLocaleString()
console.log(c31);
console.log(c32);

// Array.prototype.values()返回一个Array iterator对象 只能遍历值
var a33=["a","b"]
var c33=[...a33.values()]
console.log(c33);