操作数组的常用方法有这些就够了,JavaScript数组

时间:2019-10-06 20:33来源:编程技术
除了 Object 之外, Array 类型恐怕是 ECMAScript 中最常用的类型了;数组的每一项 可以保存任何类型的数据 ;数组的大小是可以 动态 调整的,即可以随着数据的添加自动增长以容纳新增数

除了 Object 之外,Array 类型恐怕是 ECMAScript 中最常用的类型了;数组的每一项可以保存任何类型的数据;数组的大小是可以动态调整的,即可以随着数据的添加自动增长以容纳新增数据。

不改变原数组的方法:

1.indexOf()lastIndexOf()

1.1 indexOf() : 返回元素在数组的索引,从0开始。若数组不存在该元素,则返回-1

var arr = [1, 2];
arr.indexOf(1); //0
arr.indexOf(10); //-1

1.2 lastIndexOf():
返回元素在数组中最后一次出现的索引,如果没有出现则返回-1.

var arr = [1, 2, 3, 4, 2];
arr.lastIndexOf(2); // 4

2.slice(): 与字符串substring()方法一样,截取数组的一部分,返回一个新的数组。

2.1 通常,接受2个参数作为一个左闭右开区间,即包括开始索引位置的元素,但不包括结束索引位置的元素。

var arr = [1, 2, 3,4,5,6];
arr.slice(0,2)    //[1, 2] 只返回索引0,1位置的元素

2.2 可以省略第二个参数,即截取到原数组的最后一个元素。

arr.slice(2,);    //[3, 4, 5, 6] 

2.3 如果没有传参数,则返回一个从头到尾截取所有元素的新数组。可以用来复制一个数组。

var copyArr = arr.slice();
copyArr;   //[1, 2, 3, 4, 5, 6]

3.concat(): 合并数组。把当前的数组和另一个数组连接起来,并返回一个新的数组。

3.1 concat()方法的参数可以有多个,也可以任意任意类型,数值字符串布尔值数组对象 都可以,参数会被被添加到新的数组中。

var arr1 =  [1, 2, 3,4,5,6];
var arr2 = ['a','b','c'];
var arr3 = arr1.concat(arr2);
arr3;   //[1, 2, 3, 4, 5, 6, "a", "b", "c"]

3.2 注意,如果参数是数组, 会被拉平一次,即数组会被拆开来,加入到新的数组中。具体看示例:

var arr1 = [1, 2, 3];
var arr2 = arr1.concat(66,'abc',true,[10,20],[30,[31,32]],{x:100});
arr2;  //[1, 2, 3, 66, "abc", true, 10, 20, 30, [31,32], {x:100}]

4.join(): 转成字符串。它会把当前Array的每个元素都用指定的字符串连接起来,然后返回连接后的字符串。

4.1 参数是用来指定连接的字符串。见示例代码:

var arr = [1, 2, 3];
arr.join('*')   //"1*2*3"

4.2 如果没有指定参数,默认是用,连接。

var arr = [1, 2, 3];
arr.join()   //"1,2,3"

5.toString(): 返回数组的字符串形式

var arr = [1, 2, 3];
arr.toString() // "1,2,3"

6.valueOf():返回数组本身

var arr = [1, 2, 3];
arr.valueOf() // [1, 2, 3]

7.map():

7.1 对数组的所有成员依次调用一个函数,返回值是一个新数组。

var arr = [1, 2, 3];
arr.map(function(elem){
    return elem*2;
});
//[2, 4, 6, 8]
arr; //[1, 2, 3]

7.2 map方法接受一个函数作为参数,该函数调用时,map方法会将其传入3个参数,分别是当前成员、当前位置和数组本身(后2个参数可选)。

arr.map(function(elem, index, arr) {
    return elem * index;
}); 
//[0, 2, 6]

7.3 map方法还可以接受第2个参数,表示回调函数执行时this所指向的对象。

8.forEach(): 与map方法很相似,也是遍历数组的所有成员,执行某种操作。注意forEach方法一般没有返回值

var arr = [1, 2, 3];
function log(element, index, array) {
    console.log('[' + index + '] = ' + element);
}
arr.forEach(log);
// [0] = 1
// [1] = 2
// [2] = 3

注意: forEach方法无法中断执行,总是会将所有成员遍历完。如果希望符合某种条件时,就中断遍历,要使用for循环

