js-20170613-Array对象

1.Array.isArray()

 

Array.isArray方法用来判断一个值是否为数组。它可以弥补typeof运算符的不足。

 

2.Array实例的方法

 

valueOf()，toString()，push()，pop()，join()，concat()，shift()，unshift()，reverse()，slice()，splice()，sort()，map()，forEach()，filter()，some()，every()，reduce()，reduceRight()，indexOf()，lastIndexOf()

 

2.1 valueOf()，toString()

valueOf方法返回数组本身

toString方法返回数组的字符串形式。

var a = [1, 2, 3];

a.valueOf() // [1, 2, 3]

a.toString() // "1,2,3"

 

var a = [1, 2, 3, [4, 5, 6]];

a.toString() // "1,2,3,4,5,6"

2.2 push()

push方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。

var a = [];

a.push(1) // 1

a.push('a') // 2

a.push(true, {}) // 4

a // [1, 'a', true, {}]

合并两个数组

var a = [1, 2, 3];

var b = [4, 5, 6];

Array.prototype.push.apply(a, b)

// 或者

a.push.apply(a, b)

2.3 pop()

pop方法用于删除数组的最后一个元素，并返回该元素。注意，该方法会改变原数组。

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

a.pop() // 'c'

a // ['a', 'b']

[].pop() // undefined 空数组使用pop

2.4 join()

join方法以参数作为分隔符，将所有数组成员组成一个字符串返回。如果不提供参数，默认用逗号分隔。

var a = [1, 2, 3, 4];

a.join(' ') // '1 2 3 4'

a.join(' | ') // "1 | 2 | 3 | 4"

a.join() // "1,2,3,4"

 

[undefined, null].join('#') undefined null

// '#'

['a',, 'b'].join('-') 空位

// 'a--b'

 

通过call方法，这个方法也可以用于字符串。

Array.prototype.join.call('hello', '-')

// "h-e-l-l-o"

2.5 concat()

concat方法用于多个数组的合并。它将新数组的成员，添加到原数组的尾部，然后返回一个新数组，原数组不变。

['hello'].concat(['world'])

// ["hello", "world"]

 

['hello'].concat(['world'], ['!'])

// ["hello", "world", "!"]

除了接受数组作为参数，concat也可以接受其他类型的值作为参数。它们会作为新的元素，添加数组尾部。

[1, 2, 3].concat(4, 5, 6)

// [1, 2, 3, 4, 5, 6]

 

// 等同于

[1, 2, 3].concat(4, [5, 6])

[1, 2, 3].concat([4], [5, 6])

如果不提供参数，concat方法返回当前数组的一个浅拷贝。所谓“浅拷贝”，指的是如果数组成员包括复合类型的值（比如对象），则新数组拷贝的是该值的引用。

var obj = { a:1 };

var oldArray = [obj];

 

var newArray = oldArray.concat();

 

obj.a = 2;

newArray[0].a // 2

上面代码中，原数组包含一个对象，concat方法生成的新数组包含这个对象的引用。所以，改变原对象以后，新数组跟着改变。事实上，只要原数组的成员中包含对象，concat方法不管有没有参数，总是返回该对象的引用。

concat方法也可以用于将对象合并为数组，但是必须借助call方法

[].concat.call({a: 1}, {b: 2})

// [{ a: 1 }, { b: 2 }]

 

[].concat.call({a: 1}, [2])

// [{a: 1}, 2]

 

[2].concat({a: 1})

// [2, {a: 1}]

2.6 shift()

shift方法用于删除数组的第一个元素，并返回该元素。注意，该方法会改变原数组。

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

 

a.shift() // 'a'

a // ['b', 'c']

shift方法可以遍历并清空一个数组。

var list = [1, 2, 3, 4, 5, 6];

var item;

 

while (item = list.shift()) {

console.log(item);

}

 

list // []

2.7 unshift()

unshift方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。

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

 

a.unshift('x'); // 4

a // ['x', 'a', 'b', 'c']

2.8 reverse()

reverse方法用于颠倒数组中元素的顺序，返回改变后的数组。注意，该方法将改变原数组。

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

 

a.reverse() // ["c", "b", "a"]

a // ["c", "b", "a"]

2.9 slice()

slice方法用于提取原数组的一部分，返回一个新数组，原数组不变。

它的第一个参数为起始位置（从0开始），第二个参数为终止位置（但该位置的元素本身不包括在内）。如果省略第二个参数，则一直返回到原数组的最后一个成员。

2.10 splice()

