var arr = [12,13,14];
 for(key in arr){
     console.log(key);  //输出数组的索引  0,1,2···
     console.log(arr.key); //undefined  undefined undefined
     console.log(arr[key]); // 12 13 14
 }

var obj = {
       name:"Jhon",
       age:13,
       address:"American"
   }
   for(key in obj){
       console.log(key);  // name age address
       console.log(obj.key); //undefined undefined undefined
       console.log(obj[key]); // Jhon  13 American
   }

var obj = {
       name:"Jhon",
       age:13,
       address:"American"
   }
   console.log(obj.name) //Jhon
   console.log(obj["name"]) //Jhon
   
   var key = "name";
console.log(obj[key]) //Jhon
   console.log(obj.key)  //Jhon
   //[] 可以接受变量，点操作符不可以

  function shadowCopy (target,source){
        if(!source || typeof source !== 'object'){  //source必须是对象
            return;
        }
        if(!target || typeof target !== 'object'){
            return;
        }
        for(var key in source){  
            if(source.hasOwnProperty(key)){
                target[key] = source[key];//注意必须用[]形式，不能用点操作符
            }
        }
    }
    var obj1 = {
        name:"Jhon",
        age:13,
        address:"American",
        other:{		//other是一个对象
            gender:"man"
        }
    }
    var obj2 = {};
    shadowCopy(obj2,obj1);
    console.dir(obj2);
    //浅拷贝有一个问题，就是复制的obj2中的other和obj1中的other指向的是同一个对象
	obj1.name = "JiM";
    obj1.other.gender = "woman"; //修改obj1中的属性gender
	
	console.log(obj2.name);//Jhon  // obj2中的name不会跟着改变 
    console.log(obj2.other.gender);//woman //obj2中的gender也跟着改变
//基本数据类型复制传值，复杂数据类型的复制传地址，这个是内因
//这是浅拷贝的一个缺陷，虽然说也拷贝了一份，但是对于对象的拷贝不够彻底

function deepCopy (target,source){
        if(!source || typeof source !== 'object'){  //source必须是对象
            return;
        }
        if(!target || typeof target !== 'object'){
            return;
        }
        for(var key in source){  
            if(source.hasOwnProperty(key)){
               if(source[key] && typeof source[key] == 'object'){
                 	target[key] = {};
                 	deepCopy(source[key],target[key]);
               }else{
                 	target[key] = source[key];
               }
            }
        }
    }

console.log(Object('abc'));
console.log(typeof Object('abc'));
console.log(Object(1));
console.log(typeof  Object(1));
console.log(Object(true));
console.log(typeof Object(true));

Object.assign(undefined) // 报错
Object.assign(null) // 报错
typeof Object.assign(2) // "object"
var obj = {a: 1};
Object.assign(obj) === obj // true

var obj1 = {a: {b: 1}};
var obj2 = Object.assign({}, obj1);
obj1.a.b = 2;
obj2.a.b // 2

var target = { a: { b: 'c', d: 'e' } }
var source = { a: { b: 'hello' } }
Object.assign(target, source)
// { a: { b: 'hello' } }

var obj = Object.create({ foo: 1 }, { // foo is on obj's prototype chain.
  bar: {
    value: 2  // bar is a non-enumerable property.默认emunerable属性值是false
  },
  baz: {
    value: 3,
    enumerable: true  // baz is an own enumerable property.
  }
});
var copy = Object.assign({}, obj);
console.log(copy); // { baz: 3 }

let x = 'jhon';
let y = 'jim'
console.log(Object.assign({},{x,y}));//ES6对象的属性简写，如果x y未定义会报错

//第一用法添加对象的属性
   class test {
       constructor(){
           Object.assign(this,{x,y});//这里是对象的简写
       }
   }

//第二个用法，添加对象的方法
  Object.assign(test.prototype,{
      method1(){
          console.log("this is method one");
      },
      method2(){
          console.log("this is method two");
      }
  })
  var t = new test();
  console.log(t);

function clone(origin){
      return Object.assign({},origin);
  };
  //如果想要克隆原型上的属性
  function perfectClone(origin){
      let originPrototype = Object.getPrototypeOf(origin);
      return Object.assign(originPrototype,origin);
  }
  var c = clone(t);
  console.log(c);
  var pc = perfectClone(t);
  console.log(pc);

const merge = (target,source1,source2) => Object.assign(target,source1,source2);
var M = merge(t,c,pc);
console.log(M);

const DEFAULTS = {name:"Jhon",psw:"123456"};
let loginIn = (option) => {option = Object.assign({},DEFAULTS,option)};

//很多人第一步如下
var arr = Array(100);//但是这个是稀疏数组
console.log(arr) ;//[]

Array.from(arr);//这就成功创建了一个密集数组，所有的值都被初始化未undefined
Array.from({length:100});//这个和上面达成的效果是一致的
//[undefined,undefined,undefined···········]

Object.keys(Array.from({length:100}))
//[1,2,3,4······100]

var arrayLike = {length:100};
var arr1 = [];
arr1.push.apply(arr1,arrayLike );
console.log(arr1);////[undefined,undefined,undefined···········]

var arrayLike = {length:100};
var arr2 = Array.apply(null,arrayLike ); //Array方法也是为了创建一个新的数组
//注意必须用apply，apply会将传入的数组或者类数组对象中的属性一一传入调用apply的函数中
console.log(arr2);////[undefined,undefined,undefined···········]

var arrayLike = {0:11,1:12,2:13,length:3};
var newArr = Array.from(arrayLike,item => item*2);
console.log(newArr);//[22,24,26]

var arr = ['Jhon',66,"JiM"]；
console.log(arr.length);//3  
arr.length = 4 ;
console.log(arr[4]);//undefined

Array.from("foo");   //  // ["f", "o", "o"] 
// 使用 map 函数转换数组元素
Array.from([1, 2, 3], x => x + x);      // [2, 4, 6]

Array.prototype.map(callback,thisArg);//thisArg严格模式下指向undefined ，非严格模式指向window

 	var numberArr = [36,25,9,16];
    var newNum = numberArr.map(Math.sqrt);
    console.log(newNum);//[6,5,3,4]  
    console.log(numberArr);// [36,25,9,16]
//map方法返回一个新的数组，不改变原数组

//如何利用map方法获取每一个字符串的编码值
 var str = "Learn more for great life";
 var map = Array.prototype.map;
 var strArr = map.call(str,function(s){
   // 'use strict'
  	 console.log(this) ;//注意函数内部的this指向是window,'use strict'严格模式下是undefined;
     return s.charCodeAt(0);//注意必须有返回值，如果没有return ,默认返回undefined,生成的是一个undefined组成的数组
 });
 console.log(strArr);

//如何利用map方法翻转一个字符串,现将字符串转化为数组，然后将数组翻转，在将数组转化为字符串
var str = "Learn more for great life";
var map = Array.prototype.map;
var strArr = map.call(str,function(s){
     return s;
});
var newStr = strArr.reverse().join("");
console.log(newStr);

var str = '1234567';
var revStr = str.split("").reverse().join('');

//猜一猜这个返回的数组是什么？ 
 var arr = [1,2,3,4];
 var newArr = arr.map(parseInt);
 console.log(newArr);
//parseInt函数其实接受的是两个参数 parseInt(s,radix)一个是要转化的字符串，一个是转化的进制基数;
//map函数传递给callback的是三个参数，一个数组元素，一个数组元素的索引值，一个是数组本身;
//其实执行的是以下过程
//parseInt(1,0) parse(2,1) parseInt(3,2)  parseInt(4,3)  对于parseInt如果基数为0 ，按照十进制进行转化
//所以输出结果是 [1 ,NaN,NaN,NaN]

var arr1 = new Array(100);
console.log(arr1);
var arr = arr1.map(function(item,index){
  return index;   //未被初始化的数组元素并不会调用callback函数
})
console.log(arr);//空数组

