关于javascript: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() 迭代方向相同。