函数与作用链

1.函数声明和函数表达式有什么区别

• 函数声明，使用Function关键字可以声明一个函数

function sayHello(){
  console.log("hello")
}
sayHello()

• 函数表达式，使用var之类的关键字定义

var sayHello =function(){
  console.log("hello")
}
sayHello()

区别：函数声明中，声明不必放在调用的前面；函数表达式中，声明必须放在调用的前面。

2.什么是变量的声明前置？什么是函数的声明前置

在一个作用域下，var 声明的变量和function 声明的函数会前置

console.log(a);
var a = "chen";

在这过程中，变量的声明会前置，变成

var a;   //  结果undefined
console.log(a);
a = "chen";

这就是为什么单独输入console.log(a);会报错，但再后面加上var声明变量，可以显示结果。

test
function 声明的函数会前置，先声明后运算。

3.arguments 是什么？

在函数内部,你可以使用arguments对象获取到该函数的所有传入参数，也可以相应地选择一些参数。

test

4.函数的"重载"怎样实现？

• 针对其他强类型的语言，函数名虽然重复，但变量的类型是固定的，如数值类型对应int，字符串对应string。

• 对js来讲，没有重载! 同名函数会覆盖。 但可以在函数体针对不同的参数调用执行相应的逻辑

  
  同名函数覆盖

5.立即执行函数表达式是什么？有什么作用？

一般的

function sayHello(name){
  console.log("hello"+name)
}
sayHello("css")

立即执行函数表达式

(function sayHello(name){
  console.log("hello"+name)
})("css")

作用：隔离作用域；省略函数名；包裹模块，避免污染全局变量

6.求n!，用递归来实现

 function factor(n) {
    if(n<=0){
     return  console.log('n不可小于或等于0')
}
    if(n==1){
         return n
     }
     return n*factor(n-1)
 }

7

1.当执行getInfo('饥人谷', 2, '男');时

function getInfo(name, age, sex){
        console.log('name:',name);     // name:饥人谷
        console.log('age:', age);    // age:2
        console.log('sex:', sex);    // sex:男
        console.log(arguments);    // ['饥人谷', 2, '男']
        arguments[0] = 'valley';      //（arguments[0] 值为 '饥人谷'， 将 'valley'值赋值给'饥人谷'） 
        console.log('name', name);    // name，valley
    }

2.当执行getInfo('小谷', 3);时

function getInfo(name, age, sex){
        console.log('name:',name);     // name:小谷
        console.log('age:', age);    // age:3
        console.log('sex:', sex);    // sex: undefined
        console.log(arguments);    //  ['小谷', 3]
        arguments[0] = 'valley';      
        console.log('name', name);    // name，valley
    }

3.当执行getInfo('男');时

function getInfo(name, age, sex){
        console.log('name:',name);     // name:男
        console.log('age:', age);    // age: undefined
        console.log('sex:', sex);    // sex: undefined
        console.log(arguments);    // ['男',undefined,undefined]
        arguments[0] = 'valley';      
        console.log('name', name);    // name，valley
    }

8

function sumOfSquares(){
       var sum=0;
       for(var i=0;i<arguments.length;i++) {
            sum+=arguments[i]*arguments[i];
           
       }
       return sum
   }
   sumOfSquares(2,3,4)
   sumOfSquares(1,3)

9

console.log(a);   //var=a，变量声明前置，但未赋值，结果显示为undefined。
    var a = 1;
    console.log(b);  //出现报错，`b is not defined`

10

sayName('world');
sayAge(10);
function sayName(name){
    console.log('hello ', name);
    }          //Function声明的函数前置，执行sayName('world')，结果：hello,world
var sayAge = function(age){
    console.log(age);
    };  //结果出现报错，原因：函数表达式必须放在声明的前面。

11

1.globalcontext={
  AO:{
    x:10
    foo:function
    bar:function
  },
  scope: null
}
声明foo时得到下面
foo.[[scope]]=globalcontext.AO
声明bar时得到下面
bar.[[scope]]=globalcontext.AO

2.执行bar时产生下面
barcontext={
  AO:{
    x:30
  },
  Scope: bar.[[scope]] =globalcontext.AO
}
3.执行foo时产生下面
foocontext={
  AO:{}，
  Scope: foo.[[scope]] = globalcontext.AO
}
**最终结果为`console.log(10)`，为10**

12

1.globalcontext={
  AO:{
    x:10
    bar:function
  },
  Scope:null
}
声明bar时得到：bar.[[Scope]]=globalcontext
2.执行bar时产生下面
barcontext={
  AO:{
    x:30
    foo:function
  },
  Scope:bar.[[Scope]]=globalcontext
}
Scope:foo.[[Scope]]=barcontext
3.执行foo时产生下面
foocontext={
  AO:{},
  Scope:foo.[[Scope]]=barcontext
}
console.log(10)结果为10

13

1.globalcontext={
  AO:{
    x:10
    bar:function
  }
}
声明bar时产生bar.[[Scope]]=globalcontext.AO
2.barcontext={
  AO:{
    x:30
    (function)
  }
}
Scope:(function).[[Scope]]=barcontext.A0
3.(function)context={
  AO:{}
  Scope:(function).[[Scope]]=barcontext.A0
}
4.最终结果console.log(30),结果为30

14

1.globalcontext={
  AO:{
    a:1
    fn:function
    fn3:function
  },
}
fn.[[Scope]]=globalcontext.AO
fn3.[[Scope]]=globalcontext.AO
2.fncontext={
  AO:{
    声明前置var=a
    console.log   //undefined
    a=5
    console.log    //5
    a:6(a++后)
    (fn3、fn2开始执行)
    fn2：function
  }
fn2.[[Scope]]=fncontext.AO  
}
3.fn3context={
  AO:{}
  console.log   //1(来着于globalcontent.AO)
}
a=200声明，  //globalcontent.AO中的a为200
4.fn2context={
  AO{}
  console.log   //6(来着于fncontext.AO)
}
a=20声明   //fncontext.AO中的a为20
执行console.log  //20
}
5.fn运算结束，执行console.log，结果为200
运行fn2
6.结果依次为：undefined、5、1、6、20、200