Array.prorotype.forEach(callback,thisArg) //thisArg严格模式下指向undefined ，非严格模式指向window

//thisArg可以用来改变forEach的callback函数执行时候this指向  
function Counter(){
        this.sum = 0;
        this.count = 0 ;
    }
    Counter.prototype.add = function(array){
        array.forEach(function(item){
            
            this.sum += item ;
            ++this.count;
            console.log(this);//看下这个时候的this指向
        },this);
    }
    var arr = [9,6,2];
    var counter = new Counter();
    counter.add(arr);
    console.log(counter.sum);
    console.log(counter.count);

var arr = [1,2,3,4]
arr.forEach(function(item){
  console.log(item);//1,2,3,4
})

var arr = [1,2,3,4]
arr.forEach(function(item){
  console.log(item);
  break;//抛出异常
})

var arr = [0,1,2,3,4,5,6,7]
arr.forEach(function(item,index,arr){
  console.log("item"+item);
  console.log("index"+index);
  console.log(arr);
//index 会从索引0一直递增，如果期间删除了某一项，会使后面的元素所在索引位置发生变化
  if(item === 2){
    arr.shift();
    console.log(arr);
  }
})

var str = "Learn more for great life";
var foreach = Array.prototype.forEach;
var res = foreach.call(str,function(s){
  return s;
});
console.log(res);//undefined

var arr1 = new Array(100);//创建一个未被初始化的数组，数组的长度为100 
console.log(arr1);
arr1.forEach(function(item){
  console.log(item);//并不会输出任何值
})

Parameters
callback
Function to test for each element, taking three arguments:
currentValue (required)
The current element being processed in the array.
index (optional)
The index of the current element being processed in the array.
array (optional)
The array every was called upon.
thisArg
Optional. Value to use as this when executing callback.
Return value
true if the callback function returns a truthy value for every array element; otherwise, false.
Description
The every method executes the provided callback function once for each element present in the array until it finds one where callback returns a falsy value. If such an element is found, the every method immediately returns false. Otherwise, if callback returns a truthy value for all elements, every returns true. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.

function isBigEnough(element, index, array) { 
  return element >= 10; 
} 
[12, 5, 8, 130, 44].every(isBigEnough);   // false 
[12, 54, 18, 130, 44].every(isBigEnough); // true

Parameters
callback
Function to execute on each value in the array, taking four arguments:
1 accumulator
The accumulated value previously returned in the last invocation of the callback, or initialValue, if supplied. (See below.)(如果initialValue提供了，那么第一次运行的时候，accumular值为initialValue，如果没有提供initialValue，那么accumular的值为数组中的第一个元素，currentValue为数组中的第二个元素，跳过第一个索引值)
2 currentValue
The current element being processed in the array.
3 currentIndex
The index of the current element being processed in the array. Starts at index 0, if an initialValue is provided, and at index 1 otherwise.
4 array
The array reduce was called upon.
5 initialValue
Optional. Value to use as the first argument to the first call of the callback.
Return value
The value that results from the reduction.

var Flatten = [[1,2],[4,6],[7,9]]
var newFaltten = Flatten.reduce(function(a,b){
  return a.concat(b);
},[])
console.log(Flatten);
console.log(newFaltten);

    var arr = [2,3,4,5,6,7,8];
    var newArr = arr.filter(function(item){
        return item >　4 ;
    });
    console.log(arr);	//[2,3,4,5,6,7,8];
    console.log(newArr);//[5,6,7,8]
//-----------------------------------------------
	var arr = [2,3,4,5,6,7,8];
    var newArr = arr.filter(function(item){
        return true ;
    });
    console.log(arr);		//[2,3,4,5,6,7,8]
    console.log(newArr);	//[2,3,4,5,6,7,8]
//如果是return false ;那么newArr = [] ;如果没有返回值，callback默认返回undefined,filter对undefined转化为false ,最后newArr还是空数组;
//如果return 数字 字符串 等等 返回结果都是原来的数组，因为filter会对callback函数的返回值进行转化为布尔类型的值进行判断，如果转化结果为true ,那么则保留当前数组元素，如果转化结果为false,则不保留当前数组元素

