javascript 数组

1.声明

var arr = [1, 2];

2.判断是否为数组

var arr = [1, 2];


typeof arr // "object"
Array.isArray(arr) // true

3.字符串化

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


var arr = [1, 2];
arr.join();//"1, 2"可传参数，默认用逗号分隔
arr.join("|");//"1|2"


//字符串或类似数组的对象可以同过call方法
Array.prototype.join.call('hello World', '-')
// "h-e-l-l-o- -W-o-r-l-d"

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

4.添加、删除（原数组将被改变）

var arr = [1,2];
arr.push(3);//在数组的末端添加一个或多个元素

arr;//[1, 2, 3]

//push和pop结合使用，就构成了“后进先出”的栈结构（stack）
arr.pop();//删除数组的最后一个元素，并返回该元素
arr;//[1, 2, 3]

//push()和shift()结合使用，就构成了“先进先出”的队列结构（queue）
arr.shift();//删除数组的第一个元素，并返回该元素
arr;//[2]

arr.unshift('a', 'b');//在数组的第一个位置添加元素
arr;//['a','b',2]

5.合并（返回一个新数组，原数组不变）

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

6.颠倒（原数组将被改变）

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

7.截取(arr.slice(start, end))（返回一个新数组，原数组不变）

var arr=[1,2,3];
a.slice(1, 2)// ["2"]
a.slice(1)// ["2","3"]
a.slice(-2) // ["2","3"]
a.slice()//[1,2,3]


//将类似数组的对象转为真正的数组
Array.prototype.slice.call({ 0: 'a', 1: 'b', 2: 'c', length: 3 })
// ['a', 'b']

8.指定位置删除（arr.splice(start, count, addElement1, addElement2, ...)）（原数组将被改变）

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

arr.splice(4, 2, 1, 2) // ["e", "f"]
arr // ["a", "b", "c", "d", 1, 2]

//单纯的插入元素
var arr = [1, 1, 1];
arr.splice(1, 0, 2) // []
arr // [1, 2, 1, 1]

//数组拆分
var arr = [1, 2, 3, 4];
arr.splice(2) // [3, 4]
arr // [1, 2]

9.排序（原数组将被改变）

[10111, 1101, 111].sort()//默认是按照字典顺序排序
// [10111, 1101, 111]

[10111, 1101, 111].sort(function (a, b) {//自定义排序
  return a - b;
})
// [111, 1101, 10111]

10.map循环（返回一个新数组，原数组不变）

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

//多参数
var arr = ['a', 'b', 'c'];

[1, 2].map(function (e) {
  return this[e];
}, arr)
// ['b', 'c']

11.forEach()（只循环，无返回值）

//除了没有返回值，其他和map类似
function log(element, index, array) {
  console.log('[' + index + '] = ' + element);
}

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

//多参数
var out = [];

[1, 2, 3, 4].forEach(function(elem) {
  this.push(elem * elem);
}, out);

out // [1, 4, 9, 16]

12.filter()过滤（不会改变原数组）

数组形式返回符合要求的数据

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


var arr = [0, 1, false, null, undefined, ''];

arr.filter(Boolean)
// [1]


//多参数(this指向第二个参数)
var obj = { MAX: 3 };
var myFilter = function (item, index, arr) {
  if (item > this.MAX*index) return true;
};

var arr = [2, 8, 3, 4, 1, 3, 2, 9];
arr.filter(myFilter, obj) // [2,8]

13.some()，every()（类似“断言”（assert））

some()只要一个成员满足条件就返回true,every()相反，所以成员满足条件才返回true

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

arr.every(function (elem, index, arr) {
  return elem >= 3;
});
// false

14.reduce()，reduceRight()

依次处理数组的每个成员，最终累计为一个值，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

//可设初始值
[1, 2, 3, 4, 5].reduce(function (a, b) {
  return a + b;
}, 10);
// 25

15.indexOf()，lastIndexOf()（是否包含）

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

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

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

a.indexOf('3') // 2

//多参数(开始搜索的位置)
a.indexOf('3',1)// 2