关于前端:7种Js-Array数组ES5ES6常用方法

1、栈办法（先进后出）

push()：在数组的最初一项后追加值（参数：能够为多个值或数组）

返回：数组的长度，扭转了原数组

var a=[1,2,3]
a.push(9);  // 返回数组的长度 4，扭转了原数组
console.log(a) //[1,2,3,9]

pop()：删除数组的最初一项（无参数）

返回：被删除的值，扭转了原数组

var a=[1,2,3,4];
a.pop()   // 返回删除值 4，扭转了原数组
console.log(a)  // [1,2,3]

2、队列办法（先进先出）

unshift()：在数组最前一项插入值（参数：能够为多个值或数组）

返回：数组的长度，插入的值为数组，变为子数组，扭转了原数组

var a=[1,2,3]; 
a.unshift(4);  // 返回数组的长度 4，扭转了原数组 
console.log(a);  //[4,1,2,3]

shift()：删除数组的最前一项（无参数）

返回：删除的值，扭转了原数组

var a=[1,2,3,4];
a.shift()  // 返回被删除的值 1，扭转了原数组
console.log(a)  //[2,3,4]

3、操作方法

slice(start,end)：返回从原数组中 start 下标到 end 下标之间的项组成的新数组（参数：[start 必选 end 可选)，只有一个参数时默认下标 end 为最初一项）

返回：蕴含从下标 start（包含该元素）到 下标 end（不包含该元素）的一个新数组，原数组不变（相似复制）

var a=[1,2,3,4,5];
a.slice(2,4) // 返回 [3,4]，原数组不变
a.slice(0) // 返回 [1,2,3,4,5]，原数组不变
a.slice(3) // 返回 [4,5]，原数组不变
console.log(a)  // [1,2,3,4,5]

splice(start,num,ele1,ele2…) 很弱小的一个办法，start 指 从下标 start 删除（包含 start 对应的元素），必选；num 指 删除的个数，必选；ele1,ele2… 代表插入的值，可选

返回：删除的值，扭转了原数组（相似剪切）

var a=[1,2,3,4,5];
a.splice(1,2,"我是","插入的值")   // 返回删除的值 2,3，扭转了原数组
console.log(a)  //  [1,"我是"，"插入的值",4,5]

concat()：数组和数组的粘结成新的数组（参数：能够为多个值或数组）

返回：新的数组，原数组不变

var a=[1,2,3,4];
var b=[5,6,7,8];
var c=a.concat(b); // 返回 [1,2,3,4,5,6,7,8]，原数组不变
console.log(c); // [1,2,3,4,5,6,7,8]

4、排序办法

reverse()：将数组反序

返回：新的反序数组，也扭转了原数组

var a = [1,2,3,4,5]; 
var b = a.reverse(); //a：[5,4,3,2,1] b：[5,4,3,2,1]，扭转了原数组 

sort()：按指定的参数对数组进行排序（参数：可选，函数）默认依照 ASCII 表排序，如果想依照其余规范进行排序，就须要提供比拟函数，该函数要比拟两个值，而后返回一个用于阐明这两个值的绝对程序的数字。比拟函数应该具备两个参数 a 和 b，其返回值如下：

• 若 a 小于 b，在排序后的数组中 a 应该呈现在 b 之前，则返回一个小于 0 的值。
• 若 a 等于 b，则返回 0。
• 若 a 大于 b，则返回一个大于 0 的值。

返回：排序后的数组，扭转了原数组

var a=[1,2,3,12,13];
a.sort()  // 返回 [1,12,13,2,3]
// 如果依照失常逻辑排序：a.sort(function(a,b){return a-b;})    //[1,2,3,12,13]

5、拼接办法

join():  扭转数组中拼接的符号，并转化为字符串（参数：” 拼接符号 ”）

返回：拼接而成的字符串，原数组不变

var a=[1,2,"字符串",false,undefined,null];
b=a.join("++");  // 返回 1++2++ 字符串 ++false++++ ; 原数组不变
console.log(b);   //undefined null 主动过滤掉了 

6、迭代（查找、遍历）办法

（1）查找办法：

indexOf(item,start)：该办法搜寻指定元素值地位，并返回下标。

参数：item 是要查找的值，start 是指你要从哪里开始找（该参数可选）。ps:start 是能够取负值的，举个栗子 indexOf(x,-5) 示意从倒数第 6 个开始（因为倒数第一个是 0 嘛），始终找到正序的第 0 个，

返回：如果屡次呈现，则返回第一次呈现的下标（其实找到了就不会接着往后找了）；如果没呈现，返回 -1。

var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.indexOf("Apple"); // 返回 0，原数组不变
console.log(a); //0

