JavaScript Array 对象

403 1 年前
Array对象即数组对象用于在单个变量中存储多个值,JS的数组是弱类型的,所以允许数组中含有不同类型的元素,数组元素甚至可以是对象或者其他数组。

创建 Array 对象的语法

一、使用 Array 构造器

var list=new Array();
var list=new Array(size);
var list=new Array(element0,element1,...elementn);

二、字面量的方式

var arr = [1, 2];

Array 对象用于在变量中存储多个值,第一个数组元素的索引值为 0,第二个索引值为 1,以此类推。

var mycars = new Array();
mycars[0] = "Saab";
mycars[1] = "Volvo";
mycars[2] = "BMW";
var name=myCars[2];//访问myCars数组的第一个值
myCars[0]="Opel";//修改了数组 myCars 的第一个元素

所有的JavaScript变量都是对象。数组元素是对象。函数是对象。你可以在数组中有不同的变量类型。你可以在一个数组中包含对象元素、函数、数组:

let myArray = new Array();
myArray[0]=Date.now;
myArray[1]=myFunction;
myArray[2]=myCars;
let arr = new Array(2);//arr的长度为2,arr有两个成员为'undefined'的元素
//等同于
let arr = Array(2);

Array构造函数有一个很大的缺陷,就是不同的参数,会导致它的行为不一致

// 无参数时,返回一个空数组
new Array() // []

// 单个正整数参数,表示返回的新数组的长度
new Array(1) // [ empty ]
new Array(2) // [ empty x 2 ]

// 非正整数的数值作为参数,会报错
new Array(3.2) // RangeError: Invalid array length
new Array(-3) // RangeError: Invalid array length

// 单个非数值(比如字符串、布尔值、对象等)作为参数,
// 则该参数是返回的新数组的成员
new Array('abc') // ['abc']
new Array([1]) // [Array[1]]

// 多参数时,所有参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']

如果调用构造函数 Array() 时没有使用参数,那么返回的数组为空,length 字段为 0

当调用构造函数时只传递给它一个数字参数,该构造函数将返回具有指定个数、元素为 undefined 的数组。

当其他参数调用 Array() 时,该构造函数将用参数指定的值初始化数组。

当把构造函数作为函数调用,不使用 new 运算符时,它的行为与使用 new 运算符调用它时的行为完全一样。

因此,不建议使用它生成新数组,直接使用数组字面量是更好的做法。

var a=["a",,"b",,,,"c",,];

数组的成员是空位。虽然读取的时候返回undefined,但实际上该位置没有任何值。虽然可以取到length属性,但是取不到键名

let arr=["a",,"b",,"c",,];
arr.length;  //6
arr[1];  //undefined
0 in arr;  //true
1 in arr;  //false

Array对象的静态方法

Array.isArray()

Array.isArray()方法返回一个布尔值,表示参数是否为数组。它可以弥补typeof运算符的不足

var ar = [];
typeof ar;  // "object"
Array.isArray(ar);  //true

var ar = new Array();
Array.isArray(ar);  //true

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

Array.isArray("an array");  //false

Array.from()

从类似数组的对象或可迭代的对象返回一个数组

语法

Array.from (arrayLike [ , mapfn [ , thisArg ] ] );

参数

  • arrayLike 必需。类似数组的对象或可迭代的对象。
  • mapfn 可选。要对 arrayLike 中的每个元素调用的映射函数。
  • thisArg 可选。指定映射函数中的 this 对象。

arrayLike 参数必须是具有编制索引的元素和 length 属性的对象或可迭代对象,如 Set 对象。

类似数组的对象(array-like object)和可遍历(iterable)的对象(包括 ES6 新增的数据结构 Set 和 Map)。

var eArr = Array.from(document.querySelectorAll('*'));
var elem = eArr[0]; // elem contains a reference to the first DOM element

var charArr = Array.from("abc");
// charArr[0] == "a";

var setObj = new Set("a", "b", "c");
var objArr = Array.from(setObj);
// objArr[1] == "b"; 

var arr = Array.from([1, 2, 3], x => x * 10);
// arr[0] == 10;
// arr[1] == 20;
// arr[2] == 30;
let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};

// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

实际应用中,常见的类似数组的对象是 DOM 操作返回的 NodeList 集合,以及函数内部的arguments对象。

Array.of()

从传入的参数返回一个数组

语法

Array.of(element0[, element1][, ...][,elementN]);

参数 可选。要置于数组中的元素。这将创建一个具有 n + 1 个元素且长度为 n + 1 的数组。

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

使用 Array.ofnew Array 之间的差异

Array() // []
Array(3) // [, , ,]
Array(3, 11, 8) // [3, 11, 8]

Array.of() // []
Array.of(undefined) // [undefined]
Array.of(1) // [1]
Array.of(1, 2) // [1, 2]

Array数组对象属性

属性 作用
length 表示数组的长度,即其中元素的个数
prototype 返回对象类型原型的引用
constructor 表示创建对象的函数

Array对象的实例方法

concat()

连接两个或更多的数组,该方法不会改变现有的数组,而仅仅会返回连接后的新数组,如果要进行拼接的参数是数组,那么添加的是数组中的元素(仅拼接一维)

语法

array1.concat([item1[, item2[, . . . [, itemN]]]])

参数

  • array1:必需。其他数组连接到的 Array 对象。
  • item1,. . ., itemN:可选。要添加到 array1 的末尾的附加项。

要添加的项 (item1 itemN) 会按顺序(从列表中的第一个项开始)添加到数组。如果某一项为数组,则其内容将添加到 array1 的末尾。如果该项不是数组,则将其作为单个数组元素添加到数组末尾。

源数组元素按以下规则复制到结果数组:

  • 如果从连接到新数组的任何数组中复制某个对象,则该对象引用仍然指向相同的对象。不论新数组和原始数组中哪一个有改变,都将引起对方的改变。
  • 如果将某个数字或字符串值添加到新数组,则只复制其值。更改一个数组中的值不会影响另一个数组中的值。
let a = new Array(1,2,3);
let b = "dog";
let c = new Array(42, "cat");
let d = a.concat(b, c);
d;  //1, 2, 3, "dog", 42, "cat"

var obj = { a: 1 };
var oldArray = [obj];
var newArray = oldArray.concat();
obj.a = 2;
newArray[0].a // 2
var arr1 = [2,3],
    arr2 = ["4","5"],
    arr3 = [["aa","bb"],["cc","dd"]];
var newarr = arr1.concat(arr2,arr3);
var barr1 = arr1.concat();//可实现数组克隆
var barr2 = arr2.concat("tt",88)
console.log(barr2);//(4) ["4", "5", "tt", 88]
console.log(barr1);//(2) [2, 3]
console.log(newarr);//(6) [2, 3, "4", "5", Array(2), Array(2)]

copyWithin()

将指定位置的成员复制到其他位置(会覆盖原有成员),然后返回当前数组。也就是说,使用这个方法,会修改当前数组。

语法

array.copyWithin(target, start, end)

参数

  • target(必需):从该位置开始替换数据。如果为负值,表示倒数。
  • start(可选):从该位置开始读取数据,默认为 0。如果为负值,表示倒数。
  • end(可选):到该位置前停止读取数据,默认等于数组长度。如果为负值,表示倒数。

具有 length 属性且具有已按数字编制索引的属性名的任何对象(类数组)都能使用该方法

var fruits = ["1", "2", "3", "4", "5", "6"];;
fruits.copyWithin(2, 0, 2);
//["1", "2", "1", "2", "5", "6"]

copytWithin方法并不要求this对象值是一个Array对象,类数组对象也是可以的。

[].copyWithin.call({length: 5, 3: 1}, 0, 3); //结果:{0:1,3:1,length:5}

[].copyWithin获取copyWithin函数对象 call为任何一个函数对象都有的方法 call方法的第1个参数为call方法运行的上下文,也就是我们经常遇到的函数调用时候的this

// 首先去了解copyWithin()方法的基本使用。
// 对象{length: 5, 3: 1}有两个属性。
// length属性决定此对象为类数组对象,因此可使用copyWithin方法;
// 另外有一个key为3值为1的属性。
// 将3号位复制到0号位,因此导致创建key为0,值为1(与key为3的值一样)的属性。
// 返回{0: 1, 3: 1, length: 5}
[].copyWithin.call({length: 5, 3: 1}, 0, 3)