9.filter():

9.1 筛选数组的元素,返回值是符合筛选条件元素组成的一个新数组。

var arr = [1, 2, 3, 4, 5];
arr.filter(function (elem) {
  return (elem > 3);
});
//[4, 5]

9.2 filter方法接受一个函数作为参数,该函数调用时,fitler方法会将其传入3个参数,分别是当前成员、当前位置和数组本身(后2个参数可选)。

var arr = [1, 2, 3, 4, 5];
arr.filter(function (elem, index, arr) {
  return index % 2 === 1;
});
//[2, 4]

9.3 filter方法还可以接受第2个参数,指定测试函数所在的上下文对象(即this对象)。

10.some()every(): 类似“断言”(assert),用来判断数组成员是否符合某种条件。

10.1 接受一个函数作为参数,所有数组成员依次执行该函数,返回一个布尔值。该函数接受三个参数,依次是当前位置的成员、当前位置的序号和整个数组。

10.2 some方法是只要有一个数组成员的返回值是true,则整个some方法的返回值就是true,否则false。

var arr = [1, 2, 3, 4];
arr.some(function (elem, index, arr) {
  return elem >= 3;
});
// true

10.3 every方法则是所有数组成员的返回值都是true,才返回true,否则false。

var arr = [1, 2, 3, 4];
arr.every(function (elem, index, arr) {
  return elem >= 3;
});
// false

10.4 注意,对于空数组some方法返回false,every方法返回true

10.5 someevery方法还可以接受第2个参数,用来绑定函数中的this关键字

11.reduce()reduceRight(): 依次处理数组的每个成员,最终累计为一个值。

11.1reduce从左到右处理(从第一个成员到最后一个成员)

arr.reduce(function(x, y){
  console.log(x, y)
  return x + y;
});
// 1 2
// 3 3
// 6

11.2reduceRight则是从右到左处理(从最后一个成员到第一个成员)

arr.reduceRight(function(x, y){
  console.log(x, y)
  return x + y;
});
// 3 2
// 5 1
// 6

下面是操作数组的常用方法:

改变原数组的方法:

1.push(): 向数组的末尾添加若干元素。返回值是改变后的数组长度。

var arr = [1, 2];
arr.push(3) ;// 3
arr; //  [1, 2, 3]
arr.push('b','c'); //5
arr; //[1, 2, 3, "b", "c"]
arr.push([10,20]); //6
arr; //[1, 2, 3, "b", "c", [10,20]]

2.pop(): 删除数组最后一个元素。返回值是删除的元素。

var arr =[1, 2, 3, "b", "c", [10,20]];
arr.pop(); //[10, 20]
arr;  // [1, 2, 3, "b", "c"]

3.unshift(): 向数组头部添加若干元素。返回值是改变后的数组长度。

var arr = [1, 2];
arr.unshift(3,4 );  //4
arr;  // [3, 4, 1, 2]

4.shift(): 删除数组最后一个元素。返回值是删除的元素。

var arr = ['a', 'b', 1, 2];
arr.shift(); //'a'
arr;  //['b', 1, 2]

5.sort(): 数组排序。

5.1 注意:默认是将所有元素转换成字符串,再按字符串Unicode码点排序。返回值是新的数组。

var arr = [1, 2, 12, 'a', 'b', 'ab', 'A', 'B']
arr.sort();  //[1, 12, 2, "A", "B", "a", "ab", "b"] 注意:12排在了2的前面

5.2 如果元素都是数字,要按从小到大排序,可以传入一个回调函数作为参数。

var arr = [1, 2, 12, 100]

arr.sort(function(a,b){
    return a-b;
});
// [1, 2, 12, 100]

5.3 如果想要从大到小排序:

arr.sort(function(a,b){
    return b-a;
});
//[100, 12, 2, 1]

6.reverse(): 颠倒数组中元素的位置

var arr = [1, 2, 12, 'a', 'b', 'ab', 'A', 'B'];
arr.reverse();
//["B", "A", "ab", "b", "a", 12, 2, 1]

7.splice(): 修改数组元素(新增、删减、替换)。从指定的索引开始删除若干个元素,然后再从该位置添加若干个元素。返回值是删除的元素组成的数组。参数1是删除元素的起始索引,参数2是删除的元素个数,之后的参数为待添加的元素。

