javascript基础学习笔记1

预编译

1. 执行AO对象（Activation Object）
2. GO全局对象（Gloable Object）
3. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined
4. 将实参值和形参统一
5. 在函数体里面找函数证明，值赋予函数体
6. AO有就用AO，（GO现有，AO后有）

[[scoped]]

1. 作用域链，里面有多个AO,GO

function a(){
    function b(){
        function c(){

        }
        c();
    }
    b();
}
a();
a:defined [[scoped]] ---- 0:GO
a:doing   [[scoped]] ---- 0:aAO , 1:GO
b:defined [[scoped]] ---- 0:aAO , 1:GO
b:doing   [[scoped]] ---- 0:bAO , 1:aAO , 2:GO
c:defined [[scoped]] ---- 0:bAO , 1:aAO , 2:GO
c:doing   [[scoped]] ---- 0:cAO , 1:bAO , 2:aAO , 3:GO

闭包

当内部函数被保存到外部时，将会产生闭包。闭包会导致原有作用域链不释放，造成内存泄露。

1. 实现公有变量
   函数累加器
2. 可以做缓存(存储结构)
   eater
3. 可以实现封装，属性私有化
   Person()
4. 模块化开发，防止污染全局变量

函数累加器

function a(){
    var i=0;
    function b(){
        i++;
        console.log(i);
    }
    return b;
}
var demo = a();
demo();
demo();

eater

function eater() {
    var food = ""；
    var object = {
        eat : function(){
            console.log("i am eating"+food);
            food = "";
        }
        push : function(myFood){
            food = myFood;
        }
    }
}

私有化变量

function Person(wife) {
    var propertyWife = "b";
    this.wife = wife;
    this.property = function() {
        this.wife = propertyWife;
    }
    this.changeWife = function(target) {
        propertyWife = target;
    }
    this.sayWife = function(){
        console.log(propertyWife);
    }
}

试题

function a() {
    function b() {
        var bbb = 234;
        document.write(aaa);
    }
    var aaa = 123;
    return b;
}
var glob = 100;
var demo = a();
demo();

输出123

对象

为什么原始值不能用对象，但是能访问里面的值？

var str = 'abc';
str.len = 3;
//因为在这里进行了包装类。
//new String('abc').len = 3 delete;
console.log(str.len);
//new String('abc').len; defined

原型链(prototype)继承

原型也是对象

function Person() {
    var this = {
        //__proto__ : Person.prototype
    }
}

每个构造函数都有隐世的proto属性，都指向原型链，当然可以更换。new Person().proto = new Son()

原型链的proto为Object.prototype,Object.prototype为所有原型链的终端。

原型链下的构造函数的增删改查

1.增 会在自己的构造器内增加函数
2.删 删除自己构造器内的
3.改 会在自己的构造器生成然后修改
4.查 可以查原型的

Object.create(原型)生成对象

参数原型只能是object和null。如果为null，就会生成没有任何结构的对象(没有__proto__)

apply/call方法

每个函数都有来自非继承来的方法，call和apply。

他们的主要用途是拷贝其他构造函数的用途，变量给自己。

function Person(name,sex,age) {
    this.name = name;
    this.sex = sex;
    this.age = age;
}

function Docoter(name,sex,age,job) {
    Person.call(this,name,sex,age);
    this.job = job;
}

//不new就call方法就没什么用,因为需要传this
var doctor = new Doctor("陈侑","男","23","医生");

fighting!!!