var arr = ['ma','jje','fff']
let iterator = arr.keys()
console.log(iterator)
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
/**
          Array Iterator {}
          Object {value: 0, done: false}
          Object {value: 1, done: false}
          Object {value: 2, done: false}
          Object {value: undefined, done: true}
        */       
let Arr = ['a',,'c']
let sparseKeys = Object.keys(Arr)
let denseKeys = [...Arr.keys()] 
console.log(sparseKeys) //["0","2"]
console.log(denseKeys)  //[0,1,2]
//需要注意的一点就是Object.keys() 返回的是一个由字符串索引组成的数组

var arr = [{text:"JHon"},{text:"Jim"}]
var ret = arr.indexOf({text:"JHon"})   
console.log(ret)  //-1

var obj = {text:"JHon"}
var arr = [obj,{text:"Jim"}]
var ret = arr.indexOf(obj)   
console.log(ret)  //0

var arr = [21,35,24,12,15,2,3,65,64]
 arr.sort(function(){
      console.log(arguments);
      console.log(this);
  })
 
 //从控制台结果可以看出sort传递的函数默认有两个参数，这两个参数就是要排序的数组里面的两项
 //函数执行的this指向window;
 //如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，是按照字符编码的顺序进行排序。

 var arr = [21,35,24,12,15,2,3,65,64]
    arr.sort(function(a,b){
        return a - b ;
    })
    //这种方法可以排序数字数组，却不能排序字符串数组，如下有代码案例
    console.log(arr);
//注意 - 操作符的运算，对于数字类型的运算数，结果返回数字  
//a-b输出从小到大排序，b-a输出从大到小排序。

var arr = ['eca','bda','acf','dfe'];
arr.sort()
console.log(arr);
//["acf", "bda", "dfe", "eca"]
//如果调用该方法时没有使用参数，将按字母顺序对数组中的元素进行排序，说得更精确点，是按照字符编码的顺序进行排序。要实现这一点，首先应把数组的元素都转换成字符串（如有必要），以便进行比较

var arr = ['eca','bda','acf','dfe'];
    arr.sort(function(a,b){
        return a - b ;
    })
    //这种方法不能排序字符串
console.log(arr);
//["eca", "bda", "acf", "dfe"]
//这个排序功能就没有了，因为 - 运算符操作的运算数如果有一个不是数字，那么就会返回NaN，没有返回1 -1 或者0任意一个;

var arr = ['eca','bda','acf','dfe'];
   function sortStr (str1,str2){
       if(str1 > str2){    //如果str1 > str2 交换二者的位置
           return 1 ;
       }else if (str1 < str2 ){ //如果str1 < str2 则不交换
           return -1;
       }else{
           return 0;
       }
   }
   
   arr.sort(sortStr);
   console.log(arr);
   //["acf", "bda", "dfe", "eca"]  按字母升序排列

var arr = ['eca','bda','acf','dfe'];
function sortStr (str1,str2){
    if(str1 > str2){
        return -1 ;//1  变为-1 
    }else if (str1 < str2 ){
        return 1;// -1 变为1 
    }else{
        return 0;
    }
}
arr.sort(sortStr);
console.log(arr);
//["eca", "dfe", "bda", "acf"]  按字母降序排列

 function  sortByProperty(sortName){
       return function (o1,o2){
           if(o1[sortName] > o2[sortName] ){
               return 1 ;
           }else if(o1[sortName] < o2[sortName]){
               return -1 ;
           }else{
               return 0 ;
           }
       }
   }
    arr.sort(sortByProperty("id"))
    console.log(arr);
//同样，可以按照不同的属性进行排序

function randomsort(a, b) {
  return Math.random()>.5 ? -1 : 1;
  //用Math.random()函数生成0~1之间的随机数与0.5比较，返回-1或1
}
var arr = [1, 2, 3, 4, 5];
arr.sort(randomsort);
console.log(arr);

arr.sort(function(){
    return Math.random() - 0.5;
})