7.1 只删除,不添加。可以传入2个参数:

var arr = ['Alibaba', 'Tencent', 'Baidu', 'XiaoMi', '360'];

// 从索引2开始删除3个元素
arr.splice(2, 3); // 返回删除的元素 ['Baidu', 'XiaoMi', '360']
arr; // ['Alibaba', 'Tencent']

7.2 只添加,不删除。第2个参数设为0,即不删除元素。

arr.splice(2, 0, 'Toutiao', 'Meituan', 'Didi'); // 返回[],因为没有删除任何元素
arr; //["Alibaba", "Tencent", "Toutiao", "Meituan", "Didi"]

7.3 先删除若干元素,然后在删除的位置上在添加若干个元素。

var  arr =["Alibaba", "Tencent", "Toutiao", "Meituan", "Didi"]
arr.splice(2,2,'Apple','Google');  //["Toutiao", "Meituan"]
arr; //["Alibaba", "Tencent", "Apple", "Google", "Didi"]

数组的创建数组自带属性检测是否为数组数组元素的增加与删除数组与字符串的相互转化数组的截取和合并数组元素的排序元素在数组中的位置数组的遍历与迭代其他方法扩展运算符

Array.isArray()

用来判断一个值是否为数组, 如果参数为数组,返回true,否则,返回false.

var arr = [1,2]
Array.isArray(arr);  //true;

Array.isArray('a'); //false

数组的创建[1]

  1. 使用Array构造函数的方式
new Array(); // 创建一个数组new Array; // 创建一个数组并指定长度,注意不是上限,是长度new Array(element0, element1, ..., elementn); // 创建一个数组并赋值const array = new Array();array[0] = '1';
  1. 采用字面量的方法
const array = []; //创建一个空数组const array2 = [1, 2, 3]; //创建一个有三个元素的数组

在使用数组字面量表示法时,不会调用Array构造函数。

数组自带属性[2]

constructor // 返回创建数组对象的原型函数length // 返回数组对象的长度prototype // 可以增加数组的原型方法和属性

关于数组的length属性

关于数组的的length属性,这个属性不是只读的,数组的该属性可读可写;通过设置这个属性,可以从数组的末尾移除项或向数组中添加新项。

// 将其 length 属性设置为 2 会移除最后一项结果再访问 colors[2]就会显示 undefined 了var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组 colors.length = 2; alert(colors[2]); //undefined

如果将其 length 属性设置为大于数组 项数的值,则新增的每一项都会取得undefined 值。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组 colors.length = 4; alert(colors[3]); //undefined

利用 length 属性可以方便地在数组末尾添加新项。

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组 colors[colors.length] = "black"; //添加一种颜色 colors[colors.length] = "brown"; //再添加一种颜色

检测是否为数组[3]

  1. 使用instanceof方法

instanceof 用于判断一个变量是否是某个对象的实例

const array = new Array();array instanceof Array; //true
  1. 使用constructor属性

constructor 属性返回对创建此对象的数组函数的引用,就是返回对象相对应的构造函数。

const array = new Array();array.constructor === Array; // true
  1. 使用isArray()方法

对支持isArray的浏览器,直接使用isArray方法。

const array = new Array();Array.isArray; //true

如果浏览器不支持Array.isArray()则需进行必要判断。

/** * 判断一个对象是否是数组,参数不是对象或者不是数组,返回false * * @param {Object} arg 需要测试是否为数组的对象 * @return {Boolean} 传入参数是数组返回true,否则返回false */function isArray { if (typeof arg === 'object') { return Object.prototype.toString.call === '[object Array]'; } return false;}

数组元素的增加与删除[4]

  1. array.push(e1, e2, ...eN) 将一个或多个元素添加到数组的末尾,并返回新数组的长度。
const array = [1, 2, 3];const length = array.push;// array: [1, 2, 3, 4, 5]; length: 5
  1. array.unshift(e1, e2, ...eN)将一个或多个元素添加到数组的开头,并返回新数组的长度。
const array = [1, 2, 3];const length = array.unshift;// array: [ 4, 5, 1, 2, 3]; length: 5
  1. array.pop()从数组中删除最后一个元素,并返回最后一个元素的值,原数组的最后一个元素被删除。数组为空时返回undefined
const array = [1, 2, 3];const poped = array.pop(); // array: [1, 2]; poped: 3
  1. array.shift()删除数组的第一个元素,并返回第一个元素,原数组的第一个元素被删除。数组为空时返回undefined