// 可类推返回{2: 1, 3: 1, length: 5}
[].copyWithin.call({length: 5, 3: 1}, 2, 3)

//实现删除数组最后一个元素
var a1= ["Banana", "Orange", "Apple", "Mango", "Kiwi"];
a1.copyWithin(1);
a1.shift();
//(4) ["Banana", "Orange", "Apple", "Mango"]
console.log(a1);

//实现删除数组第一个元素
var a1= ["Banana", "Orange", "Apple", "Mango", "Kiwi"];
a1.copyWithin(0,1);
a1.pop();
//["Orange", "Apple", "Mango", "Kiwi"]
console.log(a1);

every()

检测数组所有元素是否都符合指定条件。如果遇到一个元素不满足,则立即返回false,剩余的元素不会再进行检测。如果所有元素都满足条件,则返回true。如果数组没有元素,则 every 方法将返回 true。不为数组中缺少的元素调用该回调函数。

every 方法可由具有 length 属性且具有已按数字编制索引的属性名的任何对象使用(类数组)

语法

arr.every(callbackfn(value,index,array1), thisArg)

参数

  • array1:必需。一个数组对象。
  • callbackfn:必需。一个接受最多三个参数的函数。 every 方法会为 array1 中的每个元素调用 callbackfn 函数,直到 callbackfn 返回 false,或直到到达数组的结尾。
  • thisArg:可选。可在 callbackfn 函数中为其引用 this 关键字的对象。如果省略 thisArg,则 undefined 将用作 this 值。

回调函数语法

function callbackfn(value, index, array1)

  • value:数组元素的值。
  • index:数组元素的数字索引。
  • array1:包含该元素的数组对象
var ages = [32, 33, ,16, 40];
function checkAge(age){
    return age >= 18;
}
console.log(ages.every(checkAge));//false
console.log([].every(checkAge));//true
var numberArray = [1,15,20,31,18]
var numberRange = {
    max : 40,
    min : 0
};
function checkNum(value,index,arr){
	if(typeof value !== 'number'){
		return false;
	}else{
		return value >= this.min && value<= this.max;
	}	
}
//true
console.log(numberArray.every(checkNum,numberRange));
var numRange = {
	max:50
}
var obj = {
	0: 20,
	1: 20,
	2: 30,
	4: 50,
	length: 100	
};
function checkObj(v,i,a){
	//0,1,2,4
	console.log(i)
	return v <= this.max;
};
//true
//console.log(Array.prototype.every.call(obj,checkObj,numRange ))
//Array.prototype.every 与 [].every都可以
console.log([].every.call(obj,checkObj,numRange ))

fill()

方法使用给定值,填充一个数组。

语法

array.fill(value, start, end)

参数

  • value:必需。用于填充数组的值。
  • start:可选。用于填充数组值的起始索引。默认值为 0。
  • end:可选。用于填充数组值的结束索引。默认值是 this 对象的 length 属性。

如果 start 为负,则 start 被视为 length+start,其中,length 是数组的长度。如果 end 为负,则 end 被视为 length+end。不填充 end 位置的值

var arr1 = ["Banana", "Orange", "Apple", "Mango"];
arr1.fill('white',1,3);
//["Banana", "white", "white", "Mango"]
console.log(arr1);

var arr2 = [,,,22,];
arr2.fill(15,0)//[15, 15, 15, 15]
arr2.fill('aa',-3)//[15, "aa", "aa", "aa"]

var arr3 = new Array(5);
arr3.fill('bb',2);//[empty × 2, "bb", "bb", "bb"],arr3[0] => undefined

filter()

创建一个新的数组,新数组中的元素是通过检查指定数组中符合条件的所有元素,如果没有符合条件的元素则返回空数组

语法

array.filter(function(currentValue,index,arr), thisValue)

参数

every() 方法的参数,略

不为数组中缺少的元素调用该回调函数,具有 length 属性且具有已按数字编制索引的属性名的任何对象使用(类数组)

