常用循环方法

for

for(表达式1；表达式2；表达式3){ 语句 }

可满足大部分的循环需求：对象、数组、对象数组、字符串、dom节点

//数组 -- 通过数组长度循环，索引+下标+值
let array = [1,2,3]
for(let i = 0;i<array.length;i++){
    console.log(array[i],i)  //1 0
}
//对象 -- 通过key值数组长度，索引+key+value
let object = {name:'xiao',age:'18'}
for(let i = 0, keys = Object.keys(object);i<keys.length;i++){
    console.log(keys[i],object[keys[i],i])  //name xiao 0
}
//对象数组 -- 通过数组长度，索引+下标+值（对象）
let arrayObject = [{name:'xiao',age:'18'},{name:'da',age:'19'}]
for(let i = 0;i<arrayObject.length;i++){
    console.log(arrayObject[i],arrayObject[i].name)  //{name:'xiao',age:'18'} xiao
}
//字符串 -- 通过字符串长度，索引+对应元素
let string = 'abc'
for(let i = 0;i<string.length;i++){
    console.log(string[i],i)  //a 0
}
//dom节点 -- 通过节点长度，索引+节点
let doms= document.querySelectorAll('p')
for(let i = 0;i<doms.length;i++){
    console.log(doms[i],i)  //<p></p> 0
}

 for...in

for(变量 in 对象){ 语句 }

一般用来遍历一个对象的全部属性（包括原型链上）

以任意顺序

Object.prototype.nickname = 'unset'
let object = {name:'xiao',age:'18'}
for(let i in object){
    console.log(object[i],i)
}
name xiao
age 18
nickname unset

//使用hasOwnProperty做判断，使其只遍历自身的属性，不包含原型链上的属性
for(let i in object){
    if(object.hasOwnProperty(key) === true){
        console.log(object[i],i)
    }  
}

for...of 

for(变量 of 数组){ 语句 }

适用遍历数组／字符串/map/set等有迭代器对象的集合，但是不能遍历普通对象

只能拿到数组的值，获取不到数组的下标，不会遍历原型链上的属性

let arr = [1,2,3]
for(let value of arr){
    console.log(value) //1,2,3
}

 forEach

数组.forEach( i => { 语句 })

按升序为数组中的每一项执行一次回调函数，不会改变原数组

//遍历数组
let arr = [1,2,3]
arr.forEach(i=>{
    console.log(i)  //1,2,3
})
//遍历对象
let obj ={name:'xiao'}
let keys = Object.keys(obj)
keys.forEach(i => {
    console.log(i,obj[i])  //name xiao
})

 map

数组.map( i => { return 条件 })

为数组中的每一项执行回调函数，不会改变原数组，返回一个新数组

let arr = [1,2,3]
let newArr = arr.map(i=>{
    retrun i*2
})
console.log(newArr) //[2,4,6]

知识补充 

switch case

switch (表达式){
        case 值1 : 语句1
        break;
        case 值2 : 语句2
        break;
        …
        default : 语句
        break;

}

switch case 为选择语句而非循环语句，此处break为跳出Switch并非跳出循环，default为除以上情况之外执行的语句，也可以直接写default;

跳出循环 break continue

用于在一定条件下跳出循环体或执行下一次，只在循环体中使用

break：跳出当前循环体，当break在switch语句体内时，只是跳出该switch语句体，并不能终止循环体的执行

continue：终止当前循环，并继续执行下面的循环

 Object方法

Object.create()

创建对象，使用现有的对象来作为新创建对象的原型（prototype）

const obj = Object.create({a:1}, {b: {value: 2}})
//第一个参数为对象，对象为函数调用之后返回新对象的原型对象，
//第二个参数为对象本身的实例方法（默认不能修改,不能枚举）
obj.__proto__.a === 1      // true 
obj.b = 3;
console.log(obj.b)      // 2
//创建一个可写的,可枚举的,可配置的属性p
obj2 = Object.create({}, {
  p: {
    value: 2,       // 属性值
    writable: true,     //  是否可以重写值
    enumerable: true,   //是否可枚举
    configurable: true  //是否可以修改以上几项配置
  }
});
obj2.p = 3;
console.log(obj2.p)     // 3
//注意： enumerable 会影响以下
//for…in  遍历包括对象原型上属性
Object.keys()   //只能遍历自身属性
JSON.stringify  //只能序列化自身属性

Object.defineProperty/Object.defineProperties

定义对象属性

//defineProperty
var obj = {};
// 1.添加一个数据属性
Object.defineProperty(obj, "newDataProperty", {
    value: 101,
    writable: true,
    enumerable: true,
    configurable: true
});
obj.newDataProperty    // 101
//defineProperties
var obj = {};
Object.defineProperties(obj, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
  // etc. etc.
});

 Object.values()/Object.keys()

遍历对象本身的可枚举属性/属性

let arr = ["a", "b", "c"];
let obj = { foo: "bar", baz: 42 };
Object.keys(arr)        // ['0', '1', '2']
Object.keys(obj)        // ["foo","baz"]
Object.values(arr)      // ["a", "b", "c"]
Object.values(obj)      // ["bar",42]

Object.assign( target, source, source1 )

对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）

只拷贝源对象的自身属性 ，不拷贝继承属性和不可枚举的属性（enumerable: false）

浅拷贝

const target = { a: 1, b: 1 };
const source1 = { b: 2, c: 2 };
const source2 = { c: 3 };
Object.assign(target, source1, source2); target // {a:1, b:2, c:3}