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

• 函数声明，使用"function"关键字声明；函数表达式，使用"var 函数名=function(){}"
• 函数表达式必须要放到调用之前，而函数声明不需要，即函数声明会前置。

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

代码运行的时候，在同一个作用域下，对于var声明的变量和function声明的函数会被前置声明，值为undefined，然后再逐行运行代码。

函数有作用域，在函数内部，也会出现声明前置。

arguments是什么？

在函数内部，可以使用arguments获取到该函数的所有传入参数，并以对象的形式展示。例：

task3.png

函数的重载怎样实现？

在js中没有重载，对重名函数，重新声明会发生覆盖。但是，可以在函数内部针对不同的参数调用不同的逻辑。例：

task3-1.png
task3-2.png

立刻执行函数表达式是什么？有什么用？

使用括号，JS会将函数声明变成函数表达式，并会立刻执行
还可以通过对函数添加一些运算符，使之变成表达式立刻执行。
函数是一个作用域，在函数内部进行的设置不会对全局变量造成影响。

(function test(){})
(function test(){})()    /*直接加括号*/
[function test(){}]()    /*变成数组*/
{function test(){}}()    /*变成对象*/
1,function test(){}()    /*使用逗号*/
!function test(){}()    /*使用！*/

求 n!，用递归来实现

function f(n){
  if(n === 1) {return 1};
  return n*f(n-1);
}

以下代码输出什么？

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

  getInfo('饥人谷', 2, '男');
getInfo('小谷', 3);
getInfo('男');

结果：

name: 饥人谷
age: 2
sex: 男

name valley
name: 小谷
age: 3
sex: undefined

name valley
name: 男
age: undefined
sex: undefined

写一个函数，返回参数的平方和。

function sumOfSquares() {
  var sum = 0;
  for(var i = 0; i<arguments.length; i++) {
    sum = sum + arguments[i]*arguments[i]
  }
  console.log(sum)
}

var result1 = sumOfSquares(2,3,4)
var result2 = sumOfSquares(1,3)
console.log(result1)
console.log(result2)

如下代码的输出？为什么？

console.log(a);  //1
var a = 1;
console.log(b);  //报错

声明前置，a被声明，且为1，console.log（a）输出1；
b没有声明，会报错，b is not defined

如下代码的输出？为什么？

sayName('world');  //hello world
sayAge(10);  //报错
function sayName(name){
console.log('hello',name);
}
var sayAge = function(age){
console.log(age);
}

函数声明会有声明前置，所以sayName（）是被声明的；
函数表达式没有声明前置，在执行sayAge（）时，函数没有被声明，所以会报错。sayAge is not a function

11. 如下代码输出什么? 写出作用域链查找过程伪代码。

var x = 10
bar()
function foo() {
  console.log(x)
}
function bar(){
  var x = 30
foo()
}

1
globalContext = {
 AO: { 
  x: 10
  foo: function
  bar: function
  }
}
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO

2
barContext = {
  AO: {
    x: 30
    }
  scope: bar.[[scope]] = globalContext.AO
}

3
fooContext = {
  AO: {}
  scope: foo.[[scope]] = globalContext.AO
}
所以结果为10

12. 如下代码输出什么? 写出作用域链查找过程伪代码

var x = 10;
bar()
function bar(){
  var x = 30;
  function foo(){
    console.log(x)
  }
  foo();
}

1
globalContext {
  AO: {
    x: 10;
    bar: function;}
}
bar.[[scope]] = globalContext.AO

2
barContext {
  AO: {
    x: 30
    foo: function
  }
scope: bar.[[scope]] = globalContext.AO
}
foo.[[scope]] = barContext.AO

3
fooContext {
  AO: {}
  scope: foo.[[scope]] = barContext.AO
}

所以结果为30

13. 以下代码输出什么? 写出作用域链的查找过程伪代码

var x = 10;
bar()
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}

1
globalContext {
  AO: {
    x: 10;
    bar: function
    }
}
bar.[[scope]] = globalContext.AO

2
barContext {
  AO: {
    x:30
    console.log(x): 30  //输出
  }
scope: bar.[[scope]] = globalContext.AO
}

所以结果为30

14. 以下代码输出什么？ 写出作用域链查找过程伪代码

var a = 1;

function fn(){
  console.log(a)
  var a = 5
  console.log(a)
  a++
  var a
  fn3()
  fn2()
  console.log(a)
  
  function fn2(){
    console.log(a)
    a = 20
  }
}
function fn3(){
   console.log(a)
  a = 200
}

fn()
console.log(a)

1
globalContext {
  AO: {
    a: 1
    fn: function
    fn3(): function
  }
}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO

2
fnContext {
  AO: {
    a: 5
    fn2: function
  }
scope: fn.[[scope]] = globalContext.AO
}
fn2.[[scope]] = fnContext.AO

fn3Context {
  AO: {
  }
scope: fn3.[[scope]] = globalContext.AO
}

fn2Context {
  AO: {
  }
scope: fn2.[[scope]] = fnContext.AO
}

所以结果
fn()  //undefined 5 1 6 20
console.log(a) //200

对于undefined：声明前置，会声明var a，此时a为undefined

对于fn2() //6：fn3()运行后，对a赋值，此时globalContext.AO{a:200}，但是，函数是一个作用域链，对于fn2()，a++后，fnContext.AO{a: 6}

对于20：fn2()运行后，对a赋值，所以此时的fnContext.AO{a: 20}