数组进阶

数组进阶

基本概念

数组是值的有序集合。

每个值叫做一个元素，而每个元素在数组中有一个位置，以数字表示，称为索引。

数组是无类型的。

数组元素可以是任意类型，并且同一个数组中的不同元素也可能有不同的类型。

数组的元素可以是对象或其他数组，从而创建复杂的数据结构。

数组是动态的。

根据需要它们会增长或缩减，并且在创建数组时无须声明一个固定的大小或者在数组大小变化时无须重新分配空间。

数组可以是稀疏的。

• 数组元素的索引不一定要连续的，它们之间可以有空缺。
• 每个JavaScript数组都有一个length属性。
• 针对非稀疏数组，该属性就是数组元素的个数。
• 针对稀疏数组，length比实际元素个数要大。

JavaScript数组是JavaScript对象的特殊形式。

数组索引可以认为是整数的属性名。

数组继承自Array.prototype中的属性。

它定义了一套丰富的数组操作方法，它们不仅对真正的数组有效，而且对“类数组对象”同样有效。如，字符串、arguments等。

操作数组

创建数组

数组自变量

let empty = [];
console.log(empty);
let primes = [2, 3, 5, 7, 11];
console.log(primes);
let misc = [1.1, true, "a"];
console.log(misc);
let base = 10;
console.log(base);
let numbers = [base, base + 1, base++, ++base];
console.log(numbers);
let b = [
  [1, { x: 1, y: 2 }],
  [2, { x: 3, x: 4 }],
];
console.log(b);
let count = [1, , 3];
console.log(count);
let others = [, ,];
console.log(others);

结果为

构造函数Array（）

let a1 = new Array(); //相当于[]
let a2 = new Array(10);
let a3 = new Array(1, 2, 3, "四", "五", "六");

读写数组元素

使用[ ]操作符来访问数组中的一个元素。

• 方括号中是一个返回非负整数值的任意表达式。
• 使用该语法既可以读又可以写数组的一个元素。

let a = ["world"];
let value = a[0];
a[1] = 3.14;
i = 2;
a[i] = 3;
a[i + 1] = 4;
a[a[i]] = a[0];
a["10"] = "hi";
a["ten"] = "hoo";
a[-2] = -2;
a[1.11] = 1.11;

结果为

稀疏数组

包含从0开始的不连续索引的数组。

可以用Array()构造函数或简单地指定数组的索引值大于当前的数组长度来创建稀疏数组。

{
    console.log("---------");
      let a1 = [, , ,];
  let a2 = new Array(4);
  console.log(1 in a1, 1 in a2);
  a1[10] = 100;
  a1[8] = undefined;
  for (let a in a1) {
    console.log(a, a1[a]);
  }//
    console.log('for…in循环读取键名，for…of循环读取键值。');
  for (let b of a1) {
        console.log(b);//找空位
      }
    
}

数组长度

每个数组有一个length属性，代表数组中元素的个数。

• 设置为一个小于当前长度的非负整数n时，当前数组中那些索引值大于或等于n的元素将从中删除。
• 设置为大于其当前的长度，会在数组尾部创建一系列空的区域。
• 可以用Object.defineProperty()让数组的length属性变成只读的。

{
      let arr = [1, 2, 3];
      arr.length = 5;
  console.log(arr);
//   Object.defineProperty(arr, "length", {
//         writable: false,//不可写
//         configurable: false,
//       });
    Object.defineProperty(arr, "length", { writable: true });//可写
      arr.length = 3;
      console.log(arr);
      arr.push(1000);
  console.log(arr);

}

  console.log("--++--");
    let arr=[1,2,3];
    arr[arr.length]=4;
    arr.push(5);
    arr.unshift(0);
    console.log(arr);

    delete arr[1];
    console.log(arr);
    console.log('仅删除元素，原长度不变');
    arr.pop();
    arr.shift();
    console.log(arr);
    console.log('删除前后');
    arr.splice(1,2,...[22, 33]);
    console.log(arr);
    console.log('1号后2个长度替换成后面的');
    arr.splice(1,0,...[222, 333]);
    console.log(arr);
    console.log('插入');
    arr.splice(1,2);
    console.log(arr);
    console.log('删除');

数组遍历

    let arr=[1,2,3,4,5];
    console.log(Object.keys(arr));
    arr.test="hello";
    console.log(Object.keys(arr));
    console.log(Object.values(arr));
    console.log("+++++");
    for(let k in arr){
        console.log(k,arr[k]);
    }
    console.log("1111111111");
    arr[8]=9;
    for(let k in arr){
        console.log(k,arr[k]);
    }
    console.log("2222222222");
    for(let d of arr){
        console.log(d++);
    }//本身是复制来的，不是指向数组元素
    console.log("3333333333");
    arr[7]=undefined;
    for(let i=0;i<arr.length;i++){
        if(i in arr)
        console.log(arr[i]);
    }

实例方法

join( )

将数组中所有元素都转化为字符串并连接在一起，返回最后生成的字符串。
可以指定一个可选的字符串在生成的字符串中来分隔数组的各个元素。如果不指定分隔符，默认使用逗号。

   let arr = [1, 2, 3, 4, 5];
  console.log(arr.join("-"), arr.join());

reverse( )

将数组中的元素颠倒顺序，返回逆序的数组。

  let r_arr = arr.reverse();
  console.log(r_arr, arr);