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

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

一.概述

数组如何声明? 使用方括号声明，可以存放任何值具体见:定义数组
数组的本质? 是一个拥有方法的对象具体见:数组的本质
数组的任何遍历?①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);