var arr1 = [1,2,3,4,,6,7,8,9];
var obj = {
	max:10
}
function checkNum(v,i,a){
	console.log('a');//输出了8次,跳过了空元素
	return v < this.max;
}
var arr2 = arr1.filter(checkNum,obj);
console.log(arr2);//(8) [1, 2, 3, 4, 6, 7, 8, 9]
var obj = {0:0,2:2,5:5,length:99}
function filterNum(value){
	return value > 0;
}
console.log(Array.prototype.filter.call(obj,filterNum));//[2, 5]
var stringObj = '1234 6789';
function filterNum(value){
	console.log('a');//输出9次,没跳过空格
	return value > 2;
};
// (6) ["3", "4", "6", "7", "8", "9"]
console.log(Array.prototype.filter.call(stringObj,filterNum));

find()

返回符合测试条件的第一个数组元素值,如果没有符合条件的则返回 undefined。当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素,之后的值不会再调用执行函数

语法

array.find(function(currentValue, index, arr),thisValue)

参数

every() 方法的参数,略

IE 11 及更早版本不支持 find() 方法,空缺元素会被当着undefined,具有 length 属性且具有已按数字编制索引的属性名的任何对象使用(类数组),可用于字符串

var arr1 = [1,2,3,4,5,6,7,8,9];
var arr2 = [1,,3,4,5,6,7,8,9];
var stringObj = '1 3456789'
var objArr = {
	0:0,
	1:1,
	3:3,
	8:8,
	length:99
}
var checkNum = function(v,i,a){
	return v > 5;
}
console.log(arr1.find(checkNum));//6 a输出了6次
console.log(arr2.find(checkNum));//6 a输出了6次 空元素当着undefined也执行了回调函数
//可用于字符串
console.log(Array.prototype.find.call(stringObj,checkNum));//6
//类数组
console.log([].find.call(objArr,checkNum));//8

findIndex()

返回符合测试条件的第一个数组元素索引,如果没有符合条件的则返回 -1。当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引值,之后的不会再调用执行函数

语法

array.findIndex(function(currentValue, index, arr), thisValue)

参数

every() 方法的参数,略

findIndex() 对于空数组,函数是不会执行的,IE 11 及更早版本不支持 findIndex() 方法, 对于数组中的每个元素,findIndex 方法都会调用一次回调函数,具有 length 属性且具有已按数字编制索引的属性名的任何对象使用(类数组),可用于字符串

[1,2,3].findIndex(function(x) { return x == 2;});//1
[].findIndex.call("123456",function(x){return x>2});//2
Array.prototype.findIndex.call({0:5,3:1,8:9,length:20},function(x){return x>5});//8

forEach()

为数组中的每个元素执行指定操作,对于空数组不会执行回调函数,该方法没有return返回值(返回undefined)

语法

array.forEach(function(currentValue, index, arr), thisValue)

参数

every() 方法的参数,略

对于空数组是不会执行回调函数的,不会为数组中缺少的元素调用回调函数,具有 length 属性且具有已按数字编制索引的属性名的任何对象使用(类数组),可用于字符串

var arr1 = [1,2,3];
var arr2 = [1,,3];
var stringObj = '123 456';
arr1 .forEach(function(x,i,a) {a[i] = Math.pow(x,2)});
console.log(arr1);// [1, 4, 9]
arr2 .forEach(function(x,i,a) {a[i] = Math.pow(x,2)});
console.log(arr2);//[1, empty, 9],回调函数跳过了空元素
Array.prototype.forEach.call(stringObj,function(x){console.log('aa')})//输出了7次'aa'

includes()

方法用来判断一个数组是否包含一个指定的值,如果是返回 true,否则false。

语法

arr.includes(searchElement, fromIndex)

参数

  • searchElement:必须。需要查找的元素值。
  • fromIndex:可选。从该索引处开始查找 searchElement。如果为负值,则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。如果fromIndex 大于等于数组长度 ,则返回 false
['aa',2,'cc'].includes('cc',1);//true
'aa2ccac'.includes("cc",0);//true  字符串也有includes方法

