js隐式类型转换，预编译、递归、作用域，作用域链、闭包、立即执行函数、继承圣杯模式

隐式类型转换

调用Number（）
当有运算符（加减乘除，求余）时，会调用Number（）转为数字再运算，除了 加  当 有字符串时就变身成拼接
Boolean();
String();

typeof()string返回的类型

预编译

 在<script>里面的代码，进行预编译，将变量声明，，函数声明提高在逻辑的前面;执行代码时在GO（即window对象）中取出值，
var a = 1;
function text(){}
例如 Go{
　　a : undefined;
　　text : function(){}
}
当遇到函数的执行时(执行前一刻)，也会进行预编译，和上面差不多，，1将声明变量，形参赋值为undefined，2 将形参值传入  3 声明方法 
AO = （Active Object）
{

　　a : undefined;
　　text : function(){

}
ps：变量名和函数名相同时会覆盖

function text(a,b,c){

console.log(arguments.length)//arguments实参变量数组，可以拿到实际传入的变量值

console.log(text.length)//拿到形参个数

递归

就是找规律比如 ，，求阶乘  求n的阶乘，，
1 写出通式 f（n） = n * f(n-1); 2 找终止条件
function jiecheng(n) {
　　　if（ n == 1）{
　　　　　　return 1;
　　　　}

　　return n*jiecheng(n-1);
}

逻辑运算符

|| 寻找为真的表达式，，将值返回，不会再执行后面的表达式

&& 寻找假的表达式  将值返回，，不会再执行后面的表达式

作用域链

1、在函数声明后，，就会有  a[[scope]]生成，作用域链 例如数组 
2、函数执行时，生成Ao

function a(){   

　　function b(){   
　　}
}

定义时 A scope chain{0 : GO,}

执行时 A scope chain{0: ao ;1 : GO,}
执行完毕时，销毁引用，回到定义时状态

定义时 B scope chain{0 : A - ao ; 1 : GO}   它的出生在A中，，定义时，，就把A的执行Ao拿到自己B链中

执行时 B scope chain{0 : B - a0; 1 : A - a0;; 2 : GO}

执行完毕时，销毁引用，回到定义时状态

闭包

内部函数被外部函数返回出去，就会形成闭包；

function a(){

　　　　　　　var count = 1;

function b(){

var count+;

console.log(c)

}

return b;

}

var c = a();

c();

当内部函数不执行被返回时，b函数就拿者a函数的执行期的AO，..

1 可以当做缓存使用，累加器。不会污染全局变量

就相当两个函数拿着同样的test函数引用，

function text()

{

var cache = 50;

function add()

{

cache ++;

console.log(cache)

}

function remove()

{

cache --;

console.log(cache)

}

return [add,remove]

}

var myCache = text();

myCache[0]();

myCache[1]();

缺点：嵌套太深的话，就会造成内存泄漏

立即执行函数( 即表达式可以执行)

只要是表达式加上（）就会被立即执行并且忽略函数名,,函数失效

+ - ！可以把函数声明变为立即执行，执行后就失去了销毁

//立即执行函数，，只执行一次，，执行完就会销毁

        // 可以有返回值和
（） 为执行符号，，能执行表达式
（function() {} () ）;推荐写法
(function () {})();

        var a = (function (a,b){

            console.log("")

            return a*b;

        }(,))

        console.log(a)

圣杯模式

  //    圣杯模式，，继承

    Father.prototype.sex = "女";

    function Father()

    {

    }

    function Son()

    {

    }

    var inherit = (function (){

        var F = function(){};

        return function(Target,Origin)

        {

            F.prototype = Origin.prototype;

            Target.prototype = new F();       //prototype 是个对象，，直接赋值，指向的是同一个内存，，改变一个就会都会改变，new F()； 每次返回都是新的对象 防止父类被篡改

            Target.prototype.constuctor = Target;

            Target.prototype.super = Origin.prototype;

        }

    }());

    inherit(Son,Father);

    var son  = new Son();

    var father = new Father();