JS里的数组

什么是数组（Array）

用来存储一组相关的值，从而方便进行求和、计算平均数、逐项遍历等操作

定义数组的方法

• 使用方括号"[ ]"

var arr = ['A', 'B', 'C', 'D']

• 使用内置构造函数

var arr = new Array('A', 'B', 'C', 'D');
// 表示定义了一个长度为4的数组。但，这4项都是undefined
var arr = new Array(4);

访问数组项

数组每一项都有下标，下标从0开始

console.log(arr[0]);  // A
console.log(arr[1]);  // B
console.log(arr[2]);  // C
console.log(arr[3]);  // D

访问数组中不存在的项会返回undefined，不会报错

console.log(arr[1000]);  // undefined
console.log(arr[-1]);  // undefined

更改数组项

数组并不是只读的，我们可以修改它其中的任何项的值

 var arr = [2,6,7,9];
 arr[1] = 0;
 arr[2] ++;
 console.log(arr);

如果更改的数组项超过了length-1，则会创造这一项

var arr = [2, 6, 7, 9];        
arr[6] = 4;
console.log(arr);
// 输出时：(7) [2, 0, 8, 9, empty × 2, 4]
Array(7)
0: 2
1: 0
2: 8
3: 9
6: 4
length: 7

数组类型的检测

数组用typeof检测结果是object，会造成一个误会：不知道是否是真的对象，还是数组；

使用Array.isArray()方法可以用来检测是否为数组；

数组的头尾操作

方法	功能
push()	在尾部插入新项
pop()	在尾部删除
unshift()	在头部插入新项
shift()	在头部删除

push()方法

用来在数组末尾推入新项，参数就是要推入的项；如果要推入多项，可以用逗号隔开；调用push()方法后，数组会立即改变，不需要赋值

var arr = [22,33 ,4];
// 方法就是打点调用的函数，所以是数组打点调用它们
arr.push(55,66);
console.log(arr);  // (5) [22, 33, 4, 55, 66]

pop()方法

用来删除数组中的最后一项，而且会返回被删除的项

var arr = [22,33 ,4];
// 方法就是打点调用的函数，所以是数组打点调用它们
arr.push(55,66);
arr.pop();
console.log(arr);  // (4) [22, 33, 4, 55]
var item = arr.pop();
console.log(arr);  // (3) [22, 33, 4]
console.log(item);  // 55

unshift()方法

用来在数组头插入新项，参数就是要插入的项；如果要推入多项，可以用逗号隔开；调用unshift()方法后，数组会立即改变，不需要赋值

shift()方法

用来删除数组中下标为0的项；而且会返回被删除的项

splice()方法

• 用于替换数组中的指定项

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr.splice(3,2,'X', 'Y', 'Z');
console.log(arr);  // (8) ['A', 'B', 'C', 'X', 'Y', 'Z', 'F', 'G']

• 用于在指定位置插入新项

var arr = ['A', 'B', 'C', 'D'];
arr.splice(3,0,'X', 'Y', 'Z');
console.log(arr);  // (7) ['A', 'B', 'C', 'X', 'Y', 'Z', 'D']

• 用于删除指定项

var arr3 = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
arr3.splice(3,2);
console.log(arr3);  // (5) ['A', 'B', 'C', 'F', 'G']

• 会以数组形式返回被删除的项

var arr4 = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var items = arr4.splice(2,4);
console.log(arr4);  // (3) ['A', 'B', 'G']
console.log(items);  // (4) ['C', 'D', 'E', 'F']

slice()方法

• 用于得到子数组，类似于字符串的slice()方法；
• slice(a, b)截取的子数组从下标为a的项开始，到下标为b（但不包括下标为b的项）结束；
• slice(a, b)方法不会更改原有数组；
• slice()如果不提供第二个参数，则表示从指定项开始，提取所有后续所有项作为子数组；

var arr = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
var child_arr1 = arr.slice(2, 5);
var child_arr2 = arr.slice(2);
var child_arr3 = arr.slice(2, -1);
console.log(arr);  // (7) ['A', 'B', 'C', 'D', 'E', 'F', 'G']
console.log(child_arr1);  // (3) ['C', 'D', 'E']
console.log(child_arr2);  // (5) ['C', 'D', 'E', 'F', 'G']
console.log(child_arr3);  // (4) ['C', 'D', 'E', 'F']

