javaScript数据类型--Array

1. 数组的定义

在js中，数组也是对象（引用数据类型）。
可理解为一组数据的集合。

2. 数组的特点

数组的每一项可保存任何类型的数据。

3. 创建数组的基本方式（2种）

3.1 构造函数new Array()

/**** 可省略关键字new ****/
let list0 = Array();

let list1 = new Array();

/**** 创建数组时指定数组的长度 ****/
/**** 此时数组list2的长度为10, 其中数组每一项为undefined。****/
let list2 = new Array(10);

3.2 字面量表示法

let list = ['red',1, true,null,undefined,'pink'];

let list = []; // 创建一个空数组,数组长度为0。

let dates = ['1-10','1-11', , ,]; // 数组长度为4, dates[2] dates[3] 的值为undefined
console.log(dates); // ["1-10", "1-11", empty × 2]

4. 通过索引访问数组中的值

/**** 通过索引修改相对应的值 ****/
let students = ['小明', '小花', '小李']
students[1] = '小花的姐姐';
console.log(students); // ["小明", "小花的姐姐", "小李"]

/**** 如果访问的下标（索引）超出了数组的长度,值为undefined ****/
console.log(students[5]); // undefined
 
/**** 如果设置某个值的索引超过数组长度,那么 数组的将会自动增加到该索引加1的长度 ****/
students[5] = '刘老师';
console.log(students); // ["小明", "小花", "小李", empty × 2, "刘老师"]

/**** 数组最后一项的索引等于length - 1 ****/
/**** 反过来,数组的长度等于 数组最后一项的索引 加 1 ****/
let nums = [1,2,8,4];
console.log(nums[nums.length - 1]); // 4

数组最多可以包含42 9496 7295项。

5. 检测数组的方法

5.1 Array.isArray(variable )

let list = ['a','b'];
let p = {
    title:'this is obejct'
}

console.log(Array.isArray(list)); // true
console.log(Array.isArray(p));  // false

5.2 variable instanceof Array

该方法仅针对一个全局执行环境而言。

console.log(list instanceof Array); // true
console.log(p instanceof Array); // false

5.3 Object.prototype.toString.call(variable)

console.log(Object.prototype.toString.call(list));  // '[object Array]'
console.log(Object.prototype.toString.call(p)); // '[object Object]'

5.4 variable.constructor === Array

console.log(list.constructor === Array); // true
console.log(p.constructor === Array); // false
console.log(p.constructor === Object); // true

6. 数组的常用方法

1 push()

在数组末尾增加（一个或多个数据）

2 pop()

删除数组末尾的一个数据

3 unshift()

在数组开头增加（一个或多个数据）

4 shift()

删除数组的第一项 并 返回该项。

5 reverse()

反转数组的顺序。
返回排序之后的数组。

6 sort()

sort方法调用每个数组项的toString()方法，然后比较得到的字符串。
返回排序之后的数组。

let numbers1 = [1,5,2,3];
console.log(numbers1.sort()); // [1, 2, 3, 5]

let numbers2 = [10,5,12,13];
console.log(numbers2.sort());   // [10, 12, 13, 5]

/******** 可在sort()方法中使用比较进行排序 ******/
let numbers3 = numbers2.sort((a,b) => {
    return a - b; // 如果是b - a 则结果会反过来
}) 

等同于 =>

numbers2.sort((a,b) => {
    return a - b;
})

console.log(numbers2) // [5, 10, 12, 13]
console.log(numbers3); // [5, 10, 12, 13]

7 concat()

该方法创建当前数组的一个副本, 然后将参数逐个添加到副本的末尾, 最后返回副本。

let numArray = ['one','two'];
let list = numArray.concat('three',['6-1','6-2']);

console.log(list);// ["one", "two", "three", "6-1", "6-2"] 
console.log(numArray); // ["one", "two"]

8 slice()

不影响原始数组。

