函数与作用域

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

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

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

  var sayHello = new Function("console.log('hello world');");//不推荐使用

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

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

  //函数调用
  sayHello()
//声明不必放到调用的前面

• 函数表达式

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

  sayHello()
//声明必须放到调用的前面

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

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

console.log(a); //undefined
var a = 3;
console.log(a); //3

sayHello();

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

• 函数内部的声明前置

function fn(){
  console.log(a)  //undefined
  var a = 3
  console.log(a)
}
fn()

arguments 是什么

函数的"重载"怎样实现

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

function printPeopleInfo(name, age, sex){
    if(name){
      console.log(name);
    }

    if(age){
      console.log(age);
    }

    if(sex){
      console.log(sex);
    }
  }


  printPeopleInfo('Byron', 26);
  printPeopleInfo('Byron', 26, 'male');

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

• 立即执行函数表达式

(function(){
  var a  = 1;
})()
console.log(a); //undefined

• 作用： 隔离作用域

求n!，用递归来实现

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

factor(5)

以下代码输出什么？

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: 男
Arguments[3]
//
name valley
name: 小谷
age: 3
 sex: undefined
//
name valley
name: 男
age: undefined
sex: undefined
//
name valley

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

   function sumOfSquares(){
        var sum=0;
             for(var key in arguments){
              sum+=arguments[key]*arguments[key]

    }
   return sum;
   }
   var result = sumOfSquares(2,3,4)
   var result2 = sumOfSquares(1,3)
   console.log(result)  //29
   console.log(result2)  //10

如下代码的输出？为什么

    console.log(a);//undefined
    var a = 1;
    console.log(b);// b is not defined
/*
此代码执行顺序为：
var a -> console.log(a) 结果为 undefined
-> a = 1 -> console.log(b) 报错，"b"  未定义 
*/

如下代码的输出？为什么

    sayName('world');
    sayAge(10);
    function sayName(name){
        console.log('hello ', name);
    }//hello  world
    var sayAge = function(age){
        console.log(age);
    };/*sayAge is not a function：var sayAge 变量声明前置，
但只会声明此变量不会将其赋值为函数，所以函数 sayAge 的调用必须在函数赋值之后，否则会报错。*/

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

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

/*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() 时，先从 bar 执行上下文中的 AO里找，找不到再从 bar 的 [[scope]]里找

找到后即调用
当调用 foo() 时，进入 foo 的执行上下文

fooContext = {
  AO: {},
  Scope: foo.[[scope]] // globalContext.AO
}

所以 console.log(x)是 10
*/

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

var x = 10;
bar() 
function bar(){
  var x = 30;
  function foo(){
    console.log(x) 
  }
  foo();
}   
/*globalContext = {
  AO: {
    x: 10
    bar: function
  },
  Scope: null
}

//声明 bar 时 得到下面
bar.[[scope]] = globalContext.AO

注意： 在当前的执行上下文内声明的函数，这个函数的[[scope]]就执行当前执行上下文的 AO

当调用 bar() 时， 进入 bar 的执行上下文

barContext = {
  AO: {
    x: 30,
    foo: function
  },
  Scope: bar.[[scope]] //globalContext.AO
}
//在 bar 的执行上下文里声明 foo 时 得到下面
foo.[[scope]] = barContext.AO
当调用 foo() 时，先从 bar 执行上下文中的 AO里找，找到后即调用

笔试题
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); 

当调用 bar() 时， 进入 bar 的执行上下文

barContext = {
  AO: {
    x: 30,
    foo: function
  },
  Scope: bar.[[scope]] //globalContext.AO
}
//在 bar 的执行上下文里声明 foo 时 得到下面
foo.[[scope]] = barContext.AO

当调用 foo() 时，先从 bar 执行上下文中的 AO里找，找到后即调用

当调用 foo() 时，进入 foo 的执行上下文

fooContext = {
  AO: {},
  Scope: foo.[[scope]] // barContext.AO
}

所以 console.log(x)是 30
*/

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

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

/*
(function (){
    console.log(x)
  })()等同于
var f =function (){
}f();

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

barContext = {
AO: {
    x: 30
    function()
},
function.[[scope]] = barContext.AO
Scope: globalContext.AO
}

functionContext = {
AO: {},
Scope: barContext.AO
}
barContext.AO{x = 30}
输出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)

/*
globalContext = {
AO: {
    a:200;
    fn: function
   fn3 :function      
}

}
fn.[[scope]] = globalContext.AO
fn3.[[scope]] = globalContext.AO
fnContext = {
AO: {
    a: 20
},
scope:globalContext.AO
}
fn2.[[scope]] =fnlContext.AO

fn3Context = {
AO: {
    a: 20
    fn2:function(){}
},
scope:globalContext.AO
}

fn2Context = {
AO: {
    a: 
    fn2:function(){}
},
scope:globalContext.AO
}
//undefined 5 1 6 20 200
*/