函数与作用域

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

• 函数声明:function fn(){}; 函数表达式: var fn = function(){}
• 区别: 1. 函数声明必须有标识符，也就是常说的函数名；函数表达式可以省略函数名。2.函数声明会提前。3.函数声明语句可以出现在全局代码中，或者内嵌在其他函数中，但是不能出现在循环、条件判、或者try/finally以及with语句中。4.可以创建一个函数表达式即刻执行。

(function(){
alert('博主的名字是：myvin 。');
})()

这样可以使得全局变量不受局部变量的影响，保持全局的干净

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

• 解析器将当前作用域内声明的所有变量放到作用域的开始处，但是，只有变量的声明被前置了（值都为undefined），而赋值操作被保留在原处。
• JavaScript解析器允许在函数声明之前使用函数，此时不仅仅是函数名被前置了，整个函数定义也被前置了，所以就可以直接调用函数

arguments 是什么

• ECMAScript中的参数内部是用一个数组bi表示的，在函数体内可以通过arguments对象来访问这个参数数组，来获取传递给函数的每一个参数。arguments对象知识与数组类似（不是Array的实例），可以用方括号语法访问它的每一个元素，并且有length属性得到长度。arguments的值永远与对应命名参数的值保持同步。

函数的"重载"怎样实现

• ECMAScript没有函数签名，所以不可能实现重载。重名的函数自会被覆盖。可以在函数中加判断语句来模拟重载。例如根据判断参数的长度来模拟重载：

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

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

• 立即执行函数表达式是函数表达式(命名的或者匿名的)，在创建后立即执行；实现方式有下面几种：
  <pre><code>(function(){ /* code / }());
  (function(){ / code / })();
  // 括号和JS的一些操作符（如 = && || ,等）可以在函数表达式和函数声明上消除歧义
  // 如下代码中，解析器已经知道一个是表达式了，于是也会把另一个默认为表达式
  // 但是两者交换则会报错
  var i = function(){ return 10; }();
  true && function(){ / code / }();
  0, function(){ / code / }();
  // 如果你不怕代码晦涩难读，也可以选择一元运算符
  !function(){ / code / }();
  ~function(){ / code / }();
  -function(){ / code / }();
  +function(){ / code / }();
  // 你也可以这样
  new function(){ / code / }
  new function(){ / code */ }() // 带参数</code></pre>
• 它的目的有两个：一是不必为函数命名，避免了污染全局变量；二是IIFE内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。

求n!，用递归来实现

function fn(n){
    if(n<=1){
      return 1;
}else{
   return n*fn(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，男
["饥人谷", 2, "男", callee: function, Symbol(Symbol.iterator): function]
name，valley
name，小谷
age，3
sex，undefined
["小谷", 2, callee: function, Symbol(Symbol.iterator): function]
name，valley
name，男
age，undefined
sex，undefined
["男",callee: function, Symbol(Symbol.iterator): function]
name，valley

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

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

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

console.log(a);
var a = 1;
console.log(b);

-  输出undefined并且报错。由于变量声明提前，所以第一句输出undefined。因为b没有声明，所以第三句报错

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

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

-  输出hello  world并报错，因为函数声明提前，所以调用可以放在函数声明前面；函数表达式类似于变量声明，在函数表达式前调用等于undefined()，所以会报错

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

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

-  输出10

function foo(){}
function bar(){}
var x
x =10
/*全局执行上下文
globalContext = {
AO:{
x:10,
foo():function,
bar():function
},
Scope:null
}
//声明 foo 时 得到下面
foo.[[scope]] = globalContext.AO
//声明 bar 时 得到下面
bar.[[scope]] = globalContext.AO
/
bar()
/bar执行上下文
barContext = {
AO:{
x = 30
},
Scope: bar.[[scope]] //globalContext.AO
}
/
foo()
/foo执行上下文
fooContext = {
AO:{},
foo.[[scope]] = globalContext.AO //找到a =10
}
*/

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

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

-  输出30

function bar(){}
var x
x = 10
/*全局上下文
globalContext = {
AO:{
x : 10
bar() : function
},
Scope:null
//声明 bar 时 得到下面
bar.[[scope]] = globalContext.AO
}
/
bar()
/bar上下文
barContext = {
AO:{
x : 30
foo():function
},
Scope: bar.[[scope]] //globalContext.AO
//声明 foo时 得到下面
foo.[[scope]] = barContext.AO
}
/
foo()
/foo()上下文
fooContext = {
AO:{},
foo.foo.[[scope]] = barContext.AO //在barContext中找到下= 30
}
*/

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

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

-  输出30

function bar(){}
var x
x = 10
/*gloabContext = {
AO:{
x;10,
bar():function
},
Scope:null
//bar.[[scope]]=gloabContext.AO
｝
/
bar()
/
barContext = {
AO:{
x:30,
匿名函数:function
},
bar.[[scope]] = globalContext.AO
// 匿名函数[[scope]]=barContext.AO
}
*/
匿名函数是立即执行函数，在barContext.AO中找到x =30

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

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

function fn(){}
function fn3(){}
var a
a = 3
/globalContext = {
AO:{
a:3
fn():function,
fn3():function
},
Scope:null
//fn[[scope]]=globalContext.AO
//fn3[[scope]]=globalContext.AO
}/
fn(){
function fn2(){}
var a
console.log(a) //输出undefined
a = 5
console.log(a) //输出5
a++ //a = 6
fn3() //输出1 赋值globalContext.AO的a=200
fn2() //输出6 赋值fnContext.AO的a=20
console.log(a) //输出20
}
/fnContext = {
AO:{
fn2():function,
a:6
},
Scope:globalContext.AO
//fn2[[scope]]=fnContext.AO
}/
/fn2Context = {
OA:{},
Scope:fnContext.AO //a未定义，在globalContext.AO中找到a=6
}/
/fn3Context = {
OA:{},
Scope:globalContext.AO //a未定义，在globalContext.AO中找到a=1
}/
console.log(a) //输出200