find()接收的参是find(callback[,thisvalue]),全部都会查找,不能指定开始查找索引值,返回的是找到的元素值;includes()接收的参数为(value,startindex),返回true/false。

indexOf()

返回某个值在数组中的第一个匹配项的索引(全等比较 类似=== ),如果未找到 searchElement,则为 -1,fromIndex默认为0,如果 fromIndex大于或等于数组长度,则返回 -1,可以为负数。

语法

array.indexOf(searchElement,fromIndex)

参数

  • searchElement:必需。要在 array1 中定位的值。
  • fromIndex:可选。用于开始搜索的数组索引。如果省略 fromIndex,则从索引 0 处开始搜索。
["ab", "cd", "ef", "ab", "cd"].indexOf('ab',-3);//3
'abcdefabcd'.indexOf('ab',3);//6 字符串也有indexOf方法

lastIndexOf()

方法可返回一个指定的字符串值最后出现的位置,在一个字符串中的指定位置从后向前搜索,如果要检索的字符串值没有出现,则该方法返回 -1,该方法将从尾到头地检索字符串

语法

array.lastIndexOf(searchElement,fromIndex)

参数

  • searchElement:必需。要在 array1 中定位的值。
  • fromIndex:可选。用于开始搜索的数组索引。如果省略 fromIndex,则搜索将从数组中的最后一个索引处开始向前索引。
["ab", "cd", "ef", "ab", "cd"].lastIndexOf('cd');//4
["ab", "cd", "ef", "ab", "cd"].lastIndexOf('cd',1);//1
["ab", "cd", "ef", "ab", "cd"].lastIndexOf('cd',2);//1

join()

把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。如果数组的任一元素为 undefined 或 null,则该元素将被视为空字符串

语法

array.join(separator)

参数

  • separator:可选。 用于将在结果 String 中的数组的一个元素与下一个元素分开的字符串。 若忽略此参数,则数组元素之间用逗号分隔。
["Banana", "Orange",, "Apple"].join('-');//"Banana-Orange--Apple" 计算空元素
Array.prototype.join.call({0:'aa',5:'bb',length:10},'-');//"aa-----bb----" 按length长度,空元素也会计算
Array.prototype.join.call('hello', '-')
// "h-e-l-l-o"

var obj = { 0: 'a', 1: 'b', length: 2 };
Array.prototype.join.call(obj, '-')
// 'a-b'

map()

对数组的每个元素按照原始顺序依次调用定义的回调函数并返回包含结果的新数组,不会为数组中空元素调用回调函数,直接在新数组中也生成一个对应的空元素

语法

array.map(function(currentValue,index,arr), thisValue)

参数

every() 方法的参数,略

具有 length 属性且具有已按数字编制索引的属性名的任何对象使用(类数组)

var f = function (n) { return 'a' };

[1, undefined, 2].map(f) // ["a", "a", "a"]
[1, null, 2].map(f) // ["a", "a", "a"]
[1, , 2].map(f) // ["a", , "a"]

map方法不会跳过undefined和null,但是会跳过空位。

[9, 16].map(Math.sqrt)//[3, 4]
[1,, 3].map(function(v,i,a){console.log('aa');return v*v})//(3) [1, empty, 9] 输现两个'aa',空元素没有执行回调函数

pop()

用于删除数组的最后一个元素,并返回该元素。注意,该方法会改变原数组。如果数组已经为空,则 pop() 不改变数组,并返回 undefined 值

语法

array.pop()

var arr1= ["Banana", "Orange", "Apple", "Mango"];
console.log(arr1.pop());//Mango

[].pop(); // undefined

push()

向数组的末尾添加一个或多个元素,并返回新的长度,如果某个参数是数组,则以单个元素的形式添加它,如果某个参数是数组,则以单个元素的形式添加它

语法

array.push(item1, item2, ..., itemX)

var arr1= ["Banana", "Orange", "Apple", "Mango"];
console.log(arr1.push("Kiwi","Lemon","Pineapple"));//7

let a = [1,2,3]
a.push([33,44])
console.log(a); //[ 1, 2, 3, [ 33, 44 ] ]

reduce()