const array = [1, 2, 3];const shifted = array.shift(); // array: [2, 3]; shifted: 1
  1. array.splice(start[, deleteCount, item1, item2, ...])从数组中添加/删除元素,返回值是由被删除的元素组成的一个新的数组,如果只删除了一个元素,则返回只包含一个元素的数组。如果没有删除元素,则返回空数组。
  • start 指定修改的开始位置。如果超出了数组的长度,则从数组末尾开始添加内容;如果是负值,则表示从数组末位开始的第几位。
  • deleteCount ,从start位置开始要删除的元素个数。如果 deleteCount 是 0,则不移除元素。这种情况下,至少应添加一个新元素。如果deleteCount大于start之后的元素的总数,则从start后面的元素都将被删除(含第 start 位)。
  • item1, item2, …,要添加进数组的元素,从start位置开始。如果不指定,则 splice() 将只删除数组元素。
const array = [1, 2, 3, 4, 5];const deleted = array.splice; // 在索引为2的位置插入6// array 变为 [1, 2, 6, 3, 4, 5]; deleted为[]

数组与字符串的相互转化[5]

  1. 数组转字符串

array.join(separator=',')将数组中的元素通过separator连接成字符串,并返回该字符串,separator默认为","。

const array = [1, 2, 3];let str = array.join;// str: "1,2,3"

toLocaleString()toString()valueOf():所有对象都具有这三个方法,数组继承的这个三个方法,可以看作是join()的特殊用法,不常用。

var colors = ["red", "blue", "green"]; // 调用数组的 toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串console.log(colors.toString; // red,blue,green// 调用 valueOf()返回的还是数组console.log(colors.valueOf; // ["red", "blue", "green"]console.log(colors.toLocaleString; // red,blue,green

如果数组中的某一项的值是 null 或者 undefined,那么该值在join()toLocaleString()toString()valueOf()方法返回的结果中以空字符串表示。

  1. 字符串转数组

string.split(separator,howmany)用于把一个字符串分割成字符串数组。separator ,字符串或正则表达式,从该参数指定的地方对字符串进行分割。howmany ,该参数可指定返回的数组的最大长度。

let str = "abc,abcd,aaa";let array = str.split;// 在每个逗号处进行分解。// array: [abc,abcd,aaa]const array1 = "helloworld";let str1 = s1.split; //["h", "e", "l", "l", "o", "w", "o", "r", "l", "d"]

数组的截取和合并[6]

  1. 数组的截取 - array.slice(start, end) 方法

slice()通过索引位置,从数组中返回start下标开始,直到end下标结束(不包括)的新数组,该方法不会修改原数组,只是返回一个新的子数组

  • start ,设定新数组的起始位置;如果是负数,则表示从数组尾部开始算起(-1 指最后一个元素,-2 指倒数第二个元素,以此类推)。
  • end ,设定新数组的结束位置;如果不填写该参数,默认到数组结尾;如果是负数,则表示从数组尾部开始算起(-1 指最后一个元素,-2指倒数第二个元素,以此类推)。
// 获取仅包含最后一个元素的子数组let array = [1,2,3,4,5];array.slice; // [5]// 获取不包含最后一个元素的子数组let array2 = [1,2,3,4,5];array2.slice; // [1,2,3,4]

该方法并不会修改数组,而是返回一个子数组。如果想删除数组中的一段元素,应该使用方法 array.splice()

  1. 数组的合并 - array.concat([item1[, item2[, . . . [,itemN]]]])方法

conact()是将多个数组(也可以是字符串,或者是数组和字符串的混合)连接为一个数组,返回连接好的新的数组。

const array = [1,2].concat(['a', 'b'], ['name']);// [1, 2, "a", "b", "name"]

数组元素的排序[7]

  1. array.sort()方法

sort()方法用于对数组的元素进行排序,并返回原数组。如果不带参数,按照字符串UniCode码的顺序进行排序。

const array = ['a', 'd', 'c', 'b'];array.sort(); //['a', 'b', 'c', 'd']

sort()中传入排序规则函数可实现自定义排序。

排序函数规则:传两个形参当返回值为正数时,交换传入两形参在数组中位置

按照数值大小进行排序-升序

