JavaScript 的数据类型【六】(数组)

  • A+

JavaScript 语言的每一个值,都属于某一种数据类型。JavaScript 的数据类型,共有八种。数值字符串布尔值这三种是原始类型。undefinednull,为两个特殊值。function,函数也为一种基础类型。对象则称为合成类型。ES6 添加了Symbol类型的值。

一.概述

  1. 数组如何声明? 使用方括号声明,可以存放任何值 具体见:定义数组
  2. 数组的本质? 是一个拥有方法的对象 具体见:数组的本质
  3. 数组的任何遍历?①for...in方式;②for循环或while循环遍历③使用forEach方法遍历具体见:数组的遍历

二.定义数组

1.定义

  • 数组用方括号定义,角标从0开始
  • 数组可以先定义,后赋值
  • 数组可以容纳任何类型
  • 数组元素嵌套,就为多维数组
    //一使用[]定义数组
    var arr = ['a', 'b', 'c'];
    
    //二先定义后赋值
    var arr = [];
    
    arr[0] = 'a';
    arr[1] = 'b';
    arr[2] = 'c';
    
    //三容纳任何类型
    var arr = [
      {a: 1},
      [1, 2, 3],
      function() {return true;}
    ];
    
    arr[0] // Object {a: 1}
    arr[1] // [1, 2, 3]
    arr[2] // function (){return true;}
    
    //四多维数组
    var a = [[1, 2], [3, 4]];
    a[0][1] // 2
    a[1][1] // 4
    

2.数组的本质

  • 数值是一种特殊的对象,使用typeof运算符会返回
    object
  • 数组的健名是索引,为固定值(0,1,2....)
  • 不可用.点的形式获取值,只能用中括号方式获取值[]
  • 数组是一个对象,所以可以添加属性,不会影响原有的数据
    //一数组是对象
    typeof [1, 2, 3] // "object"
    
    //二数组键为索引
    var arr = ['a', 'b', 'c'];
    
    Object.keys(arr)
    // ["0", "1", "2"]
    
    //不能用点获取值
    var arr = [1, 2, 3];
    arr.0 // SyntaxError
    

三.数组的特性

1.length 属性

  • 数组的length属性,返回数组的成员数量;计算方式是健名加上1
    var arr = ['a', 'b'];
    arr.length // 2
    
    arr[2] = 'c';
    arr.length // 3
    
    arr[9] = 'd';
    arr.length // 10
    
    arr[1000] = 'e';
    arr.length // 1001
    
  • 使用length操作数组长度,①length是可赋值的,赋值比当前小,就自动减少值;②赋值比当前大,就自动填充undefined;③快速清空数组length属性设为0
    //一赋值比当前数组小
    var arr = [ 'a', 'b', 'c' ];
    arr.length // 3
    
    arr.length = 2;
    arr // ["a", "b"]
    
    //二赋值比当前数组大
    var a = ['a'];
    
    a.length = 3;
    a[1] // undefined
    
    //清空数组
    var arr = [ 'a', 'b', 'c' ];
    
    arr.length = 0;
    arr // []
    

2.in 运算符

  • in验证某个键名是否存在
    var arr = [ 'a', 'b', 'c' ];
    2 in arr  // true
    '2' in arr // true
    4 in arr // false
    

3.数组的遍历

  • 数据的遍历有三种方式
  • 第一种:使用for...in遍历;因为数组为对象,所以可以使用for...in的方式进行遍历
  • 第二种:使用for循环或while循环遍历
  • 第三种:使用forEach方法遍历
    //一:for...in方式,不仅遍历数字键,也会遍历非数字键
        var a = [1, 2, 3];
        a.foo = true;
    //二:使用`for`循环或`while`循环遍历
        for (var key in a) {
          console.log(key);
        }
        // 0
        // 1
        // 2
        // foo
    
        // while循环正向遍历
        var i = 0;
        while (i < a.length) {
          console.log(a[i]);
          i++;
        }
        // while循环反向遍历
        var l = a.length;
        while (l--) {
          console.log(a[l]);
        }
    
    //三:使用`forEach`方法遍历
        var colors = ['red', 'green', 'blue'];
        colors.forEach(function (color) {
          console.log(color);
        });
        // red
        // green
        // blue
    

4.数组的空位

  • 数组的空位,不会影响长度
  • 数组空位返回undefined
  • delete删除数组成员,形成空位
  • 空位不会被遍历到,若数组中显示定义undefined,则会被遍历到
    //============
    //一:空位不影响长度
    var a = [1, 2, 3,];
    
    a.length // 3
    a // [1, 2, 3]
    
    //============
    //二:空位返回undefined
    var a = [, , ,];
    a[1] // undefined
    
    //============
    //三:delete删除数组成员,形成空位
    var a = [1, 2, 3];
    delete a[1];
    
    a[1] // undefined
    a.length // 3
    
    //============
    //四:空位遍历
    var a = [, , ,];
    
    a.forEach(function (x, i) {
      console.log(i + '. ' + x);
    })
    // 不产生任何输出
    
    for (var i in a) {
      console.log(i);
    }
    // 不产生任何输出
    
    Object.keys(a)
    // []
    //------------
    var a = [undefined, undefined, undefined];
    
    a.forEach(function (x, i) {
      console.log(i + '. ' + x);
    });
    // 0. undefined
    // 1. undefined
    // 2. undefined
    
    for (var i in a) {
      console.log(i);
    }
    // 0
    // 1
    // 2
    
    Object.keys(a)
    // ['0', '1', '2']
    

四.类似数组的对象与数组之间的转换

1.类数组对象

  • 类数组对象的定义:如果一个对象的所有键名都是正整数或零,并且有length属性,那么这个对象就很像数组,语法上称为“类似数组的对象”
  • 典型的“类似数组的对象”是函数的arguments对象,以及大多数 DOM 元素集,还有字符串。
    var obj = {
      0: 'a',
      1: 'b',
      2: 'c',
      length: 3
    };
    

2.类数组对象与数组转换

  • 数组的slice方法可以将“类似数组的对象”变成真正的数组
    var arr = Array.prototype.slice.call(arrayLike);
    
  • 通过call()把数组的方法放到对象上面
    function args() { return arguments }
    var arrayLike = args('a', 'b');
    function print(value, index) {
      console.log(index + ' : ' + value);
    }
    
    Array.prototype.forEach.call(arrayLike, print);
    
zhangfeng

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: