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