lastIndexOf(item,start)：与下面办法用法一样，不同的中央是，他是逆行，是从结尾开始找的。start 也能指定负值，如果 start 取 -5，则表明从下标为 5 的中央开始，始终往前找。

var fruits = ["Apple", "Orange", "Apple", "Mango"];
var a = fruits.lastIndexOf("Apple");// 返回 2，原数组不变
console.log(a);//2

find()：ES6 新增，查找通过测试（自定义函数内判断，通常配合 ES6 箭头函数）的数组的第一个元素的值，参数：（自定义函数：函数的参数：（我的项目值（必选），我的项目索引，数组自身））

返回：查找到的第一个值，，原数组不变

var numbers = [4, 9, 16, 25, 29];
var first = numbers.find(myFunction); // 返回 25，原数组不变
function myFunction(value, index, array) {return value > 18;}

findIndex()：与下面办法用法一样，不同的中央是查找的是第一个下标

返回：查找到的第一个值的下标，查找不到则返回 -1，原数组不变

var numbers = [4, 9, 16, 25, 29];
var first = numbers.findIndex(myFunction);// 返回 3，原数组不变
function myFunction(value, index, array) {return value > 18;}

（2）遍历办法：

以下五种办法都接管两个参数：要在每一项上运行的函数和（可选的）运行该函数的作用域对象——影响 this 的值

传入这些办法中的函数会接管三个参数：数组项的值、该项在数组中的下标和数组对象自身。依据应用的办法不同，这个函数执行后的返回值可能会也可能不会影响办法的返回值。以下是这五个迭代办法的作用。

every(function(item,index,array){})：对数组中的每一项运行给定函数，如果该函数对每一项都返回 true，则返回 true，原数组不变

var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var everyResult = numbers.every(function(item, index, array){return (item > 3);
})
console.log(everyResult); //false

some(function(item,index,array){})：对数组的每一项运行给定函数，如果该函数对任一项返回 true，则返回 true，原数组不变

var someResult = numbers.some(function(item, index, array) {return (item > 3);
})
console.log(someResult); //true

filter(function(item,index,array){})：对数组中的每一项运行给定函数，返回该函数调用后果值为 true 的项组成新的数组，原数组不变

var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var filterResult = numbers.filter(function(item, index, array) {return (item > 3);
})
console.log(filterResult); //[4, 5, 4]，原数组不变 

map(function(item,index,array){})：对数组中的每一项运行给定函数，返回每次该函数调用的后果组成的数组，原数组不变

var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var mapResult = numbers.map(function(item, index, array) {return item * 2;})
console.log(mapResult); //[2, 4, 6, 8, 10, 8, 6, 4, 2]

forEach(function(item,index,array){})：对数组中的每一项运行给定的函数，该办法没有返回值，实质上与应用 for 循环迭代数组一样，原数组不变

var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var copy = [];var Result = numbers.forEach(function(item, index, array) {copy.push(item - 1) // 执行某些操作
})
console.log(numbers); //[1, 2, 3, 4, 5, 4, 3, 2, 1] 原数组不变
console.log(copy); //[0, 1, 2, 3, 4, 3, 2, 1, 0] 
console.log(Result); //undefined 无返回值 

reduce(function(prev,item,index,array){},init)：对数组中的每一项运行给定函数，返回每次该函数调用的后果组成的数组，原数组不变

prev：必须，初始值, 或者计算完结后的返回值；init：可选，传递给函数的初始值，须要当时赋值

var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
var init=10;
var Result = numbers.reduce(function(prev, item, index, array) {return prev + item},init)
console.log(numbers); //[1, 2, 3, 4, 5, 4, 3, 2, 1] 原数组不变
console.log(Result); // 返回 35

7、转换方法（Array、Boolean、Date、Number 等对象通用办法）

toString()：扭转数组中拼接的符号，并转化为字符串（参数：” 拼接符号 ”）

返回：拼接而成的字符串，原数组不变

var a = [1, 2, 3, 4, 5];
var b = a.toString();// 返回 1,2,3,4,5 ; 原数组不变
console.log(a); //[1,2,3,4,5]
console.log(b); //1,2,3,4,5

toLocaleString()：扭转数组中拼接的符号，并转化为字符串（参数：” 拼接符号 ”）

返回：拼接而成的字符串，原数组不变

var a = [1, 2, 3, 4, 5];
var b = a.toLocaleString();// 返回 1,2,3,4,5 ; 原数组不变
console.log(a); //[1,2,3,4,5]
console.log(b); //1,2,3,4,5

valueOf()：通常由 JavaScript 在后盾主动进行调用，而不是显式地处于代码中