JS组数操作方法（包含ES6）

因为数组操作的方法有很多，我们在实际项目中又会经常使用,本篇文章一次性整理常用的数组操作方法 ( 包含 ES6 的 map、forEach、every、some、filter、find、from、of…等 )，熟悉了这些数组的操作方法，编起代码来也就会更加干净利落哟。
Array数组的方法：

Mutator方法————"突变方法"会改变数组自身的值；Accessor方法————"访问方法"不会改变数组自身的值；Iteration方法————"遍历的方法" Establish方法————"创建新方法"

一、Mutator方法（会改变数组自身的值）
1、[ ].push
作用：将一个或多个元素添加到数组的末尾，
传参：（单个或多个数组元素）；
返回值：新数组的长度；

 //标准用法arr.push(el1, el2 ……elN)；//合并两个数组[].push.apply(arr1, arr2)

let a = [1,2,3,4,5,6,7,8];
a.push(9, 10);
console.log(a); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2、[].pop()，
作用：删除最后一个元素，
传参：无；
返回值：删除的元素。

//标准用法
let a = [1 ,2 ,3 ];
a.pop();//3

let a = [1,2,3,4,5,6,7,8];
a.pop();
console.log(a); // [1, 2, 3, 4, 5, 6, 7]

3、[ ].unshift
作用：将一个或多个元素添加到数组的开头，
传参：（单个或多个数组元素）；
返回值：新数组的长度；

 //标准用法arr.unshift(el1, el2 ……elN)；

let a = [1,2,3,4,5,6,7,8];
a.unshift(100,200,300);
console.log(a); // [100, 200, 300, 1, 2, 3, 4, 5, 6, 7, 8]

4、[].shift()，
作用：删除第一个元素，
传参：无；
返回值：删除的元素。

//标准用法
let a = [1 ,2 ,3 ];
a.shift();//1

let a = [1,2,3,4,5,6,7,8];
a.shift();
console.log(a); // [2, 3, 4, 5, 6, 7, 8]

5、[].reverse()，
作用：数组元素颠倒位置，
传参：无；
返回值：颠倒后的数组。

//标准用法
arr.reverse()

let a = [1,2,3,4,5,6,7,8];
a.reverse();
console.log(a); // [8, 7, 6, 5, 4, 3, 2, 1]

6、[].splice()，
作用：移除或新增数列的元素，
传参：（索引（要移除或要添加的索引( 必填)），删除个数【要移除的长度( 选填，若不填则从第一个参数序号位置开始，后方的所有元素都会被移除，若设定为0则不会有元素被移除)】，要添加的元素【要替换的内容( 选填 )】）；
返回值：被删除的元素组成的一个数组。

//标准用法
array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

let a = [1,2,3,4,5,6,7,8];
a.splice(5,1);
console.log(a);
// [1, 2, 3, 4, 5, 7, 8] ( 6 被移除了 )

添加第三个参数就能够添加或替换元素。

let a = [1,2,3,4,5,6,7,8];
a.splice(5,1,100);
console.log(a);
// [1, 2, 3, 4, 5, 100, 7, 8] ( 6 被移除，100加到第5个位置 )
let b = [1,2,3,4,5,6,7,8];
b.splice(5,3,100,200,300);
console.log(b);
// [1, 2, 3, 4, 5, 100, 200, 300] ( 6,7,8 被移除，100,200,300 加到第 5,6,7 个位置 )
let c = [1,2,3,4,5,6,7,8];
c.splice(5,0,100);
console.log(c);
// [1, 2, 3, 4, 5, 100, 6, 7, 8] ( 沒有元素被移除，100 加到第 5 个位置 )

7、[].fill()，
作用：用一个固定值填充一个数组中从起始索引到终止索引内的全部元素，
传参：（准备要置换的内容(必填)，从什么位置开始置换(选填，不设定就全部置换) ，停止置换的元素的前一个位置(选填，预设等于数组长度)。）；
返回值：修改后的数组。

//标准用法
arr.fill(value)
arr.fill(value, start)
arr.fill(value, start, end)


//例子
[1, 2, 3].fill(4)            // [4, 4, 4]
[1, 2, 3].fill(4, 1)         // [1, 4, 4]
[1, 2, 3].fill(4, 1, 2)      // [1, 4, 3]

let a = [1,2,3,4,5,6,7,8];
a.fill('a');
console.log(a); // ['a','a','a','a','a','a','a','a']
let b = [1,2,3,4,5,6,7,8];
b.fill('b',3,5);
console.log(b); // [1,2,3,'b','b',6,7,8]