[1, 8, 5].sort => { return a-b; // 从小到大排序});// [1, 5, 8]

按照数值大小进行排序-降序

[1, 8, 5].sort => { return b-a; // 从大到小排序});// [8, 5, 1]
  1. array.reverse()方法reverse() 方法将数组中元素的位置颠倒,第一个数组元素成为最后一个数组元素,最后一个数组元素成为第一个。在原数组上操作,然后返回原数组
let arr = [1,2,3,4,5]console.log(arr.reverse // [5,4,3,2,1]console.log // [5,4,3,2,1]

数组的sort()reverse()方法都对原数组进行了修改,返回值是经过排序之后的数组。

元素在数组中的位置[8]

  1. indexOf()lastIndexOf()
  • indexOf(searchElement[, fromIndex = 0]) 方法返回某个指定的字符串值在字符串中首次出现的位置
  • lastIndexOf(searchElement[, fromIndex = 0]) 方法返回一个指定的字符串值最后出现的位置,在一个字符串中的指定位置从后向前搜索。
  • 这两个方法都接受两个参数:searchElement:要查找的元素;fromIndex:开始查找的索引位置。
  • 这两个方法都返回查找的项在数组中的位置,或者在没找到的情况下返回-1
[2, 9, 7, 8, 9].indexOf; // 1[2, 9, 7, 8, 9].lastIndexOf; // 4
  1. find()findIndex()

find(callback[, thisArg])方法,用于找出第一个符合条件的数组元素。它的参数是一个回调函数,所有数组成员依次执行该回调函数,直到找出第一个返回值为true的成员,然后返回该成员。如果没有符合条件的成员,则返回undefined

[1, 4, -5, 10].find => n < 0)// -5

find()方法的回调函数可以接受三个参数,依次为当前的值、当前的位置和原数组。

[1, 5, 10, 15].find(function(value, index, arr) { return value > 9;}) // 10

findIndex(callback[, thisArg])返回第一个符合条件的数组成员的位置,如果所有成员都不符合条件,则返回-1。

[1, 5, 10, 15].findIndex(function(value, index, arr) { return value > 9;}) // 2

这两个方法都可以接受第二个参数,用来绑定回调函数的this对象。

function f{ return v > this.age;}let person = {name: 'John', age: 20};[10, 12, 26, 15].find(f, person); // 26
  1. includes(searchElement[, fromIndex = 0])方法返回一个布尔值,表示某个数组是否包含给定的值。

这个方法都接受两个参数:searchElement:要查找的元素;fromIndex:开始查找的索引位置。

[1, 2, 3].includes // true[1, 2, 3].includes; // false[1, 2, 3].includes; // true

数组的遍历与迭代[9]

  1. array.filter(callback, thisArg)方法使用指定的函数测试所有元素,并创建一个包含所有通过测试的元素的新数组。

参数说明:

  • callback 用来测试数组的每个元素的函数,返回true表示保留该元素,false则不保留。
  • thisArg 可选。执行 callback 时的用于 this 的值。
// callback定义如下,三个参数: element:当前元素值;index:当前元素下标; array:当前数组function callback(element, index, array) { // callback函数必须返回true或者false,返回true保留该元素,false则不保留。 return true || false;}const filtered = [1, 2, 3].filter(element => element > 1);// filtered: [2, 3];
  1. array.every(callback[, thisArg])方法检测数组中的每一个元素是否都通过了callback测试,全部通过返回true,否则返回false
// callback定义如下: element:当前元素值;index:当前元素下标; array:当前数组function callback(element, index, array) { // callback函数必须返回true或者false告知every是否通过测试 return true || false;}let a = [1, 2, 3, 4, 5];let b = a.every => { return item > 0;});let c = a.every => { return item > 1;});console.log; // trueconsole.log; // false
  1. array.some(callback[, thisArg])判断数组中是否包含可以通过callback测试的元素,与every不同的是,这里只要某一个元素通过测试,即返回truecallback定义同上。
[2, 5, 8, 1, 4].some(item => item > 6);// true
  1. array.map(callback[, thisArg])方法返回一个由原数组中的每个元素调用callback函数后的返回值组成的新数组。
let a = [1, 2, 3, 4, 5];let b = a.filter => { return item > 3;});console.log; // [4 ,5]let bb = [];a.map => { if (item > 3) { bb.push; }});console.log; // [4, 5]let bbb = a.map => { return item + 1;});console.log; // [2, 3, 4, 5, 6]
  1. array.forEach为数组的每个元素执行对应的方法。
// callback定义如下: element:当前元素值;index:当前元素下标; array:当前数组let a = [1, 2, 3, 4, 5];let b = [];a.forEach => { b.push;});console.log; // [2,3,4,5,6]
  1. 遍历数组的方法:entries()values()keys()

这三个方法都是返回一个遍历器对象,可用for...of循环遍历,唯一区别:keys()是对键名的遍历、values()对键值的遍历、entries()是对键值对的遍历。

for(let item of ['a','b'].keys{ consloe.log; //0 //1}for(let item of ['a','b'].values{ consloe.log; //'a' //'b'}let arr4 = [0,1];for(let item of arr4.entries{ console.log; // [0, 0] // [1, 1]}for(let [index,item] of arr4.entries{ console.log(index+':'+item); //0:0 //1:1}
  1. array.reduce(callback[, initialValue])方法返回针对数组每项调用callback函数后产生的累积值。
const total = [0, 1, 2, 3].reduce((sum, value) => { return sum + value;}, 0);// total is 6const flattened = [[0, 1], [2, 3], [4, 5]].reduce => { return a.concat;// flattened is [0, 1, 2, 3, 4, 5]

参数说明:initialValue:累加器初始值, callback函数定义如下:

function callback(accumulator, currentValue, currentIndex, array) {}

以上callback的参数中accumulator代表累加器的值,初始化时,如果initialValue有值,则accumulator初始化的值为initialValue,整个循环从第一个元素开始;initialValue无值,则accumulator初始化的值为数组第一个元素的值,currentValue为数组第二个元素的值,整个循环从第二个元素开始。initialValue的数据类型可以是任意类型,不需要跟原数组内的元素值类型一致。

const newArray = [{ name: 'aa', age: 1 }, { name: 'bb', age: 2 }, { name: 'cc', age: 3 }].reduce((arr, element) => { if (element.age >= 2) { arr.push(element.name); } return arr; // 必须有return,因为return的返回值会被赋给新的累加器,否则累加器的值会为undefined。}, []);// newArray is ["bb", "cc"];// 上面代码的同等写法:const newArray = [{ name: 'aa', age: 1 }, { name: 'bb', age: 2 }, { name: 'cc', age: 3 }].filter(element => element.age >= 2).map(item => item.name);// newArray is ["bb", "cc"];

其他方法[10]

  1. Array.from()澳门金莎娱乐网站,方法

Array.from()方法是用于将类似数组的对象(即有length属性的对象)和可遍历对象转为真正的数组。比如,使用·Array.from()·方法,可以轻松将·JSON·数组格式转为数组。

let arrayLike = { '0': 'a', '1': 'b', '2': 'c', length: 3};let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']
  1. Array.of()方法

Array.of()方法是将一组值转变为数组。

let arr0 = Array.of;console.log;//[1,2,33,5]let arr1 = Array.of('你好','hello');console.log;//["你好", "hello"]

扩展运算符[11]

扩展运算符(spread)是三个点(...)。它好比rest参数的逆运算,将一个数组转为用逗号分隔的参数序列

console.log(...[1, 2, 3])// 1 2 3console.log(1, ...[2, 3, 4], 5)// 1 2 3 4 5

该运算符主要用于函数调用

function add { return x + y;}const numbers = [4, 38];add(...numbers) // 42

注意,扩展运算符如果放在括号中,JavaScript引擎就会认为这是函数调用,就会报错。

// Uncaught SyntaxError: Unexpected numberconsole.log()// Uncaught SyntaxError: Unexpected numberconsole.log(...[1, 2])// 1,2
  1. 数组的创建 ↩

  2. 数组自带属性 ↩

  3. 检测是否为数组 ↩

  4. 数组元素的增加与删除 ↩

  5. 数组与字符串的相互转化 ↩

  6. 数组的截取和合并 ↩

  7. 数组元素的排序 ↩

  8. 元素在数组中的位置 ↩

  9. 数组的遍历与迭代 ↩

  10. 其他方法 ↩

  11. 扩展运算符 ↩

编辑:编程技术 本文来源:操作数组的常用方法有这些就够了,JavaScript数组

关键词:

  • 上一篇:没有了
  • 下一篇:没有了