函数与作用域

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

ECMAScript规定了三种声明函数方式

---

• 构造函数
  首先函数也是对象的一种，我们可以通过其构造函数，使用new来创建一个函数对象

var sayHello = new Function("console.log('hello world');");

不推荐使用

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

  //函数声明
  function sayHello(){
    console.log('hello')
  }

  //函数调用
  sayHello()

声明不必放到调用的前面

• 函数表达式

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

  sayHello()

声明必须放到调用的前面

• 区别如下:
  1 .以函数声明的方法定义的函数，函数名是必须的，而函数表达式的函数名是可选的
  2 .以函数声明的方法定义的函数，函数可以在函数声明之前调用，而函数表达式的函数只能在声明之后调用
  3 .以函数声明的方法定义的函数并不是真正的声明，它们仅仅可以出现在全局中，或者嵌套在其他的函数中，但是它们不能出现在循环，条件或者try/catch/finally中，而函数表达式可以在任何地方声明

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

• 在一个作用域下，var 声明的变量和function 声明的函数会前置
• 不在函数作用域内,var声明的变量和function声明的函数都会前置到全局最顶部
• 在函数作用域内，var声明的变量和function声明的函数则会
  前置到函数体的最顶部

console.log(a)
console.log(ct)
var a = 2
function ct(){
    console.log(b)
    console.log(qcy)
    var b = 3
    function qcy (){}
    }
}
>前置后
var a
function ct(){
    var b
    function qcy (){}
    console.log(b)
    console.log(qcy)
    b = 3
    }
console.log(a)
console.log(ct)
a = 2
}

3. arguments 是什么

在函数代码中，使用特殊对象 arguments，开发者无需明确指出参数名，就能访问它们。

function qcy(){
    console.log(arguments[1]);
}
qcy(1,2,3)
>输出
2

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

js不支持重载，同名函数会覆盖，需要对参数进行非空或者类型的判断来模拟函数重载（可以用条件判断语句来实现）

function overLoading() {
　　// 根据arguments.length，对不同的值进行不同的操作
　　switch(arguments.length) {
　　　　case 0:
　　　　　　/*操作1的代码写在这里*/
　　　　　　break;
　　　　case 1:
　　　　　　/*操作2的代码写在这里*/
　　　　　　break;
　　　　case 2:
　　　　　　/*操作3的代码写在这里*/
 　　　　　　
　　//后面还有很多的case......
    }
}

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

立即调用函数表达式（英文：immediately-invoked function expression，缩写：IIFE）
，是一种利用 JavaScript 函数生成新作用域的编程方法。
立即调用函数表达式可以令其函数中声明的变量绕过JavaScript的变量置顶声明规则，还可以避免新的变量被解释成全域变量或函数名占用全域变量名的情况。与此同时它能在禁止访问函数内声明变量的情况下允许外部对函数的调用。有时，这种编程方法也被叫做“自执行（匿名）函数”，但“立即调用函数表达式”是语义上最准确的术语。

参考

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

function recursive(x){
  if (x === 1) return(1); 
  else return(x*recursive(x-1));
}
var n;
n = +prompt();
console.log('!n = ',recursive(n));

7. 以下代码输出什么？

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:男
["饥人谷", 2, "男"]
name valley
name:小谷
age:3
sex:undefined
["小谷", 3]
name valley
name:男
age:undefined
sex:undefined
["男"]
name valley

8. 写一个函数，返回参数的平方和？

 function sumOfSquares(){
    var sum = 0;
    for (var i=0;i<arguments.length;i++)
      sum+=arguments[i]*arguments[i];
    return sum;
   }
   var result = sumOfSquares(2,3,4)
   var result2 = sumOfSquares(1,3)
   console.log(result)  //29
   console.log(result2)  //10

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

  console.log(a);
  var a = 1;
  console.log(b);
  >
  undefined
  //报错，b未定义

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

  sayName('world');
  sayAge(10);
  function sayName(name){
    console.log('hello ', name);
  }
  var sayAge = function(age){
    console.log(age);
  };
>
hello world
//报错，sayAge不是一个函数

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

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

作用域链查找过程伪代码

1.
globalEC = {
  AO: {
    x: 10,
    foo: function,
    bar: function
  },
  Scope: null
}
foo.[[scope]] = globalEC. AO
bar.[[scope]] = globalEC. AO

2.
barEC = {
    AO: {
      x: 30
    }
    Scope: bar.[[scope]] = globalEC. AO
}

3.
fooEC = {
    AO: {
    }
    Scope: bar.[[scope]] = globalEC. AO
}

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

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

作用域链查找过程伪代码

1.
globalEC = {
  AO: {
    x: 10,
    bar: function
  },
  Scope: null
}
bar.[[scope]] = globalEC. AO

2.
barEC = {
    AO: {
      x: 30
      foo: function,
    }
    Scope: bar.[[scope]] = globalEC. AO
}
foo.[[scope]] = barEC. AO

3.
fooEC = {
    AO: {
    }
    Scope: foo.[[scope]] = barEC. AO
}

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

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

作用域链查找过程伪代码

1.
globalEC = {
  AO: {
    x: 10,
    bar: function
  },
  Scope: null
}
bar.[[scope]] = globalEC. AO

2.
barEC = {
    AO: {
      x: 30
      function(){}
    }
    Scope: bar.[[scope]] = globalEC. AO
}
function.[[scope]] = barEC. AO

3.
functionEC = {
    AO: {
    }
    Scope: function.[[scope]] = barEC. AO
}

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)
>
undefined
5
1
6
20
200

作用域链查找过程伪代码

1.
globalEC = {
  AO: {
    a: 1,
    fn: function
    fn3: function
  },
  Scope: null
}
fn.[[scope]] = globalEC. AO
fn3.[[scope]] = globalEC. AO

执行 fn()

2.
fnEC = {
    AO: {
      a: 5
      fn2: function,
    }
    Scope: bar.[[scope]] = globalEC. AO
}
fn2.[[scope]] =fnEC. AO

执行 fn3()

3.
fn3EC = {
    AO: {
    }
    Scope: fn3.[[scope]] = globalEC. AO
}

fn3()执行完毕跳回fn()
执行fn2()

4.
fn2EC = {
    AO: {
    }
    Scope: fn2.[[scope]] =fnEC. AO

fn2()执行完毕跳回fn()
fn()执行完毕跳回globalEC