Array

写之前巩固一下JS的七种数据类型:number, string, boolean, null, undefined, symbol, object,

由此可见, Array属于object.

Array是JS的原生对象, 同时也是一个构造函数.

构造函数

var arr = new Array(2); // 生成一个两个成员的数组,每个位置都是空值
//等同于
var arr = Array(2);

Array构造函数有个很大的缺陷, 就是不同的参数, 会导致不一致性,比如:

var arr = new Array(2); // 第一个参数2代表数组的length

var arr = new Array(2,2); // 第一个参数2代表数组的第一个元素

var arr = new Array(); // 返回一个空数组

var arr = new Array('abc'); // 返回一个数组['abc']

因此,通常创建数组的时候,不建议使用构造函数创建, 使用数组字面量最好:

var arr = [1,2];

遍历

// 下面是两个数组 arr 和 obj

var arr = [1,2]; // 内存中 __proto__, 指向的是Array.prototype
var obj = {0:1, 1:2, 'length':2}; // 内存中 __proto__, 指向的是Object.prototype

// 遍历arr
for(let i = 0; i < arr.length; i++){
    console.log(i, arr[i])
}
// 0 1
// 1 2

// 遍历obj
for(let i = 0; i < obj.length; i++){
    console.log(i, obj[i])
}
// 0 1
// 1 2

obj.xxx = 'xxx';
// 得到obj为
obj = {0:1, 1:2, 'length':2, xxx:"xxx"}

// 再次遍历obj得到
// 0 1
// 1 2

// 换一种方法遍历
for(let key in obj){
    console.log(key, obj[key])
}
// 0 1
// 1 2
// 2 3
// length 3
// xxx xxx

由上面的例子可以总计出:

所以遍历是是遍历, 和是不是数组无关, 有关的是有没有下标.
数组之所以为数组, 是因为你觉得他是数组, 觉得是数组就使用for(let i = 0;i<obj.length;i++)进行遍历, 觉得不是就使用for(let key in obj)遍历.
数组本质: ____proto____(原型)指向了Array.prototype.

静态方法

Array.isArray 方法返回一个bool值, 表示参数是否为数组.

var arr = [1,2,3];

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

实例方法

讲实例方法之前,先看下Array创建之后的内存图:

image

valueOf(), toString()

所有对象都拥有的两个公用方法.

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

arr.toString(); // "1,2,3"

push(), pop()

push向数组添加一个或者元素, pop删除数组的最后一个元素, 两个方法都会改变原数组

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

arr.push(1)
arr.push('d')
arr.push(true)

arr // ['a', 'b', 'c', 1, 'd', true]

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

push和pop结合使用, 构成了后进先出的stack结构.

shift(), unshift()

shift删除数组的第一个元素, unshift在数组第一个位置添加元素, 两个方法都会改变原数组

var arr = ['a', 'b', 'c'];
a.shift() // ['b', 'c']
// 使用shift可以清空一个数组

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

shift和unshift结合使用, 构成了先进先出的queue结构.

join()

join数组元素之间用指定参数作为分隔符拼接

var arr = [1,2,3];
arr.join(',') // "1,2,3"
arr.join() // "1,2,3" 不加参数,默认用逗号拼接

arr.toString(arr) // "1,2,3" 与join不同, 只是巧合

arr + "" // "1,2,3" 与join不同, 只是巧合

concat()

concat拼接两个数组,生成一个新数组, 原数组不变

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

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

a.concat([]) // [1,2,3]
a.concat([]) !== a

reverse()

reverse颠倒排列数组元素 , 改变原数组

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

sort()

sort对数组成员进行排序, 快速排序方法, 需要接受一个函数, 函数返回排序依据, 改变原数组

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

a.sort(function(x,y){ return x-y }) // [1,2,3,5,6] 如果函数返回值小于等于0, 第一个元素排在第二个元素前面
a.sort(function(x,y){ return y-x }) // [6,5,3,2,1] 如果该函数的返回值大于0，表示第一个成员排在第二个成员后面

var students = ['小明','小红','小花'] ;
var scores = { 小明: 59, 小红: 99, 小花: 80 };
students.sort(function(x,y){
    return scores[x] - scores[y]
})

map()

map将所有元素依次传入参数函数, 并将每一次的执行结果组成一个新数组返回, 不改变原数组.

var a = [1, 2, 3];
a.map(function(n){
    return n + 1''
}) // [2, 3, 4]

forEach()

forEach和map方法相似, 也是对数组的所有成员依次执行参数函数, 但是forEach不会有返回值,只用来操作数据.

// forEach 有三个参数, 通常只写两个参数
1. 当前值
2. 当前位置
3. 数组本身

var out = [];
[1, 2, 3].forEach(function(elem) {
  this.push(elem * elem);
}, out); // 其中this 就是[1,2,3], 第一个参数是一个函数, 第二个参数是空数组out, 回调函数内部的this指向了out

out // [1, 4, 9]

filter()

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

var a = [1,2,3,4,5,6];
a.filter(function(value){
    return value % 2 === 0
})
// [2,4,6]
a.filter(function(value,index){
    return index % 2 !== 0
})
// [1,3,5]

reduce()

reduce方法依次处理数组的每个成员，最终累计为一个值.下面是四个参数:

累积变量，默认为数组的第一个成员
当前变量，默认为数组的第二个成员
当前位置（从0开始）(可选)
原数组 (可选)

var a = [1,2,3,4,5];
a.reduce(function(a,b){
    console.log(a,b);
    return a+b;
})
// 15

使用reduce表示map

var a = [1,2,3];
a.reduce(function(arr,n){
    arr.push(n*2);
    return arr;
},[])
// [2,4,6]

使用reduce表示filter

var a = [1,2,3,4,5,6];
a.reduce(function(arr,n){
    if(n % 2 === 0){
        arr.push(n)
    }
    return arr
}, [])
// [2, 4, 6]

JS里的Array

JS里的Array

Array

构造函数

遍历

静态方法

实例方法

推荐阅读更多精彩内容