javascript常用内置对象方法（Array篇）

数组Array对象

静态方法

Array.isArray()

用途：判断参数是否为数组
返回值：一个布尔值

var arr = [1, 2, 3]
typeof arr //"object"
Array.isArray(arr) //true

实例方法

对象通用方法：vauleOf(),toString()

valueOf方法返回数组本身
toString()方法返回数组的字符串形式

push()

用途：在数组末端添加一个或多个元素
返回值：添加新元素后的数组长度

var arr = []
arr.push(1) //1
arr.push('a') //2
arr.push(true, {}) //4
arr //[1, 'a', true, {}]

pop()

用途：删除数组最后一个元素
返回值：被删除的元素

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

arr.pop() // 'c'
arr // ['a', 'b']

对空数组使用pop方法，不会报错，而是返回undefined。[].pop() // undefined
push和pop结合使用，就构成了“后进先出”的栈结构（stack）。\

unshift()

用途：在数组的第一个位置添加元素（与push()类似）
返回值：添加新元素后的数组长度

var arr = [ 'c', 'd' ];
arr.unshift('a', 'b') // 4
arr // [ 'a', 'b', 'c', 'd' ]

shift()

用途：删除数组第一个元素（与pop()类似）
返回值：被删除的元素

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

a.shift() // 'a'
a // ['b', 'c']

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或空位，会被转成空字符串。

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

['a',, 'b'].join('-')
// 'a--b'

concat()

用途：在原数组的后边合并其他对象
返回值：合并后的新数组
参数：要合并的值，可以是数组，对象（浅拷贝合并），数字等

['hello'].concat(['world'])
// ["hello", "world"]

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

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

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

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

reverse()

用途：颠倒排列数组元素
返回值：改变后的数组（改变原数组）

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

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

slice(start, end)

用途：提取原数组的一部分
返回值：一个新数组（不改变原数组）
参数：start为起始索引值（从0开始，会包含到新数组中）；end为终止索引（不包含在内，可省略）

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

a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice(2, 6) // ["c"]
a.slice() // ["a", "b", "c"]

如果slice()方法的参数是负数，则表示倒数计算的位置。

splice(start, count, addElement1,addElement2…)

用途：删除，替换，增加原数组的内容
返回值：被删除的元素（改变原数组）
参数：start为起始索引，count为要删除的元素个数，其余的为要插入数组的新元素，从start位置开始插入

var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2) // ["e", "f"]
a // ["a", "b", "c", "d"]
a.splice(4, 2, 1, 2) // ["e", "f"]
a // ["a", "b", "c", "d", 1, 2]

sort()

用途：对数组成员进行排序（按照字典顺序排序而不是大小，如果是数组，先转换成字符串再比较）
返回值：一个排序后的新数组（改变原数组）
参数：一个接受两个参数的函数，表示进行比较的两个数组成员。如果该函数返回值大于0，表示第一个成员排在第二个成员后面

['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 }
// ]
//ES6 箭头函数写法
[1, 4, 2, 6, 0, 6, 2, 6].sort((a, b) => a - b)

map（）

用途：将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回（简单来说就是将数组里的值进行加工)
返回值：一个新数组，原数组没有变化
参数：（当前成员，当前位置，整个数组）

var numbers = [1, 2, 3];

numbers.map(function (n) {
  return n + 1;
});
// [2, 3, 4]

numbers
// [1, 2, 3]

//map方法接受一个函数作为参数。该函数调用时，map方法向它传入三个参数：当前成员、当前位置和数组本身。
[1, 2, 3].map(function(elem, index, arr) {
  return elem * index;
});
// [0, 2, 6]

forEach（）

用途：forEach与map方法很相似，但是forEach不返回值，只用来操作数据
返回值：无
参数：（当前成员，当前位置，整个数组）

function log(element, index, array) {
  console.log('[' + index + '] = ' + element);
}

[2, 5, 9].forEach(log);
// [0] = 2
// [1] = 5
// [2] = 9

//如果想中途中断forEach需要用for循环添加条件

filter（）

用途：用于过滤数组成员，满足条件的成员组成一个新数组返回
返回值：一个满足过滤条件的新数组，不改变原来数组
参数：（当前成员，当前位置，整个数组）

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

some（）, every（）

用途：这两个方法都是用来判断数组成员是否符合某个条件
返回值：布尔值
区别：some方法是只有一个成员返回值是true则整个some方法返回true，而every只有所有成员都返回true，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

reduce(), reduceRight()

用途：这两个方法都是依次处理数组每个成员，最终累计为一个值
返回值：一个值
参数：1累积变量，默认为数组的第一个成员
2当前变量，默认为数组的第二个成员
3当前位置（从0开始）
4原数组
区别：reduce()是从左到右处理，reduceRight则是从右向左处理

[1, 2, 3, 4, 5].reduce(function (a, b) {
  console.log(a, b);
  return a + b;
})
// 1 2
// 3 3
// 6 4
// 10 5
//最后结果：15

indexOf()，lastIndexOf()

用途：返回给定元素在数组中出现的位置
返回值：找到返回该值的索引下标，没找到返回-1
参数：1.给定的元素，2.搜索开始位置的数组索引
区别：indexOf()返回第一次出现的位置，lastIndexOf()返回最后一次出现的位置

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

a.indexOf('b') // 1
a.indexOf('y') // -1
//给定开始位置
['a', 'b', 'c'].indexOf('a', 1) // -1
var a = [2, 5, 9, 2];
a.lastIndexOf(2) // 3
a.lastIndexOf(7) // -1

链式使用

上面这些数组方法之中，有不少返回的还是数组，所以可以链式使用。

var users = [
  {name: 'tom', email: 'tom@example.com'},
  {name: 'peter', email: 'peter@example.com'}
];

users
.map(function (user) {
  return user.email;
})
.filter(function (email) {
  return /^t/.test(email);
})
.forEach(function (email) {
  console.log(email);
});