数组

数组用于存放多个数据

数组是一个非常重要的知识,在日后的业务开发中，会像呼吸一样，一直在使用。

创建一个数组

new Array(长度)

长度，数组里面的数据总数，长度一定是一个非负整数

new Array(数据, 数据, 数据....)

创建一个数组，并初始化其每一项的值

数组项：数组其中的一项数据

[数据,数据,数据,....]

创建一个数据，并初始化其每一项的值

var arr = new Array(5); //构造函数方式创建
var arr = [1, 2, 3, 4, 5]; //字面量方式创建

认识数组的本质

数组的本质是一个对象

length属性：数组的长度，会自动变化，值为最大下标+1
数字字符串属性：叫做下标，也叫做索引，相当于数组中每个数据的编号，下标从0开始排列

连续下标的取值范围：0 ~ length -1，如果给length直接赋值，会导致数组可能被截断

实际开发中，不要给length赋值。

// 相当于
var arr = {
  0: 1,
  1: 2,
  length: 2,
  //其他属性xxx
};

下标

通常情况下，下标是连续的。

下标不连续的数组，叫做稀松数组。

数组的常见操作

添加数组项

数组[长度] = 数据：向数组末尾添加一个数据
数组.push(数据): 向数组末尾添加一个数据
数组.unshift(数据)：向数组起始位置添加一个数据，会导致数组每一项的下标向后移动
数组.splice(下标, 0, 添加的数据): 从指定下标位置开始，删除0个，然后在该位置插入添加的数据，如果下标超过范围，则按照范围的边界进行处理。

push、unshift、splice可以添加多个数据

var arr = [1, 2];

arr[2] = 3; //[1,2,3]
arr[arr.length] = 4; //[1,2,3,4]

arr.push(3); //[1,2,3]
arr.unshift(3); //[3,1,2]

删除数据

delete 数组[下标]: 这种做法不会导致数组其他的属性发生变化，因此，该做法会导致产生稀松数组，所以不推荐使用该做法。
数组.pop(): 删除数组的最后一项，该表达式返回最后一项的数据
数组.shift()：删除数组第一项，该表达式返回第一项的数据
数组.splice(下标, 删除的数量, 添加的数据): 从指定下标位置开始，删除指定数量，然后在该位置插入添加的数据，如果下标超过范围，则按照范围的边界进行处理。返回一个新数组，该数组记录被删除的数据。

var arr = [1, 2, 3];

delete arr[0]; //不推荐
var res = arr.pop(); //[1,2] 返回3
arr.unshift(); //[2]
arr.splice(0, 1); //[]

其他操作

数组.slice(起始位置下标, 结束位置下标)：将起始位置到结束位置之间的数据拿出来，得到一个新的数组，该函数不会改变原数组；注意：结束下标取不到([前闭后开))

下标可以写负数，如果是负数，则从数组的末尾开始计算。

如果不写结束下标，则直接取到末尾。

var arr = [1, 2, 3];

arr.slice(0, 2); //[1,2]
arr.slice(-1, -2); //[3]
arr.slice(1); //[2,3]

数组清空

数组.splice(0, 数组.length);

数组.length = 0;

var arr = [1, 2, 3];

arr.splice(0, arr.length); //[]
arr.length = 0;

查找数组中某一项的下标

数组.indexOf(数据)

从数组中依次查找对应的数据，查找时使用严格相等进行比较。找到第一个匹配的下标，返回。如果没有找到，则得到-1；

数组.lastIndexOf(数据)

功能和indexOf类似，只是查找的是最后一个匹配的下标

数组.fill

数组.fill(数据)：将数组的所有项，填充为指定的数据

数组.fill(数据, 开始下标): 将数组从开始下标起，到数组的末尾，填充为指定的数据

数组.fill(数据, 开始下标，结束下标): 将数组从开始下标起，到数组的结束下标（取不到），填充为指定的数据

数组.join 数组.join(分隔符)，该函数返回一个按照分隔符拼接的字符串
数组.concat 数组1.concat(数组2,[数组3])，将数组2的所有元素拼接到数组1 的末尾，产生一个新数组返回，该表达式不会对原数组造成任何影响数组1.concat(其他类型的值); 可以合并其他类型的值 arr.concat('hello', 'world');

var arr = [1, 2, 3];
var arr2 = ["x", "y"];

arr.indexOf(2); //1
arr.indexOf(4); //-1
arr.lastIndexOf(3); //2

arr.fill(0); //[0,0,0]
arr.fill("a", 1); //[1,'a','a']
arr.fill("b", 1, 2); //[1,'b','a']

arr.join("-"); //'1-b-a'
arr.concat(arr2); //[1,'b','a','x','y'];

语法补充

in关键字

判断某个属性在对象中是否存在

属性名 in 对象

let obj = { a: 10, b: 20 };
console.log("a" in obj); //true

var arr = [1, 2, 3];
console.log(23 in arr); //false

for-in forEach 循环

for (var prop in 对象) {
  //循环体
}

取出对象的所有属性名，每次循环将其中一个属性名赋值给变量prop，运行循环体。

// 遍历对象
let obj = { a: 10, b: 20 };

for (let k in obj) {
  console.log(k); //a,b
}

// 遍历数组
var arr = [1, 2, 3];

for (var i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

for (var index in arr) {
  console.log(index, typeof index, arr[index]);
}

数组应用

面试题-数组的本质：对象（引用类型）

var arr1 = [3, 5, 7, 8, 2]; // arr1中存放的是地址
var arr2 = arr1; // arr2中存放的是地址
arr2[0] = 5;
console.log(arr1 === arr2); //true;
console.log(arr1[0], arr2[0]); //5,5

// 如何复制（克隆，产生一个全新的对象） 使用slice
var arr1 = [3, 5, 7, 8, 2];
var arr2 = arr1.slice();
arr2[0] = 5;
console.log(arr1 === arr2); //false
console.log(arr1[0], arr2[0]); //3,5

对数组求和

var arr = [34, 6, 7, 122, 3];

var sum = 0;
for (var i = 0; i < arr.length; i++) {
  sum += arr[i];
}
console.log(sum);

二维数组

//3*3的二维数组
var arr = [
  [1, 2, 34],
  [345, 1, 1],
  [44, 4, 7],
];

// 遍历二维数组
for (var i = 0; i < arr.length; i++) {
  for (var j = 0; j < arr[i].length; j++) {
    console.log(arr[i][j]);
  }
}

//对二维数组求和
var sum = 0;
for (var i = 0; i < arr.length; i++) {
  for (var j = 0; j < arr[i].length; j++) {
    sum += arr[i][j];
  }
}
console.log(sum);

将数组每一项进行字符串拼接

var arr = [3, 4, 6, 1, 3];

// 输出：3, 4, 6, 1, 3
var str = "";
for (var i = 0; i < arr.length; i++) {
  str += arr[i];
  if (i < arr.length - 1) {
    str += ",";
  }
}

// 方法二 arr.join()
var str = arr.join(",");
console.log(str);

数组 ​

创建一个数组 ​

认识数组的本质 ​

下标 ​

数组的常见操作 ​

添加数组项 ​

删除数据 ​

其他操作 ​

语法补充 ​

in关键字 ​

for-in forEach 循环 ​

数组应用 ​

数组