this的讲解和其他习题

习题

 var f = (
   function f(){return '1'},
   function g(){return 2}
 )() 
 typeof f //number (括号操作符会返回逗号后面的东西）

 var x = 1;
 if(function f(){}){
   x+=typeof f
 }
 //x  1undefined   函数变成表达式就会立即执行，执行之后再也找不到了

判断一个数字是不是数字

function isNaN(num){
  var ret = Number(num);
  ret +='';
  if(ret =='NaN'){
   return true;
 }else{
   return false;
 }
}

对象是引用值，引用值比对的是地址，而这个是属于两个房间，地址不一样

 

 

 

 this

1、函数预编译过程this->window

function test(){
  console.log(this);//this指向window
}
test();

2、全局作用域里this ->window

3、call/apply 可以改变函数运行时this指向

4、obj.func(); func()里面的this指向obj(谁调用函数，这个this就指向谁)

this习题

var name = '222';
var a = {
  name:'111',
  say:function(){
    console.log(this.name);
  }
}

var fun = a.say;
fun();//222
a.say();//111
var b = {
  name:'333',
  say:function(fun){
    fun(); 
  }
}
b.say(a.say);//222
b.say = a.say;
b.say();//333

 

var length = 10;
function fn(){
     console.log(this.length)
}
var obj = {
      length:5,
      method:function(fn){
            fn();//10
            arguments[0]();//2
      }
}
obj.method(fn,1)

 

arguments.callee(相当于函数自身引用)

var num = (function (n){
    if(n==1){
      return 1;
    }
    return n*arguments.callee(n-1);
}(100))

深克隆（改变现在的属性，不会更改原来的属性）

遍历对象for(var prop in obj)

判断是不是原始值 typeof() object

判断是数组还是对象

建立相应的数组或对象

 function deepCopy(origin, target) {
            var target = target || {}
            for (var i in origin) {//遍历数组
                if (typeof origin[i] === 'object') {//判断是不是原始值
                //要考虑深复制问题了
                if (origin[i].constructor === Array) {//判断是数组还是对象
                    //这是数组
                    target[i] = []
                } else {
                    //这是对象
                    target[i] = {}
                }
                deepCopy(origin[i], target[i])//建立相应的数组或对象
                } else {
                target[i] = origin[i]
                }
            }
            return target
        }
        var obj = {
            name:'fan',
            abc:{
                grade:190,
                arr:[{a:123}]
            }
        }
        var obj1 ={}
        deepCopy(obj,obj1)
        console.log(obj1)
        obj1.name = 'you'

 

 

function deepCopy(origin,target){
            var target = target || {}
                toStr = Object.prototype.toString,
                arrStr = "[object Array]";
            for(var prop in origin){
                if(origin.hasOwnProperty(prop)){
                    if(origin[prop] !=='null' && typeof(origin[prop]) == 'object'){
                        if(toStr.call(origin[prop]) === arrStr){
                            target[prop] = []
                        }else{
                            target[prop] = {}
                        }
                        deepCopy(origin[prop], target[prop])
                    }else{
                        target[prop] = origin[prop]
                    }
                }
            }
            return target;
        }
        var obj = {
            name:'fan',
            abc:{
                grade:190,
                arr:[{a:123}]
            }
        }
        var obj1 ={}
        deepCopy(obj,obj1)
        // console.log(obj1)
        obj1.name = 'you'