作业题2

var num = 10;
var obj = {num: 20};
obj.fn = (function (num) {
    this.num = num * 3;
    num++;
    return function (n) {
        this.num += n;
        num++;
        console.log(num);
    }
})(obj.num);
var fn = obj.fn;
fn(5);
obj.fn(10);
console.log(num, obj.num);
function Fn() {
    this.x = 100;
    this.y = 200;
    this.getX = function () {
        console.log(this.x);
    }
}
Fn.prototype = {
    y: 400,
    getX: function () {
        console.log(this.x);
    },
    getY: function () {
        console.log(this.y);
    },
    sum: function () {
        console.log(this.x + this.y);
    }
};
var f1 = new Fn;
var f2 = new Fn;
console.log(f1.getX === f2.getX);
console.log(f1.getY === f2.getY);
console.log(f1.__proto__.getY === Fn.prototype.getY);
console.log(f1.__proto__.getX === f2.getX);
console.log(f1.getX === Fn.prototype.getX);
console.log(f1.constructor);
console.log(Fn.prototype.__proto__.constructor);
f1.getX();//=>this:f1  f1.x=>100
f1.__proto__.getX();//=>this:f1.__proto__(Fn.prototype)  Fn.prototype.x=>undefined
f2.getY();//=>this:f2  f2.y=>200
Fn.prototype.getY();//=>this:Fn.prototype  Fn.prototype.y=>400
f1.sum();//=>this:f1  f1.x+f1.y=>300
Fn.prototype.sum();//=>this:Fn.prototype  Fn.prototype.x+Fn.prototype.y=>undefined+400=>NaN
function fun() {
    this.a = 0;
    this.b = function () {
        alert(this.a);
    }
}
fun.prototype = {
    b: function () {
        this.a = 20;
        alert(this.a);
    },
    c: function () {
        this.a = 30;
        alert(this.a)
    }
};
var my_fun = new fun();
// my_fun.b();//=>私有的方法B  this:my_fun  my_fun.a =>'0'
// my_fun.c();//=>公有的方法C  this:my_fun  my_fun.a=30(把当前实例私有属性A修改为30) =>'30'
var my_fun2 = new fun;
console.log(my_fun2.a);
my_fun2.__proto__.c();//=>this:my_fun2.__proto__   my_fun2.__proto__.a=30(当前实例通过原型链在类的公有属性上增加了一个a:30)
console.log(my_fun2.a);
console.log(my_fun.__proto__.a);
function Foo() {
    getName = function () {
        console.log(1);
    };
    return this;
}
Foo.getName = function () {
    console.log(2);
};
Foo.prototype.getName = function () {
    console.log(3);
};
var getName = function () {
    console.log(4);
};
function getName() {
    console.log(5);
}
Foo.getName();//=>2 把FOO作为对象,找其私有属性
getName();//=>4 执行全局下的GET-NAME
Foo().getName();//=>1 先把FOO作为普通函数执行,把执行的结果调取GET-NAME在执行
getName();//=>1
new Foo.getName();//=>先获取Foo.getName的值(假设B),然后再new B()相当于创建B的实例 =>2  (new Foo.getName;一样的)
new Foo().getName();//=>new Foo()获取实例，把得到的实例在调取GET-NAME  =>3
new new Foo().getName();
//=>var f=new Foo()
//=>new f.getName();  =>new (f.getName)(); =>3
//obj.getX();//=>先获取obj的getX的属性值，然后把获取的值执行
// Function.prototype.call = function call(context) {
//     //=>call方法中的this:fn  call
//
//     //[native code]
//     //1、把指定函数中的THIS指向CONTEXT [把THIS中的THIS关键字指向CONTEXT]
//     //2、把指定函数执行 [把THIS执行]
//     this();
//
// };
// //=>以下都是让CALL方法执行
// // fn.call(opp);
// // fn.__proto__.call()
// // Function.prototype.call();
function fn1() {
    console.log(1);
}
function fn2() {
    console.log(2);
}
fn1.call(fn2);
/*
 * fn1.call：fn1这个Function的实例通过__proto__找到Function.prototype上的call方法,然后让call方法执行（传递fn2这个实参）
 *
 * 执行CALL的时候,CALL中的THIS:FN1,所以此处是把FN1执行,让FN1中的THIS指向FN2(只不过我们的FN1中不需要使用THIS) =>1
 */
fn1.call.call.call(fn2);
/*
 * fn1.call.call.call：依然是找到原型上的CALL方法,并且让CALL执行
 *   CALL中的THIS:fn1.call.call[原型上的CALL]
 *   CALL中的CONTEXT:FN2
 *
 *   让 [原型上的CALL(FN1.CALL.CALL)] 中的THIS指向 FN2
 *   让 [原型上的CALL(FN1.CALL.CALL)] 执行
 *      第二次执行原型上的CALL,只不过此时CALL中的THIS是FN2
 *          让FN2中的THIS指向UNDEFINED
 *          让FN2执行
 * =>2
 */
Function.prototype.call(fn2);
/*
 * 找到原型上的CALL方法,让CALL方法执行
 *   CALL执行：
 *   =>THIS:Function.prototype
 *   =>CONTEXT:fn2
 *
 *   把Function.prototype中的THIS关键字变为fn2
 *   让Function.prototype执行
 *
 * =>无输出
 */
Function.prototype.call.call.call(fn2);
/*
 * 等价于fn1.call.call.call(fn2)
 */