JS-this

this

1. 函数预编译过程 this —> window

function test (c) {
    var a = 123;
    function b() {}
}
AO {
    arguments : [1],
    this : window,
    c : 1,
    a : undefined,
    b : function () {}
}
test(1);

new test();
//new之后
var this = Object.creat(test.prototype)

2. 全局作用域里 this —> window

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

4. obj.function(); function();里面的this指向obj

var obj = {
    a : function () {},
    b : 123
}
obj.a();
//其中this指向obj

var name = '222';
var a = {
    name : '111',
    say : function () {
        console.log(this.name);
    }
}
var fun = a.say;
fun();      //222 say函数在全局执行，第一条
a.say();    //111 a调用say方法执行，第四条

var b = {
    name : '333',
    say : function (fun) {
        fun();
    }
}
b.say(a.say);   //222 b调用say，此时this指向b，在执行say函数时执行fun函数，没人调用，空执行，走预编译环节，此时this指向window
b.say = a.say;
b.say();        //333 第四条

arguments.callee：指向函数自身引用

function test(){
    console.log(arguments.callee);  //打印函数引用
}

test();

//out： function test() {
//          console.log(arguments.callee);
//      }

应用：立即执行函数的函数名没有用，当需要递归使用函数时，可用arguments.caallee找到引用

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

function test () {
    console.log(arguments.callee);
    function demo () {
        console.log(arguments.callee);
    }
    demo();
}
test();

function.caller：在哪个环境被调用，指向哪个环境

function test () {
    demo();
}
function demo () {
    console.log(demo.caller);
}
test();

克隆

浅层克隆

var obj = {
    name : 'abc',
    age : 123,
    sex : 'famale'
}
var obj1 = {};

function clone (orgin, target) {
    var target = target || {};
    for (var prop in origin) {
        terget[prop] = orgin[prop];
    }
    return terget;
}
clone(obj,obj1);

这种方法拷贝引用值时，修改一个，另一个也会更改

深度拷贝

数组对象，先分析

var obj = {
    name : 'abc',
    age : 123,
    card : ['visa','master'],
    wife : {
        name : 'bcd',
        son : {
            name : 'aaa'
        }
    }
}

// 1.判断是不是原始值
// 2.判断是数组还是对象
// 3.建立相应的数组或对象

function deepClone(origin,target) {

}

P27