函数与作用域

1.函数声明和函数表达式有什么区别?
函数声明：function functionName(){}
函数表达式：var fn = function(){}
函数声明会提前，不论执行语句的位置在哪皆可调用该函数。函数表达式必须在表达式执行完后，函数才存在并可以被调用。
函数声明会提前，函数表达式可以省略标识符（函数名）。

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

在同一个作用域下，var 声明的变量和 function 声明的函数会前置，也就是不管这些声明在作用域的什么地方，JavaScript 的解析器先统一把它们全部按顺序放在执行上下文的最前面，先赋值为undefined，再按顺序执行语句然后才开始执行后面的语句。

函数声明前置：JS自动把function声明的函数提到前面，因此调用函数时不需要考虑函数调用与声明的位置关系
在 JavaScript 中，只有全局作用域和函数作用域，没有块作用域
在函数作用域中，var 声明的变量和 function 声明的函数也会前置，跟在全局作用域中的行为一致

arguments 是什么
是一个类数组对象，它包含了函数的所有实参。
argument是类数组对象，每个函数中都存在argument对象，argument并不是一个真正的数组，所以不具备除length属性之外的属性，这个对象维护着所有传入该函数的参数列表，通过arguments[1、2、3]等...可以获取到相应的传入参数

function foo(a,b) {
 console.log(a);
console.log(b);
console.log(arguments);
}
foo(1,2);
//1
//2
//[1, 2]

函数的"重载"怎样实现
重载是函数具有相同的名字，根据传入的参数不同，执行不同操作。在js中没有类似其他语言的重载，因为同名函数会被覆盖。但是js可以通过在函数内部对传入参数进行判断来达到重载的目的。
所谓重载，就是定义两个或多个同名的函数，分别设置不同的参数个数、类型。在调用函数时，通过检测传入参数的个数、类型，来执行不同的函数体语句，以达到一个函数名，多种用法的目的。
但是在 JavaScript 中，没有重载。同名函数，前面声明的会被后面声明的覆盖，不过可以在函数体内部，针对不同的参数调用，执行相应的逻辑（用 if 语句判断）。

function fn(name,age,sex) {

 if (name) {
 console.log(name);
}
if (age) {
 console.log(age);
}
if (sex){
 console.log(sex);
}
}
fn('luoqian');
fn('luoqian',21);
fn('luoqian',21,'female');

function doAdd() {
  if(arguments.length == 1) {
    alert(arguments[0] + 5);
  } else if(arguments.length == 2) {
    alert(arguments[0] + arguments[1]);
  }
}
doAdd(10);        //输出 "15"
doAdd(40, 20);    //输出 "60"

立即执行函数表达式是什么？有什么作用？
立即执行函数表达式就是声明一个函数，同时马上调用它，把声明和调用合用写成一个语句。
它有多种写法：
(function() {})();
(function() {});
[function() {}];
1, function() {};
它的作用：隔离作用域，避免变量污染全局

求n!，用递归来实现

递归的思想：是指在函数在定义中自己调用自己
一个比喻帮助理解：我们查词典的过程就是递归，为了解释一个词，需要使用更多的词。当你查一个词，发现这个词的解释中某个词仍然不懂，于是你开始查这第二个词，可惜，第二个词里仍然有不懂的词，于是查第三个词，这样查下去，直到有一个词的解释是你完全能看懂的，那么递归走到了尽头，然后你开始后退，逐个明白之前查过的每一个词，最终，你明白了最开始那个词的意思。
类推：n的阶乘，就是n乘(n-1)的阶乘，一直顺推到1的阶乘是1，作为终止条件。再逆推2的阶乘是2x(1的阶乘)),3的阶乘是3x(2的阶乘)，4的阶乘是4x(3的阶乘)......

function factor(n){
if (n === 1) { return 1 }//终结点
return n * factor(n-1);
}

console.log(factor(4)); //输出24；
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, '男');
/* name: 饥人谷
   age: 2
   sex: 男
   ["饥人谷", 2, "男"]
   name valley
*/

getInfo('小谷', 3);
/* name: 小谷
   age: 3
   sex: undefined
   ["小谷", 3]
   name valley
*/

getInfo('男');
/* name: 男
   age: undefined
   sex: undefined
   ["男"]
   name valley
*/

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

function foo(){
var result = 0;
for(var i = 0; i < arguments.length;i++){

       result +=arguments[i]*arguments[i]
    }
return result
}
foo(3,4)//25

9.如下代码的输出？为什么
console.log(a); //声明提前，但是未赋值所以为undefined
var a = 1;
console.log(b); //会报错，b is not defined

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

sayName('world'); //hello world,因为函数声明前置
sayAge(10); //sayAge is not a function函数表达式只将函数表达式里的sayAge前置，此时还未赋值，所以以函数的方式调用会报错
function sayName(name){
    console.log('hello ', name);
}
var sayAge = function(age){
    console.log(age);
};

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

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

globalContext = {
    AO :{
        x:10,
        foo：function(){}
        bar:function(){}
    },
    Scope:null
}
foo.[[scope]] = globalContext.AO
bar.[[scope]] = globalContext.AO

barContext = {
    AO:{
        x:30
    },
    Scope:bar.[[scope]]//globalContext.AO
}
fooContext = {
    AO:{},
    scope:foo.[[scope]] //globalContext.AO
}

以下代码会输出什么？

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

globalContext ={
    AO:{
        x:10,
        bar:function(){}
    },
    Scope:null
}
//函数声明时候就会得到下面
bar.[[scop]] = globaltext.AO
bartContext ={
    AO:{
      x:30,
    },
    Scope:bar.[[scop]] = globaltext.AO
}
function.[[scope]]=barCOntext
functionCOntext = {
    AO:{}
    scope:function.[[scope]]=barContext.AO

}

在匿名函数的AO中找不到x,于是从scope指向的barContext.AO上找找到x=30所以输出的是30

下面代码会输出什么
var a = 1;

function fn(){
console.log(a)//underfined
var a = 5
console.log(a)//5
a++
var a

fn3()
fn2()
console.log(a,'a')//20

function fn2(){
console.log(a)//6
a = 20
}
}

function fn3(){
console.log(a)//1
a = 200
}

fn()
console.log(a)//200

globalContext ={
    AO:{
        a:1=>200,
        fn:function(){}
        fn3:function(){}
    },
    Scope:null
}
fn.[[scope]]=globalContext.AO
fn3.[[scope]]=globalContext.AO
fnContext = {
    AO:{
        a:undefined =>5=>6=>20,
        fn2:function(){}
    },
    Scope:fn.[[scope]]=globalContext.AO
}
fn2.[[scope]] =fnContext.AO

fn2Context ＝{
    AO:{

    },
    Scope:fn2.[[scope]]=fnContext.AO
}
fn3Context = {
    AO:{

    },
    Scope:fn3.[[scope]]=globalContext.AO
}

函数与作用域

推荐阅读更多精彩内容