隐式类型转换
调用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();