函数（闭包）

函数

高内聚，弱偶合

定义

函数声明

如果函数名由多个字母组成，第一个单词的首字母小写，往后单词的首字母大写-theFirstName

函数表达式

• 命名函数表达式

var test = function abc() {

}

• 匿名函数表达式————函数表达式

var demo = function (){

}

组成形式

函数名称

参数

形参、实参

数量可以不一致，不会报错。

function example(a,b,c,d){}

example(1,2,3);

output: 123undefined

function example(a,b,c){}

example(1,2,3,4);
// arguments———— [1，2，3，4] ————实参列表—(类数组)

output: 123

function sum(a,b,c,d){
    if(sum.length > arguments.length){
        console.log('形参比实参多');
    }
    else if(sum.length < arguments.length){
        console.log('实参比形参多');
    }
    else {
        console.log('相等');
    }
}

function sum(){
    var result=0;
    for(var i = 0; i < arguments.length; i++){
        result += arguments[i];
    }
    console.log(result);
}
sum(1,2,3,4,5,6,7,8,9,0);

返回值

递归

预编译⭐

四步

1. 创建AO对象(Activation Object)

AO{
    a : 1;
    b : undefined;
}

2. 找形参和变量声明，将变量和形参名作为AO属性名，值为undefined

AO{
    a : function a(){};
    b : undefined;
    d : function d(){};
}

3. 将实参值和形参统一
4. 在函数体里面找函数声明，值赋予函数体

———————分割线———————

1. imply global暗示全局变量: 即任何变量，如果变量未经声明就赋值，此变量就为全局对象所有。
   e.g.: a = 123;
   e.g.: var a = b = 123;

2. 一切声明的全局变量，全是window的属性。
   e.g.: var a = 123; ===> window.a = 123;

window===GO就是全局的域。

函数声明整体提升
变量 声明提升(赋值不提升)

console.log(a);
var a=123;
output: undefined(不报错)

test();
function test(){
    console.log('a');
}
output: a(不报错)

function fn(a){
    console.log(a);//f a(){}
    console.log(b);//undefined
    console.log(d);//f d(){}
    var a = 123;
    console.log(a);//123
    function a(){}
    console.log(a);//123
    var b = function(){}
    console.log(b);//f (){}
    function d(){}
}
fn(1)
output:function a(){}
       

function a(a, b){
    console.log(a,b,d);//f a(){}//undefined//f d(){}//
    a = 123;
    var b = 234;
    console.log(a,b,d);//123//234//f d(){}
    var b = 345;
    function a(){}
    function d(){}
    console.log(a,b,d);//123//345//f d(){}
}
a(1);

GO{
    global : 100;
    fn : function(){...}
}
var global = 100;
function fn(){
    console.log(global);
}
AO{
    // 啥也没有往上找GO:global = 100
    // 执行fn打印global = 100
}
fn();

GO{
    // 有变量声明var global; ==> global = undefined
    /*global = 100; ==>*/ global : 100;
}
global = 100;
function fn(){
    console.log(global);
    global = 200;
    console.log(global);
    var global = 300;
}
AO{
    // 有变量声明var global; ==> global = undefined
    global : undefined;
    global : 200;
}
fn();
var global;

//百度笔试
GO{
    
}
function bar(){
    return foo;
    foo = 10;
    function foo(){
        //body...
    }
    var foo = 11;
}
console.log(bar());//functionfoo(){}

//百度笔试
console.log(bar());//11
function bar(){
    foo = 10;
    function foo(){
        //body...
    }
    var foo = 11;
    return foo;
}

console.log(b);//undefined
var b = function (){}
//var关键字只有声明提升了

(window.foo || (window.foo = 'bar'));
console.log(window.foo);//先读括号，bar

变量未经声明便赋值，归全局对象(GO)所有

闭包