for (var i = 1; i <= 5; i++) {
  setTimeout( function timer() {
      console.log(i+'m');
  }, 1000 );
}
以上输出  5个6
如何做到输出每个数呢？
①如下
for (let i = 1; i <= 5; i++) {
  setTimeout( function timer() {
      console.log(i+'m');
  }, 1000 );
}
②如下
for (var i = 1; i <= 5; i++) {
    (function(i){
        setTimeout( function timer() {
          console.log(i+'m');
      }, 1000 );
    })(i)
}

使用var或是非对象内部的函数表达式内，可以访问到存放当前函数的变量；在对象内部的不能访问到。

原因也非常简单，因为函数作用域链的问题，采用var的是在外部创建了一个fn变量，函数内部当然可以在内部寻找不到fn后向上册作用域查找fn，而在创建对象内部时，因为没有在函数作用域内创建fn，所以无法访问

解如下题：

function fun(n,o) {
  console.log(o)
  return {
    fun:function(m){
      return fun(m,n);
    }
  };
}
var a = fun(0);  a.fun(1);  a.fun(2);  a.fun(3);//undefined,?,?,?
var b = fun(0).fun(1).fun(2).fun(3);//undefined,?,?,?
var c = fun(0).fun(1);  c.fun(2);  c.fun(3);//undefined,?,?,?
//问:三行a,b,c的输出分别是什么？






//a: undefined,0,0,0
//b: undefined,0,1,2
//c: undefined,0,1,1

function Animal() {  
    this.name = "Animal";  
    this.showName = function() {  
        console.log(this.name);  
    };  
}  
  
function Cat() {  
  
    this.name = "Cat";  
    this._super = Cat.prototype;  
  
    this.showName1 = function() {  
        console.log(this.name);  
    };  
  
    this.showName2 = function() {  
        console.log(this.name);  
    };  
  
    this.showName3 = function() {  
        console.log(this._super.name + "=>" + this.name);  
    };  
}  
Cat.prototype = new Animal();  
var cat = new Cat();  
console.log(cat instanceof Animal);   //true  
cat.showName1();     //"Cat"  
cat.showName2.call(Cat.prototype);   //"Animal"  
cat.showName3();    //"Animal" => "Cat"  

编写一个程序将数组扁平化去并除其中重复部分数据，最终得到一个升序且不重复的数组：
var arr = [[1,2,2],[3, 4, 5, 5],[6, 7, 8, 9,[11,12,[12,13,[14]]]],10];
=>
var res= [1,2,3,4,5,6,7,8,9,10,11,12,13,14]

function copeArray(initArray){
    var result = [];
    result = delayering(initArray);
    console.log(quickSort(result));
}
var quickSort = function(){
    
    var result = [];
    var arr = arguments[0];
    if(arr.length<=1){
        return arr;
    }
    var middleIndex = Math.floor(arr.length/2);
    var minddleItem = arr.splice(middleIndex,1);
    var leftItem = [];
    var rightItem = [];
    
    arr.map((item,index)=>{
        if(item<minddleItem){
            leftItem.push(item)
        }else{
            rightItem.push(item);
        }
    })
    return quickSort(leftItem).concat(minddleItem).concat(quickSort(rightItem))
     
}
var delayering = function(){
    var result = [];
    var arr = arguments[0];
    arr.map((item,index)=>{
        if(Array.isArray(item)){
            var temp = delayering(item);
            temp.map((item,index)=>{
                if(result.indexOf(item)===-1){
                    result.push(item)
                }
            })
        }else{
            if(result.indexOf(item)===-1){
                result.push(item);
            }
        }
    })
    return result ;
}

闭包实现单例

var  GetInstance =(function (name,age){
    var person;
    function Person(){
        this.name = name;
        this.age = age;
    }
    function getInst(){
        debugger;
        if(person !=null){
            return person;
        }else{
            person = new Person();
            return person;
        }
    }
    Person.prototype.showName = function(){
        console.log('name:'+this.name+','+this.age);
    }
    return getInst;
})()