8、[].sort()，
作用：对数组的元素进行排序，并返回数组，（可以针对数组的元素进行排序，里头包含了一个排序用的判断函数，函数内必须包含两个参数，这两个参数分别代表数组里的第n个和第n+1 个元素，通过比较第n和第n+1个元素的大小来进行排序。）
传参：（指定排列顺序的函数【选】）；
返回值：排列后的数组。

//标准用法
arr.sort()
arr.sort(compareFunction)//例子
let numbers = [4, 2, 5, 1, 3];
numbers.sort((a, b) => {return a - b;
});// [1, 2, 3, 4, 5]

let a = [1,3,8,4,5,7,6,2];
a.sort((x,y) => y - x);
console.log(a);
// [8, 7, 6, 5, 4, 3, 2, 1]
a.sort((x,y) => x - y);
console.log(a);
// [1, 2, 3, 4, 5, 6, 7, 8]

如果不使用判断函数，默认会将元素转换成字串，并采用unicode来判断，这也会造成某些数字的排序错误，如下段示例：

let a = [1,3,8,4,5,7,6,2,9,10,11];
a.sort();
console.log(a); // [1, 10, 11, 2, 3, 4, 5, 6, 7, 8, 9]

二、Accessor方法（不会改变数组自身的值）

1、[ ].join
作用：将数组（或一个类数组对象）的所有元素，变成由指定的字符分割合并在一起组合成字符串进行呈现，若没有指定字符默认会用「逗号」合并。。
传参：（指定一个字符串来分隔数组的每个元素【选】）；
返回值：一个所有数组元素连接的字符串；

//标准用法
let a = ['Wind', 'Rain', 'Fire'];
let myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
let myVar2 = a.join(', ');  // myVar2的值变为"Wind, Rain, Fire"

let a = [1,2,3,4,5,6,7,8];
console.log(a.join()); // 1,2,3,4,5,6,7,8
console.log(a.join('')); // 12345678
console.log(a.join('@@'));
// 1@@2@@3@@4@@5@@6@@7@@8

2、[ ].concat
作用：合并两个或多个数组，如果是使用ES6语法也可以用扩展运算符…来代替。。
传参：（将数组和/或值连接成新数组【选】）；
返回值：合并后的数组；

//标准用法
let alpha = ['a', 'b', 'c'];
let numeric = [1, 2, 3];alpha.concat(numeric);
//['a', 'b', 'c', 1, 2, 3]

let a = [1,2,3,4,5];
let b = [6,7,8,9];
let c = a.concat(b);
let d = [...a, ...b];
// 使用 ...
console.log(c);
// [1,2,3,4,5,6,7,8,9]
console.log(d);
// [1,2,3,4,5,6,7,8,9]

3、[ ].slice
作用：方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组。
传参：（开始索引【选】，结束索引【选，操作时数字减1】）；
返回值：截去后的数组；

//标准用法
let fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango'];
let citrus = fruits.slice(1, 3);
console.info(citrus );     //['Orange','Lemon'] //类数组转数组
function list() {return [].slice.call(arguments)
}
let list1 = list(1, 2, 3);     //[1, 2, 3]

let a = [1,2,3,4,5,6,7,8];
let b = a.slice(2,4);
console.log(b); // [3, 4]

4、[ ].toString
作用：会把整个数组转换成字符串，
传参：（无）；
返回值：转化成的字符串；（=[].join()）

//标准用法
let monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
let myVar = monthNames.toString();     // assigns "Jan,Feb,Mar,Apr" to myVar.

let a = [1,2,3,4,5,6,7,8];
let b = a.toString();
console.log(b);
// 1,2,3,4,5,6,7,8

5、[ ].includes
作用：判断一个数组是否包含一个指定的值，如果有包含就返回true，否则返回false
传参：（两个参数，第一个参数表示要判断的值( 必填)，第二个参数表示从数组的哪个位置开始判断( 选填)。）；
返回值：true或 false；

//标准用法
let a = [1, 2, 3];
a.includes(2); // true
a.includes(4); // false

let a = [1,2,3,4,5,6,7,8];
console.log(a.includes(2));
// true
console.log(a.includes(2,2));
// false ( 在 3,4,5,6,7,8 查找有没有 2 )

6、[ ].indexOf
作用：判断数组中是否包含某个值，判断的方式为「由左而右」，如果有包含就返回这个值在数组中的索引值，如果没有就返回-1，
传参：（第一个参数表示要判断的值( 必填)，第二个参数表示从数组的哪个位置开始判断( 选填，预设为0 )。）；
返回值：找不到-1，找得到索引；