splice方法用于删除原数组的一部分成员，并可以在被删除的位置添加入新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。

splice的第一个参数是删除的起始位置，第二个参数是被删除的元素个数。如果后面还有更多的参数，则表示这些就是要被插入数组的新元素。

// 格式

arr.splice(index, count_to_remove, addElement1, addElement2, ...);

 

// 用法

var a = ['a', 'b', 'c', 'd', 'e', 'f'];

a.splice(4, 2) // ["e", "f"]

a // ["a", "b", "c", "d"]

2.11 sort()

sort方法对数组成员进行排序，默认是按照字典顺序排序。排序后，原数组将被改变。

['d', 'c', 'b', 'a'].sort()

// ['a', 'b', 'c', 'd']

 

[4, 3, 2, 1].sort()

// [1, 2, 3, 4]

 

[11, 101].sort()

// [101, 11]

 

[10111, 1101, 111].sort()

// [10111, 1101, 111]

数字排序

[10111, 1101, 111].sort(function (a, b) {

return a - b;

})

// [111, 1101, 10111]

 

[

{ name: "张三", age: 30 },

{ name: "李四", age: 24 },

{ name: "王五", age: 28 }

].sort(function (o1, o2) {

return o1.age - o2.age;

})

// [

// { name: "李四", age: 24 },

// { name: "王五", age: 28 },

// { name: "张三", age: 30 }

// ]

2.12 map()

map方法对数组的所有成员依次调用一个函数，根据函数结果返回一个新数组。

var numbers = [1, 2, 3];

 

numbers.map(function (item) {

return item + 1;

});

// [2, 3, 4]

 

numbers

// [1, 2, 3]

map方法接受一个函数作为参数。该函数调用时，map方法会将其传入三个参数，分别是当前成员、当前位置和数组本身。

2.13 forEach()

forEach方法与map方法很相似，也是遍历数组的所有成员，执行某种操作，但是forEach方法一般不返回值，只用来操作数据。如果需要有返回值，一般使用map方法。

forEach方法的参数与map方法一致，也是一个函数，数组的所有成员会依次执行该函数。它接受三个参数，分别是当前位置的值、当前位置的编号和整个数组。

function log(element, index, array) {

console.log('[' + index + '] = ' + element);

}

 

[2, 5, 9].forEach(log);

// [0] = 2

// [1] = 5

// [2] = 9

上面代码中，forEach遍历数组不是为了得到返回值，而是为了在屏幕输出内容，所以应该使用forEach方法，而不是map方法，虽然后者也可以实现同样目的。

forEach方法也可以接受第二个参数，用来绑定回调函数的this关键字。

var out = [];

 

[1, 2, 3].forEach(function(elem) {

this.push(elem * elem);

}, out);

 

out // [1, 4, 9]

上面代码中，空数组out是forEach方法的第二个参数，结果，回调函数内部的this关键字就指向out。这个参数对于多层this非常有用，因为多层this通常指向是不一致的。

2.14 filter()

filter方法的参数是一个函数，所有数组成员依次执行该函数，返回结果为true的成员组成一个新数组返回。该方法不会改变原数组。

[1, 2, 3, 4, 5].filter(function (elem) {

return (elem > 3);

})

// [4, 5]

2.15 some()、every()

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

 

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

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

对于空数组，some方法返回false，every方法返回true，回调函数都不会执行。

var arr = [1, 2, 3, 4, 5];

arr.some(function (elem, index, arr) {

return elem >= 3;

});

// true

 

var arr = [1, 2, 3, 4, 5];

arr.every(function (elem, index, arr) {

return elem >= 3;

});

// false

2.16 reduce()、reduceRight()

reduce方法和reduceRight方法依次处理数组的每个成员，最终累计为一个值。

它们的差别是，reduce是从左到右处理（从第一个成员到最后一个成员），reduceRight则是从右到左（从最后一个成员到第一个成员），其他完全一样。

这两个方法的第一个参数都是一个函数。该函数接受以下四个参数。

这四个参数之中，只有前两个是必须的，后两个则是可选的。

[1, 2, 3, 4, 5].reduce(function(x, y){

console.log(x, y)

return x + y;

});

// 1 2

// 3 3

// 6 4

// 10 5

//最后结果：15

2.17 indexOf()、lastIndexOf()

indexOf方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。

indexOf方法还可以接受第二个参数，表示搜索的开始位置。

lastIndexOf方法返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1。

转载于:https://www.cnblogs.com/jialuchun/p/7283485.html