将数组元素计算为一个值(从左到右),对数组中的所有元素调用指定的回调函数。该回调函数的返回值为累积结果,并且此返回值在下一次调用该回调函数时作为参数提供。

语法

array.reduce(callbackfn(previousValue, currentValue, currentIndex, array1), initialValue)

参数

  • callbackfn:必需。一个接受最多四个参数的函数。对于数组中的每个元素,reduce 方法都会调用 callbackfn 函数一次。
  • initialValue:可选。如果指定 initialValue,则它将用作初始值来启动累积。第一次调用 callbackfn 函数会将此值作为参数而非数组值提供。

reduce() 对于空数组是不会执行回调函数的,如果提供了 initialValue,则 reduce 方法会对数组中的每个元素调用一次 callbackfn 函数(按升序索引顺序)。如果未提供 initialValue,则 reduce 方法会对从第二个元素开始的每个元素调用 callbackfn 函数,回调函数的返回值在下一次调用回调函数时作为 previousValue 参数提供。最后一次调用回调函数获得的返回值为 reduce 方法的返回值。

回调函数的语法如下所示: function callbackfn(previousValue, currentValue, currentIndex, array1)

  • previousValue:通过上一次调用回调函数获得的值。如果向 reduce 方法提供 initialValue,则在首次调用函数时,previousValue 为 initialValue。
  • currentValue:当前数组元素的值。
  • currentIndex:当前数组元素的数字索引。
  • array1:包含该元素的数组对象。
var arr1 = [15.5, 2.3, 1.1, 4.7];
function funNum(f,v,i,a){
	return f+Math.round(v);
}
arr1.reduce(funNum,0)//24

取不到初始值,reduce方法会报错

function add(prev, cur) {
  return prev + cur;
}

[].reduce(add)
// TypeError: Reduce of empty array with no initial value
[].reduce(add, 1)
// 1

reduceRight()

reduceRight() 方法的功能和 reduce() 功能是一样的,不同的是 reduceRight() 从数组的末尾向前将数组中的数组项做累加,空数组是不会执行回调函数的

reverse()

用于颠倒数组中元素的顺序,如果数组是不连续的,则 reverse 方法将在数组中创建元素,这些元素将填充数组中的间隙。 所创建的这些元素的值具有值 undefined

语法

array.reverse()

var arr1= ["Banana", "Orange", "Apple", "Mango"];
arr1.reverse();
var arr2 = ['a',,'c','d'];
arr2.reverse();//["d", "c", empty, "a"]

shift()

把数组的第一个元素从其中删除,并返回第一个元素的值,如果数组是空的,那么 shift() 方法将不进行任何操作,返回 undefined 值

语法

array.shift()

unshift()

向数组的开头添加一个或更多元素,并返回新的长度

语法

array.unshift(item1,item2, ..., itemX)

var arr1= ["Banana", "Orange", "Apple", "Mango"];
arr1.unshift("Lemon","Pineapple");//6

slice()

方法可从已有的数组中返回选定的元素,返回一个新的数组,包含从 start 到 end (不包括该元素)的 arrayObject 中的元素。start 和end可以为负数

语法

array.slice(start, end)

splice()

向/从数组中添加/删除项目,然后返回被删除的项目,返回删除的数组元素,如果没删除,则返回空数组

语法

array.splice(index,howmany,item1,.....,itemX)

var arr1= ["Banana", "Orange", "Apple", "Mango"];
arr1.splice(2,0,"Lemon","Kiwi");
//["Banana", "Orange", "Lemon", "Kiwi", "Apple", "Mango"]

sort()

用于对数组的元素进行排序,默认排序顺序为按字母升序(字符编码的顺序进行排序),当数字是按字母顺序排列时"40"将排在"5"前面

语法

array.sort(sortfunction)

参数

  • sortfunction:可选。规定排序顺序。必须是函数。

sortfunction函数必须返回下列值之一

  • 如果所传递的第一个参数小于第二个参数,则返回负值。
  • 如果两个参数相等,则返回零。
  • 如果第一个参数大于第二个参数,则返回正值。

sortfunction(a,b)