let fruit = ['apple', 'banana', 'strawberry', 'pears'];

/************ 一个参数:截取从指定位置开始 到 数组末尾所有项 ************/
fruit.slice(1); // "banana", "strawberry", "pears"]

/************ 两个参数:截取起始位置和结束位置之间的项，但不包括结束位置 ************/
fruit.slice(0,2); //  ["apple", "banana"]

如果slice方法中是一组负数，则用数组的长度加上该负数来确定位置：
例如数组长度为5, 那么slice(-2,-1) 等同于 slice(3,4)。

9 splice()

let numbers = ['1','3','5','7','9'];

/**
 *删除: 删除任意数量的项
 * @params 第一个参数 起始位置
 * @params 第二个参数 结束位置（但不包括结束位置）
 * /
 * 
numbers.splice(1,2)  //  ["3", "5"]


/**
 * 插入: 向指定位置插入任意数量的项
 * @params 第一个参数 起始位置
 * @params 第二个参数 要删除的项数
 * @params 第三个参数 要插入的项（可以多个）
 * /

numbers.splice(2,0,'red','pink')
console.log(numbers); ["1", "3", "red", "pink", "5", "7", "9"]
console.log(numbers); //  ["1", "7", "9"]


/**
 * 替换: 向指定位置插入任意数量的项, 并且同时删除任意数量的项
 * @params 第一个参数 起始位置
 * @params 第二个参数 要删除的项数
 * @params 第三个参数 要插入的任意数量项
 * /

numbers.splice(1,1,'替换的值')
console.log(numbers); // ["1", "替换的值", "5", "7", "9"]

10 indexOf()

默认从索引0开始向后查找，找到了返回正确的索引,否则返回-1。

let list = ['13','red','null',20,-3];

console.log(list.indexOf('null')); // 2
console.log(list.indexOf(-3)); // 4
console.log(list.indexOf(10)); // -1

/**
 * 从指定位置开始查找
 * @params 第一个参数 查找到项
 * @params 第二个参数 查找的起始位置
 * /
console.log(list.indexOf('null',3)); // -1
console.log(list.indexOf('null',1)); // 2

11 lastIndexOf()

与indexOf()方法查找方向相反。

12 every()

返回布尔值。
对原始数组无影响。

let grades = [50,60,75,80,93];
 
let result1 = grades.every((item,index,array) => {
    return item >= 60;
});
console.log(result1); // false

let result2 = grades.every((item,index,array) => {
    return item >= 30;
});
console.log(result2); // true

13 filter()

筛选出符合指定条件的项。
对原始数组无影响。

let grades = [50,60,75,80,93];
let list =  grades.filter((item,index,array) => {
    return item >= 60;
});
console.log(list); // [60, 75, 80, 93]

13 forEach()

该方法无返回值。
对原始数组无影响。

let k = [1,2,3];
let j = [];

k.forEach((item,index,array) => {
     j.push(item * 2);
});

console.log(k); // [1,2,3]
console.log(j); // [2, 4, 6]

14 map()

对原始数组无影响。

let n = [5,10,20];
let v = n.map((item,index,array) => {
    return item * 2;
});

console.log(n); // [5, 10, 20]
console.log(v); // [10, 20, 40]

15 some()

返回布尔值。
对原始数组无影响。
只要有任一项满足条件就返回true,否则返回false, 与方法every( ) 相反。

let o = [1,2,12,16,18];
let result1 = o.some(item => {
     return item > 20;
});
console.log(result1); // false

let result2 = o.some(item => {
     return item > 10;
});
console.log(result2); // true

16 reduce()

该方法迭代数组所有项。
对原始数组无影响。

// 求数组中每一项加起来的总和
let u = [1,2,3,4,5];
let values = u.reduce((pre,cur,index,array) => {
    return pre + cur;
});
 
console.log(values);  // 15

17 reduceRight()

该方法迭代数组所有项。
与方法reduce()迭代方向相反。