let array = [2, 5, 9];
array.indexOf(2);     // 0
array.indexOf(7);     // -1

let a = [1,2,3,4,5,6,7,8];
console.log(a.indexOf(4)); // 3
console.log(a.indexOf(4,5));
// -1 ( 在6,7,8中搜索有沒有4 )

7、[ ].ilastIndexOf()
作用：判断数组中是否包含某个值，判断的方式为「由右而左」，如果有包含就返回这个值在数组中的索引值，如果没有就返回-1，
传参：（第一个参数表示要判断的值( 必填)，第二个参数表示从数组的哪个位置开始从右往左查找( 选填，默认为整个数组长度-1 )。）；
返回值：找不到-1，找得到索引；

let a = [1,2,3,4,5,6,7,8];
console.log(a.lastIndexOf(3)); // 2
console.log(a.lastIndexOf(3,1));
// -1 ( 只在1,2中判断，所以沒有 3 )

三.Iteration方法

1、[ ].forEach
作用：将数组中每个元素套用到指定的函数里进行运算，
传参：（callback(当前元素,索引，该数组)）；
返回值：无；

 //标准用法array.forEach(callback(currentValue, index, array){//do something
}, this)

let a = [1,2,3,4,5];
let b = 0;
a.forEach(item => {b = b + item;
});
console.log(b); // 15 ( 1+2+3+4+5 )

如果结合第二和第三个参数进行搭配使用，就能做到改变原本数组的效果。

let a = [1,2,3,4,5];
a.forEach((item, index, arr) => {arr[index] = item * 10;
});
console.log(a); // [10,20,30,40,50]

2、[ ].find
作用：将数组中的「每一个」元素带入指定的函数内做判断，并会返回第一个符合判断条件的元素，如果没有元素符合则会返回undefined。
传参：（callback(当前元素,索引，该数组)）；
返回值：该元素；（[].findIndex()返回索引）

 //标准用法array. find(callback(currentValue, index, array){//do something
}, this)let num = [1,2,3];
console.log(num.find( value => {if(value === 2){return true;}return false;
}));  // 2

let a = [1,2,3,4,5,6,7,8];
console.log(a.find(e => e > 3)); // 4
console.log(a.find(e => e < 0)); // undefined

3、[ ].filter
作用：将数组中的「每一个」元素带入指定的函数内做判断，如果元素符合判断条件则会返回，组成一个新的数组。
传参：（callback(当前元素,索引，该数组)）；
返回值：通过测试的元素的集合的数组；

 //标准用法let arr = array.filter(callback(currentValue, index, array){//do something}, this)

let a = [1,2,3,4,5,6,7,8];
console.log(a.filter(e => e > 3));
// [4, 5, 6, 7, 8]
console.log(a.filter(e => e%2 == 0));
// [2, 4, 6, 8]

4、[ ].map
作用：创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。处理数组中每个元素，最后返回一个新的数组，里头有一个函数( 必填) 和一个返回函数里的this参数( 选填)，函数内又包含三个参数，第一个是每个元素的值( 必填)，第二个是当前元素的索引值( 选填)，第三个是当前的数组( 选填)。
传参：（callback(当前元素,索引，该数组)）；
返回值：一个新数组，每个元素都是回调函数的结果；

 //标准用法let numbers = [1, 4, 9];let roots = numbers.map(Math.sqrt);// roots的值为[1, 2, 3], //numbers的值仍为[1, 4, 9]

let a = [1,2,3,4,5,6,7,8];
let b = a.map(e => {return e + 10;
});
console.log(b); // [11, 12, 13, 14, 15, 16, 17, 18]

使用第二个和第三个参数的示例:

let a = [1,2,3,4,5,6,7,8];
let b = a.map((e,i,arr) => {return `${e}${i}${arr.find(e => e%5 == 1)}`;
// 组合成「元素 + 索引值 + 除以五余数为1的第一个元素」
});
console.log(b);
// ['101', '211', '321', '431', '541', '651', '761', '871']

如果要使用回调函数里this的参数，则「不能使用」箭头函数，因为箭头函数的this指向和函数的this指向不同，所以要用一般的函数处理。

let a = [1,2,3,4,5,6,7,8];
let b = a.map(function(e){return e + this; // 此处的 this为10
}, 10);
console.log(b); // [11, 12, 13, 14, 15, 16, 17, 18]