join()方法和split()方法

• 数组的join()方法可以使数组转为字符串；字符串的split()方法可以使字符串转为数组；
• join()的参数表示以什么字符作为连接符，如果留空则默认以逗号分隔，如同调用toString()方法；split()的参数表示以什么字符拆分字符串，一般不能留空

['C', 'D', 'E', 'F'].join()
// 'C,D,E,F'
['C', 'D', 'E', 'F'].join(';;')
// 'C;;D;;E;;F'
'dghcghccf'.split('')
// (9) ['d', 'g', 'h', 'c', 'g', 'h', 'c', 'c', 'f']
'dghcghccf'.split()
// ['dghcghccf']
'a-b-c-d-e'.split('-')
// (5) ['a', 'b', 'c', 'd', 'e']

• 字符串也可以使用方括号内写下标的形式，访问某个字符，等价于charAt()方法；

'房间打扫'[0]
// '房'
'房间打扫'[2]
// '打'

concat()方法

可以合并连结多个数组；但，不会改变原数组；

var arr1 = [1, 2, 3, 4];
var arr2 = [5, 6, 7, 8];
var arr3 = [9, 10, 11];
var arr = arr1.concat(arr2, arr3);
console.log(arr);  // (11) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

reverse()方法

用来将一个数组中的全部项顺序置反；

var arr = ["A", "B", "C", "D"];
arr.reverse();
console.log(arr);  // (4) ['D', 'C', 'B', 'A']

indexOf()方法和includes()方法

indexOf()方法是搜索数组中的元素，并返回它所在是位置，如果元素不存在，则返回-1；

includes()方法是判断一个数组是否包含一个指定的值，返回布尔值

 ["A", "B", "C", "D"].indexOf('C')
// 2
 ["A", "B", "C", "D"].indexOf('M')
// -1
 ["A", "B", "C", "D"].includes('C')
// true
 ["A", "B", "C", "D"].includes('M')
// false

二维数组

以数组作为数组元素的数组，即“数组的数组”；可以看作是矩阵；

var matrix = [
    [1, 5, 6],
    [8, 9, 2],
    [55, 66, 22],
    [31, 25, 5]
];
console.log(matrix.length);  // 4
// 循环输出二维数组中的每一个项
for(var i = 0; i<4;i++){
    for(var j=0;j<3;j++){
        console.log(matrix[i][j]);
    }
}

基本类型和引用类型

基本类型：

• number、boolean、string、undefined、null
• 当var a = b 变量传值时，在内存中会产生新的地址副本
• 进行相等判断时，会比较值是否相等

引用类型：

• array（数组）、object（对象）、function（函数）、regexp（正则表达式）...
• 当var a = b 变量传值时，在内存中不会产生新的地址副本，而是让新变量指向同一个地址对象；
• 进行相等判断时，会比较地址是否相等，也就是说，它会比较是否为内存中的同一个东西；

[]==[]
// false
3==3
// true
[1,2,3]==[1,2,3]
// false

深克隆和浅克隆

浅克隆：只克隆数组的第一层，如果是多维数组，或者数组中的项是其他引用类型值，则不克隆其他层；

深克隆：克隆数组的所有层，使用递归技术

var arr1 = [1, 2, 3];
// 不会产生克隆
var arr2 = arr1;

// 结果数组
var result_arr = []
// 遍历原数组中的每一项，把遍历到的项推入到结果数组中
for (var i = 0; i < arr1.length; i++) {
    result_arr.push(arr1[i]);
}
console.log(result_arr);  // (4) [1, 2, 3, Array(2)]
console.log(result_arr == arr1); // false, 因为引用类型值进行比较的时候，==比较的是内存地址
arr1.push[4];
console.log(result_arr);  // (4) [1, 2, 3, Array(2)]
console.log(result_arr[3] == arr1[3]);  // true, 引用类型值不会进行赋值