如果a要在b前面 若 a 小于 b,则返回一个小于 0 的值。 若 a 等于 b,则返回 0。 若 a 大于 b,则返回一个大于 0 的值。

var arr1 = [23,12,1,34,116,8,18,37,56,50];
var arr2 = [23,12,1,34,116,8,18,37,56,50];
function upNum(a,b){
	//升序
	if(a>b){
		return 1
	}else if(a==b){
		return 0
	}else{
		return -1
	}
};
function downNum(a,b){
	//升序
	if(a>b){
		return -1
	}else if(a==b){
		return 0
	}else{
		return 1
	}
}
var b = arr1.sort(upNum);//[1, 8, 12, 18, 23, 34, 37, 50, 56, 116]
var c = arr2.sort(downNum);//[116, 56, 50, 37, 34, 23, 18, 12, 8, 1]

some()

检测数组中的元素是否有满足指定条件,如果有一个元素满足条件,则表达式返回true , 剩余的元素不会再执行检测,不会对空数组进行检测,返回值:布尔值。如果数组中有元素满足条件返回 true,否则返回 false

语法

array.some(function(currentValue,index,arr),thisValue)

参数

every() 方法的参数,略

some 方法可由具有 length 属性且具有已按数字编制索引的属性名的任何对象使用

toString()

可把数组转换为字符串,并返回结果。数组中的元素之间用逗号分隔。返回值与没有参数的 join() 方法返回的字符串相同

语法

array.toString()

var arr1= ["Banana", "Orange", "Apple", "Mango"];
arr1.toString();//"Banana,Orange,Apple,Mango"
var arr = [1, 2, 3];
arr.toString() // "1,2,3"

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

valueOf()

返回 Array 对象的原始值,原始值由 Array 对象派生的所有对象继承,valueOf() 方法通常由 JavaScript 在后台自动调用,并不显式地出现在代码中。

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

valueOf方法是一个所有对象都拥有的方法,表示对该对象求值。不同对象的valueOf方法不尽一致,数组的valueOf方法返回数组本身。

entries(), keys() 和 values()

用于遍历数组。它们都返回一个遍历器对象,可以用for...of循环进行遍历,唯一的区别是keys()是对键名的遍历、values()是对键值的遍历,entries()是对键值对的遍历

for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1
for (let elem of ['a', 'b'].values()) {
console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 "b"

var entries = ["a", "b", "c"].entries();
// entries.next().value == [0, "a"]
// entries.next().value == [1, "b"]
// entries.next().value == [2, "c"] 

  • 推荐在循环对象属性的时候,使用for...in,在遍历数组的时候的时候使用for...of
  • for...in循环出的是key,for...of循环出的是value
  • 注意,for...of是ES6新引入的特性。修复了ES5引入的for...in的不足
  • for...of不能循环普通的对象,需要通过和Object.keys()搭配使用

...(扩展运算符)

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

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

function push(array, ...items) {//参数里...是rect
  array.push(...items);
}
function add(x, y) {
  return x + y;
}
const numbers = [4, 38];
add(...numbers)//用在数组前面,就是扩展运算符

数组遍历方法对空缺的不同行为

一、ES5中

方法 针对空缺
forEach() 遍历时跳过空缺
every() 遍历时跳过空缺
some() 遍历时跳过空缺
map() 遍历时跳过空缺,但是最终结果会保留空缺
filter() 去除空缺
join() 把空缺,undefined,null转化为空字符串
toString() 把空缺,undefined,null转化为空字符串
sort() 排序时保留空缺
apply() 把每个空缺转化为undefined

二、ES6中

遍历时不跳过空缺,空缺都转化为undefined

方法 针对空缺
Array.from() 空缺都转化为undefined
...(扩展运算符) 空缺都转化为undefined
copyWithin() 连空缺一起复制
fill() 遍历时不跳过空缺,视空缺为正常的元素
for...of 遍历时不跳过空缺
entries() 空缺都转化为undefined
keys() 空缺都转化为undefined
values() 空缺都转化为undefined
find() 空缺都转化为undefined
findIndex() 空缺都转化为undefined p0p0
分类栏目
© 2018邮箱:11407215#qq.comGitHub沪ICP备12039518号-6