5、[ ].every
作用：测试数组，将数组中的「每一个」元素带入指定的函数内做判断，只要有任何一个元素不符合判断条件，会回返回false，如果全部符合，就会回传true。
传参：（callback(当前元素,索引，该数组)）；
返回值：true或false；

//标准用法
function isBigEnough(element, index, array) {return (element >= 10);
}
let passed = [12, 5, 8, 130, 44].every(isBigEnough);    // passed is falsepassed = [12, 54, 18, 130, 44].every(isBigEnough);    // passed is true

let a = [1,2,3,4,5,6];
console.log(a.every(e => e > 3));
// fasle ( 因为1、2 小于 3，3 等于 3 )
console.log(a.every(e => e > 0));
// true

6、[ ].some
作用：测试数组，将数组中的「每一个」元素带入指定的函数内做判断，只要有任何一个元素符合判断条件，就会返回true，如果全都不符合，才会返回false。；
传参：（callback(当前元素,索引，该数组)）；
返回值：true或false；

//标准用法
function isBigEnough(element, index, array) {return (element >= 10);
}
let passed = [1, 5, 8, 3, 4].some(isBigEnough);    // passed is falsepassed = [2, 4, 18, 13, 4].some(isBigEnough);    // passed is true

let a = [1,2,3,4,5,6];
console.log(a.some(e => e > 3));
// 返回 true，因为 4、5、6 大于 3
console.log(a.some(e => e > 6));
// 返回 fasle，因为全都小于或等于 6

7、[ ].reduce
作用：对累加器和数组中的每个元素（从左到右）应用一个函数，将其减少为单个值（将数组中每个元素进行计算，每次计算的结果会再与下个元素作计算，直到结束为止，里头包含一个函数( 必填) 和初始计算的数值( 选填)，函数内有四个参数，第一个是计算的值( 必填)，第二个是取得的元素(必填)，第三个是该元素的索引值( 选填)，第四个是原本的数组(选填)。）；
传参：（callback(累加器accumulator，当前元素,索引，该数组)）；
返回值：函数累计处理的结果；

//标准用法
let total = [0, 1, 2, 3].reduce((sum, value) => {return sum + value;
}, 0);
// total is 6let flattened = [[0, 1], [2, 3], [4, 5]];
flattened.reduce((a, b) => {return a.concat(b);
}, []);// flattened is [0, 1, 2, 3, 4, 5]

let a = [1,2,3,4,5,6,7,8];
let b = a.reduce(function(total, e){return total + e;
});
console.log(b); // 36 ( 1+2+3+4+5+6+7+8=36 )

[ ].reduceRight()
和reduce()大同小异，只是其计算方式是由右到左，对于加法来说没什么影响，但对于减法而言就有差异。

let a = [1,2,3,4,5,6,7,8];
let b = a.reduce(function(total, e){return total - e;
});
console.log(b);
// -34 ( 1-2-3-4-5-6-7-8 = -34 )
let c = a.reduceRight(function(total, e){return total - e;
});
console.log(c);
// -20 ( 8-7-6-5-4-3-2-1 = -20 )

8、[ ].entries
作用：返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对；
传参：无；
返回值：一个新的 Array 迭代器对象；

   //标准用法var arr = ["a", "b", "c"];var iterator = arr.entries();// undefinedconsole.log(iterator);// Array Iterator {}console.log(iterator.next().value); // [0, "a"]console.log(iterator.next().value); // [1, "b"]console.log(iterator.next().value); // [2, "c"]

9、[ ].values
作用：数组转对象；
传参：无；
返回值：一个新的 Array 迭代器对象；

   //标准用法let arr = ['w', 'y', 'k', 'o', 'p'];let eArr = arr.values();    // 您的浏览器必须支持 for..of 循环// 以及 let —— 将变量作用域限定在 for 循环中for (let letter of eArr) {console.log(letter);}

四Establish方法（创建新方法）

1、Array.from()

该方法基于一个类数组的对象或可迭代的对象，创建一个新的数组实例。该方法接收一至三个参数，各个参数如下：

参数1是一个类数组对象或可迭代对象，方法基于该对象创建数组。函数的返回值将作为新数组中的每一项的值。必需的参数。

参数2是一个函数，数组的每一项都会调用该函数。非必需参数。

参数3指定在参数2中，this所代表的对象。非必需参数。

类数组对象是具有length属性并含有被编上索引index的元素的对象，如NodeList对象。
可迭代对象是表示具有可以利用迭代的方式取得它自己本身的元素，如Map和Set

