数组

Array：
数组： 保存一组数据
数组对象的作用是：使用单独的变量名来存储一系列的值。
（动态数组：可自动根据元素个数调用长度大小）
概念：

1. 元素：数组中所保存数据的空间

2. 长度：数组中所保存元素的个数

3. 下标（索引）：数组中元素的编号，从0开始编号，到（数组的长度-1）结束
   使用：
   创建数组对象：

   var arr = [];//直接量
   var arr = new Array();//创建数组对象。
   var arr = [1,2,3];//直接量，在创建数组对象的同时初始化保存的数据。
   var arr = new Array(1,2,3);在创建数组对象的同时初始化保存的数据。
   var arr = new Array(size);//size为数字参数，表示创建数组时先预定size个空间。

   访问数组元素：
   数组名[下标]

数组元素遍历迭代：
普通循环：

for(let i = 0;i < array.length; i++) {
	//array[i]
}

for-in：

for(let 变量名 in 数组名) {
	//变量名中所保存的值是数组下标编号的字符串内容
	//仍然使用“数组名[字符串下标]”来访问数组对应下标处的元素
}

这是对数组的操作

  var a=[5,4,3,2,1];
        var x=0;
        console.log(typeof x);//number
        for (x in a) {
            console.log("a["+x+"]: "+a[x]);
            console.log(typeof x);//string
        }
        console.log(x);//4
        console.log(typeof x);//string
    //        a[0]: 5
    //        a[1]: 4
    //        a[2]: 3
    //        a[3]: 2
    //        a[4]: 1

对象操作：for…in 并不能够保证返回的是按一定顺序的索引，但是它会返回所有可枚举属性，包括继承属性

var obj={"1":"first",
   "two":"zoo",
  "3":"2",
  "three":"34",
  "4":"1",
  "2":"second"
};
for (var i in obj) { 
    console.log(i+":"+obj[i]);
};

//1:first
//2:second
//3:2
//4:1
//two:zoo
//three:34

给原型添加属性之后，默认情况下枚举，会把原型属性一并输出，如下所示。由于它总是会访问该对象的原型,看下原型上是否有属性,这在无意中就给遍历增加了额外的压力。

function fun4(){
var a=[1,2,3,4,5];
Array.prototype.age=13;
for(var i in a){
console.log("a["+i+"]: "+a[i]);
}
}
//a[0]: 1
//a[1]: 2
//a[2]: 3
//a[3]: 4
//a[4]: 5
//a[age]: 13

此时可以使用 hasOwnProperty() 的方法使隐藏的继承属性不会被显示

function fun4(){
var a=[1,2,3,4,5];
Array.prototype.age=13;
for(var i in a){
  if( a.hasOwnProperty( i ) ) {
    console.log("a["+i+"]: "+a[i]);
  }
}
}
  //a[0]: 1
//a[1]: 2
//a[2]: 3
//a[3]: 4
//a[4]: 5

for-of：可以遍历arrays、strings、maps、sets等可迭代的数据结构等

for(let 变量名 of 数组名) {
	//变量名中所保存的值是数组中当前遍历到的元素值
}

const iterable = ['mini', 'mani', 'mo'];
for (const value of iterable) {
  console.log(value);
}
// mini
// mani
// mo

maps映射

   const iterable = new Map([['one', 1], ['two', 2]]);
    for (const [key, value] of iterable) {
      console.log(`Key: ${key} and Value: ${value}`);
    }
    // Key: one and Value: 1
    // Key: two and Value: 2

set集合：Set(集合) 中的值只能发生一次。如果您创建一个具有多个相同元素的 Set(集合) ，那么它仍然被认为是单个元素。

const iterable = new Set([1, 1, 2, 2, 1]);
for (const value of iterable) {
  console.log(value);
}
// 1
// 2

For…of vs For…in
for…in 循环将遍历对象的所有可枚举属性。

//for-in-example.js
Array.prototype.newArr = () => {};
Array.prototype.anotherNewArr = () => {};
const array = [‘foo’, ‘bar’, ‘baz’];

for (const value in array) {
console.log(value);
}
// Outcome:
// 0
// 1
// 2
// newArr
// anotherNewArr
for…in 不仅枚举上面的数组声明，它还从构造函数的原型中查找继承的非枚举属性，在这个例子中，newArr 和 anotherNewArr 也会打印出来。
for…of 更多用于特定于集合（如数组和对象），但不包括所有对象。

注意：任何具有 Symbol.iterator 属性的元素都是可迭代的。

Array.prototype.newArr = () => {};
const array = [‘foo’, ‘bar’, ‘baz’];

for (const value of array) {
console.log(value);
}
// Outcome:
// foo
// bar
// baz
for…in 不考虑构造函数原型的不可枚举属性。它只需要查找可枚举属性并将其打印出来。