数组常用api

JavaScript常用api

Array

语法
[element0, element1, ..., elementN ]

new Array ( element0 , element1 [ , ... [ , elementN ] ] )

new Array ( arrayLength )

属性
Array.length Array构造函数的length属性，其值为1（注意该属性为静态属性，不是数组实例的length属性）
Array.prototype 数组的原型对象，可以为所有数组对象添加属性
方法
Array.isArray() 判断某个变量是否为一个数组对象
Array.from() 从类数组对象或者可迭代对象中创建一个新的数组实例
Array.of() 根据一组参数来创建新的数组实例，支持任意的参数数量和类型

数组实例

属性
Array.prototype.constructor
所有的数组实例都继承了这个属性，它的值就是Array，表明了所有的数组都是由Array构造出来的

Array.prototype.length
因为 Array.prototype 也是个数组，所以它也有 length 属性，这个值为 0，因为它是个空数组

方法

Array.prototype.push(value,...) 添加元素到数组的末尾，并返回添加新元素后的数组长度

//后插（返回数组长度，会改变原数组）
var arr1 = [1,2,3];
var arr2 = arr1.push(9,10,11);
console.log(arr2);	//6(返回数组长度)
console.log(arr1);	//改变原数组[1,2,3,9,10,11]

Array.prototype.pop() 删除数组末尾的元素，并返回该元素

//后删（返回被删除的元素,会改变原数组）
var arr1 = [1,2,3,4,5];
var arr2 = arr1.pop();
console.log(arr2);	//5(返回被删除的元素)
console.log(arr1);	//[1,2,3,4]

Array.prototype.unshift(value) 添加元素到数组的头部，并返回添加新元素后的数组长度

//前插（返回数组长度, 会改变原数组）
var arr1 = [1,2,3,4,5];
var arr2= arr1.unshift(0,'a','b');
console.log(arr2);	//8(返回新数组长度)
console.log(arr1);	//[0, 'a', 'b', 1, 2, 3, 4, 5]

Array.prototype.shift() 删除数组最前面（头部）的元素，并返回该元素（shift：改变、去掉、转移）

//前删--返回被删除的元素,会改变原数组
var arr1 = [1,2,3,4,5];
var arr2= arr1.shift();
console.log(arr2);    //1(返回被删除的元素)
console.log(arr1);    //[2,3,4,5]

Array.prototype.slice(start_index,upto_index)
抽取原数组的一部分，返回一个新数组，原数组不变。 （slice：切片、切下）

第一个参数为其实位置（从0开始），第二个参数为终止为止（但该位置的元素本身不包含在内）。若省略第二个参数，则一直返回到原数组的最后一个元素。负数表示倒数第几个元素

截取数组

var arr=[1,2,3];
var newArr=arr.slice(0,2);
console.log(newArr); //[1,2]
console.log(arr); //[1,2,3]

Array.prototype.splice(index,remove_count, addElement1,addElement2,...)
在任意的位置给数组删除或添加任意个元素，返回值是被删除的元素。（splice：胶接、粘接、剪接）

第一个参数是删除的起始位置，第二个参数是被删除元素的个数，若后面还有更多的参数，它们是要在被删除的位置添加的新数组元素

增删改查四合一

//删除：需指定2个参数，要删除的第一项位置和要删除的项数
var colors = ['red','green','blue'];
var removed = colors.splice(0,1);//位置下标，删除个数
console.log(colors);      //green,blue
console.log(removed);     //red//返回被删除数据的数组

//插入：需提供3个参数，起始位置、0（要删除的项数）和要插入的项，如要插入多个项
// ，再传入第四，五...
var removed = colors.splice(1,0,'black');//位置下标，删除个数，插入数据
console.log(colors);     //green,black,blue
console.log(removed);    // 返回空数组

//替换：需指定3个参数，起始位置、要删除的项数和要插入的任意数量的项
var removed = colors.splice(0,2,'yellow','white');//位置下标，删除个数，插入数据
console.log(colors);     //yellow,white,blue
console.log(removed);    //red,green

Array.prototype.indexOf(item，index)
返回数组中第一个与指定值相等的元素的索引，如果找不到则返回 -1。第二个参数表示搜索的开始位置

let arr = [1,2,3,4,5,6,1,2,3,4,5,6]
let result = arr.indexOf(3)
console.log(result) // 2

Array.prototype.lastIndexOf()
返回数组中最后一个（从右边数第一个）与指定值相等的元素的索引，如果找不到这样的元素，则返回 -1

let arr = [1,2,3,4,5,6,1,2,3,4,5,6]
let result = arr.indexOf(3)
console.log(result) // 8

Array.prototype.includes()
判断当前数组是否包含某指定的值，如果是返回true，否则返回false

Array.prototype.concat(value,...)
合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组（浅拷贝）

let arr = [1,2,3]
let arr2 = [4,5,6] 
let newArr = arr.concat(arr2)
console.log(newArr) // [1, 2, 3, 4, 5, 6]

Array.prototype.join(separator)
返回以参数作为分隔符，将所有数组元素组成的一个字符串；若不提供参数，则默认用逗号分隔

var arr1 = [1,2,3];
console.log(arr1.join("到"));	//'1到2到3'--以'到'对arr1数组的元素进行拼接
 
var arr2 = ['a','b','c'];
console.log(arr2.join(''));    //'abc'--以空字符串为拼接符对arr2数组进行拼接

Array.prototype.sort([compareFunction])
对数组成员进行排序，默认无参是按照字典顺序（Unicode）排序。排序后，原数组将被改变。

若传入一个函数作为参数，表示按照自定义方法进行排序。该函数本身接受两个参数，表示进行比较的两个元素。如果返回值大于0，表示第一个元素排在第二个元素后面；其他情况下，都是第一个元素排在第二个元素前面。

let arr = [1,6,4,3,5,2] 
arr.sort();
console.log(arr) // [1, 2, 3, 4, 5, 6]

var arr= [11,99,33,4,4,35,3,46,9];
console.log(arr.sort((a,b)=>a-b);    //升序[3, 4, 4, 9, 11, 33, 35, 46, 99]
console.log(arr.sort((a,b)=>b-a);    //降序[99, 46, 35, 33, 11, 9, 4, 4, 3]

Array.prototype.reverse()
颠倒数组中元素的排列顺序，即原先的第一个变为最后一个，原先的最后一个变为第一个

var arr = [1,2,3,4,5,'a'];
console.log(arr.reverse());    //['a',5,4,3,2,1]

Array.prototype.toLocaleString()
返回一个由所有数组元素组合而成的本地化后的字符串。遮蔽了原型链上的 Object.prototype.toLocaleString() 方法
Array.prototype.toString()
返回一个由所有数组元素组合而成的字符串。遮蔽了原型链上的Object.prototype.toString()方法
迭代方法：
Array.prototype.forEach(function(item, index, array){...})
遍历数组的所有成员。参数是一个函数，它接受三个参数（当前位置的值、当前位置的编号和整个数组）

let arr = [1, 2, 3, 4, 5, 6];
arr.forEach((item) => {
    console.log(item) // 依次输出1到6
});

Array.prototype.map(function(item, index, array){...})
默认（无参）对数组的所有成员依次调用一个函数，根据函数结果返回一个新数组

重新包装数组

var arr = [1,2,3,5]
var arr2= arr.map(function(item,index){
    // 将元素重新组装并返回
    return '<span>'+item+'</span>'
})
console.log(arr);//[1,2,3,5]
console.log(arr2);//["<span>1</span>", "<span>2</span>", "<span>3</span>", "<span>5</span>"]

map方法接受一个函数作为参数。该函数有三个参数，分别是当前成员、当前位置和数组本身

Array.prototype.every()
如果数组中的每个元素都满足测试函数，则返回 true，否则返回 false

var arr = [1,2,3]
var result = arr.every(function (item, index) {
    // 用来判断所有的数组元素，都满足一个条件
    if (item < 4) {
        return true
    }
})
console.log(result);//true

Array.prototype.some()
如果数组中至少有一个元素满足测试函数，则返回 true，否则返回 false

var arr = [1,2,3]
var result = arr.some(function (item, index) {
    // 用来判断所有的数组元素，只要有一个满足条件即可
    if (item < 2) {
        return true
    }
})
console.log(result);//true

Array.prototype.filter()
将所有在过滤函数中返回 true 的数组元素放进一个新数组中并返回

过滤数组

var arr = [1,2,3,5]
var arr2= arr.filter(function(item,index){
    // 通过某个条件过滤数组
    if(item>2){
      return true
   }
})

console.log(arr2);//[3, 5]

//数组去重
var myArr = [1,3,4,5,6,3,7,4];
console.log(myArr.filter((value,index,arr)=>arr.indexOf(value)===index));
//[ 1, 3, 4, 5, 6, 7 ]

Array.prototype.reduce()
从左到右为每个数组元素执行一次回调函数，并把上次回调函数的返回值放在一个暂存器中传给下次回调函数，并返回最后一次回调函数的返回值

let arr = [1, 2, 3, 4, 5, 6];
let result = arr.reduce((sum, item) => sum+=item,0);
console.log(arr) // [1, 2, 3, 4, 5, 6]
console.log(result) // 21

Array.prototype.reduceRight()
从右到左为每个数组元素执行一次回调函数，并把上次回调函数的返回值放在一个暂存器中传给下次回调函数，并返回最后一次回调函数的返回值

Array.prototype.find()
找到第一个满足测试函数的元素并返回那个元素的值，如果找不到，则返回 undefined

const myArr=[1,2,3,4,5,6];
var v=myArr.find(value=>value>4);
console.log(v);// 5

const myArr=[1,2,3,4,5,6];
var v=myArr.find(value=>value>40);
console.log(v);// undefined

//value：当前的数组元素。index：当前索引值。arr：被查找的数组。
const myArr=[1,2,3,4,5,6];
var v=myArr.find((value,index,arr)=>{
    return index==4
});
console.log(v);// 5

Array.prototype.findIndex()
找到第一个满足测试函数的元素并返回那个元素的索引，如果找不到，则返回 -1

const bookArr=[
    {
        id:1,
        bookName:"三国演义"
    },
    {
        id:2,
        bookName:"水浒传"
    },
    {
        id:3,
        bookName:"红楼梦"
    },
    {
        id:4,
        bookName:"西游记"
    }
];
var i=bookArr.findIndex((value)=>value.id==4);
console.log(i);// 3
var i2=bookArr.findIndex((value)=>value.id==100);
console.log(i2);// -1

Array.prototype.keys()
返回一个数组迭代器对象，该迭代器会包含所有数组元素的键

Array.prototype.values()
返回一个数组迭代器对象，该迭代器会包含所有数组元素的值

Array.prototype.entries()
返回一个数组迭代器对象，该迭代器会包含所有数组元素的键值对

持续更新中......