var str = "hello";
Array.from(str, x => x + x);      // ["hh", "ee", "ll", "ll", "oo"]

上面的代码中接收一个字符串为第一个参数，接收箭头函数作为第二个参数。在箭头函数中，对每一项做了复制操作，然后返回得到的值，作为数组的每一项。

let a = 'abcde';
let b = Array.from(a);
console.log(b); // ['a','b','c','d','e']
let c = Array.from(a, e => e + e);
console.log(c); // ['aa','bb','cc','dd','ee']

类数组对象写法必须包含length 属性，且对象的key须为0开始的数字，对应转换后的元素索引。

let a = {'0': 14,'2': 13,'1': 7,'3': 9,'4': 6,length: 5
};
let b = Array.from(a);
console.log(b); // [14,7,13,9,6]

2.Array.of()
该方法接收一系列参数，并以这些参数为项，创建一个数组，并返回该数组（快速将数字、字串等内容，转换成数组）。

var arra = Array.of("red", "green", "blue");
console.log(arra);         //  ["red", "green", "blue"]

该方法与构造函数Array()类似，但有一点不同。当接收到只有一个数值类型的参数时，Array()会创建一个数值参数指定的长度的数组，而Array.of()会将该数值作为数组中的项添加进数组。

var arra1 = new Array(7);
console.log(arra1);     //  [undefined × 7]
var arra2 = Array.of(7);
console.log(arra2);     //  [7]

let a = Array.of(1,'a',2,'b',3);
console.log(a);
// [1, "a", 2, "b", 3]

JS组数操作方法（包含ES6）相关推荐

JavaScript字符串操作方法大全，包含ES6方法
一.charAt() 返回在指定位置的字符. var str="abc" console.log(str.charAt(0))//a 二.charCodeAt() 返回在指定的位置 ...
JavaScript字符串操作方法大全，包含ES6方法 1
一.charAt() 返回在指定位置的字符. var str="abc" console.log(str.charAt(1))//a 二.charCodeAt() 返回在指定的位置 ...
JavaScript字符串操作方法大全，包含ES6方法 2
一.charAt() 返回在指定位置的字符. var str="abc" console.log(str.charAt(1))//a 二.charCodeAt() 返回在指定的位置 ...
mysql必须包含数据组_MySQL必知必会--分组数据
数据分组目前为止的所有计算都是在表的所有数据或匹配特定的 WHERE 子句的数据上进行的.提示一下,下面的例子返回供应商 1003 提供的产品数目但如果要返回每个供应商提供的产品数目怎么办?或者 ...
13. 编写一个程序，提示用户输入3组数，每组数包含5个double类型的数(假设用户都正确地响应，不会输入非数值数据)。该程序应完成下列任务。
13. 编写一个程序,提示用户输入3组数,每组数包含5个double类型的数(假设用户都正确地响应,不会输入非数值数据).该程序应完成下列任务. 13. 编写一个程序,提示用户输入3组数,每组数包含5 ...
c++中组数的替代方案
向量 vector vector可以看作一个动态数组,用于存储一组数据类型相同的数据,对数据元素的个数没有限制,即可以把 vector看作一个存放任意数据类型的"容器".使用 ve ...
122345 java_【每天算法2】：用java语言实现，一个组数：122345这6个数，打印出它所有可能的组合；要求4不能在第3位，3和5不能相连。 | 学步园...
一个组数:122345这6个数,打印出它所有可能的组合:要求4不能在第3位,3和5不能相连. 我在实现这个感觉我的算法复杂度还是挺高的.过程中,不断的创建新的数组列别. 如果你有更好的算法,请发上来 ...
Description 一个笼子里关了若干鸡和兔子，鸡有2只脚，兔子有4只脚，没有例外。已知笼子里脚的总数a，问笼子里至少有多少只动物，至多有多少只动物？ Input 第一行是测试数据的组数n，后面
/*Description 一个笼子里关了若干鸡和兔子,鸡有2只脚,兔子有4只脚,没有例外.已知笼子里脚的总数a,问笼子里至少有多少只动物,至多有多少只动物? Input 第一行是测试数据的组数n, ...
JS元素属性操作方法，包括获取属性，修改属性，删除属性
JS元素属性操作方法,包括获取属性,修改属性,删除属性本篇记录JS元素属性的操作的方法.其中包含获取属性两个方法,修改属性两个方法,删除属性一个方法获取属性 element.属性该方法通常获取自 ...

JS组数操作方法（包含ES6）

JS组数操作方法（包含ES6）相关推荐

最新文章

热门文章