20170103作业

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

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

function sayHello() {
  console.log('hello')
}
// 函数调用
sayHello()

声明不必放到调用的前面（可以放在全局作用域里面的任何位置）例如：

sayHello()  //hello jirengu
sayHello() //hello jirengu
//调用了两次
var a = 1;
function sayHello() {
console.log('hello')
console.log('jirengu')
}

函数表达式

//把命名函数function()赋值给了变量sayHello
var sayHello = function() {
  console.log('hello');
}  // 这就是函数表达式，相当于把functions(){console.log('hello');} 这个值赋值给sayName。
sayHello()

声明必须要放到调用的前面
什么是声明前置
变量声明前置——指的是解析器将当前作用域内声明的所有变量放到作用域的开始处，但是，只有变量的声明被前置了，而赋值操作被保留在原处，

console.log(name);  // undefined;  
var name="wmsj100";
console.log(name);  // "wmsj100";

因为变量的声明被前置了，但是赋值操作被保留在原处，所以这段代码和下面的效果是一样的：

var name;
console.log(name);  //已经被声明但未赋值的变量会被自动赋值undefinde;
name = "wmsj100";  //  进行赋值操作
console.log(name);  //"wmsj100"

函数声明前置——JavaScript解释器允许在函数声明之前使用函数，此时不仅仅是函数名被前置了，整个函数定义也被前置了，所以就可以直接调用函数：

sayHi();  //"hello world" 
function sayHi(){
    console.log("hello world");
}

和下面这段代码是等效的：

function sayHi(){
    console.log("hello world");
}
sayHi();  //因为函数sayHi已经声明，所以此时直接输出"hello world"

求n!，用递归来实现

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

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

立即执行函数描述：

立即执行函数是一种语法，可以让函数在定义后立即被执行，

(function(){
        console.log(1);
    }()); // 1

这种模式本质上就是函数表达式（命名的或者匿名的），在创建后立即执行；
立即执行函数术语不是在ECMAScript标准中定义的，但它很短有助于描述和讨论模式，这种模式由以下几部分组成：
- 使用函数表达式定义一个函数（函数声明不能起作用）；
- 在结尾加上一对括号，让函数立即执行；
- 将整个函数包裹在一对括号中（只有在不将函数赋值给变量的时候才需要）；
立即执行函数可以包含参数；

(function(name,age){
        console.log("姓名："+name+" ; "+"年龄："+age+"!");
    }("wmsj100",28));
    // 姓名：wmsj100 ; 年龄：28!

像其它任何函数一样，立即执行函数也可以返回值并且把值赋给其它变量；

var infor=function(){
        return "wmsj100";
    }();    //把函数的返回值"wmsj100"赋值给infor；
    console.log(infor); //"wmsj100";

立即执行函数作用；

立即执行函数模式被广泛使用，它可以封装大量的工作而不会在背后遗留任何全局变量；定义的所有变量都会成为立即执行函数的局部变量，所以不必担心这些临时变量会污染全局空间；
这种模式也可以将独立的功能封装在自包含模块中。假如页面是稳定的并且在没有JS情况下能正常工作，然后本着逐步加强的想法，你加入了一些代码加强页面某个方面；你可以将这些代码封装进一个立即执行函数中，并且确保页面在没有它们的时候也可以正常工作。

参考文献——立即执行函数

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

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

输出结果为10.

作用域链查找过程伪代码:
globalContext = {
  AO : {
    x = 10
    foo : function
    bar : function
  }
  scope: null
}
// 当调用bar()时进入bar的执行上下文
barContext = {
  AO : {
    x : 30
  }
  scope : bar.[[scope]] //globalContext.AO
}
// 找到var x = 30 之后，它调用foo(),这时进入foo()的执行上下文
fooContext = {
  AO : {}
  scope : foo.[[scope]] //globalContext.AO
}
// 因为fooContext中的AO为空，这时我们就去scope里面找，在globalContext中的AO里我们得到x : 10; 
所以最终输出结果为10.

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

var x = 10;
bar() // 输出什么
function bar(){ 
    var x = 30; 
    function foo(){
       console.log(x)
   } 
foo();
}
// 输出结果为10
// 作用域链查找过程伪代码
globalContext = {
    AO: {
      x: 10
      bar : function
   }
}
bar.[[scope]] = globalContext.AO

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

fooContext = {
    AO: {}
    scope: foo.[[scope]] = barContext.AO
}
// 所以console.log(x) 输出结果为30.

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

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

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

var a = 1;

function fn(){
  console.log(a);  // undefined
  var a = 5;
  console.log(a);  //5
  a++;
  var a;
  fn3(); //1
  fn2(); //6
  console.log(a);//20

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

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

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


执行：
1. 
globalContext = {
    AO: {
        a: 200,//变化顺序是undefined, 1，200
        fn: function(){},
        fn3: function(){}
    }
}
fn.[[scope]] = globalContext.AO;
fn3.[[scope]] = globalContext.AO;
2. 
fnContext = {
        AO: {
            a: 20,//变化顺序是undefined,5,6,20
            fn2: function(){},
        },
        scope: fn.[[scope]]  
}
fn2.[[scope]] = fnContext.AO;
3.
fn3Context = {
        AO: {},
        scope: fn3.[[scope]]  
}
4.
fn2Context = {
    AO: {},
    scope: fn2.[[scope]]
}
控制台输出结果顺序为：undefined 5 1 6 20 200

邮件待看：
// 函数声明和函数表达式有什么区别
function a() {
} // 函数表达式(函数声明是和var类似会被前置的哦)
var aa = function () {
}; // 函数声明(不会被前置)

// 3. 求n!，用递归来实现
function factorial(n) {
    if (n === 1) {
        return 1;
    } else if (n > 1) {
        return n * factorial(n - 1)
    } else {
        return 'No result.';
    }
}

/*
 * 什么是立即执行的函数表达式？有什么作用？
 * 匿名，立刻执行自己
 */

var x = 10;
bar() ;//  输出30
function bar(){
    var x = 30;
    (function (){
        console.log(x); // 当前作用域没有，查找上一级作用域，找到x = 30;
    })()
}

var a = 1;

function fn() {
console.log(a); // undefined,下面声明的a前置上去
var a = 5;
console.log(a); //5 正常获得当前作用域的5
a++; // 当前作用域的a变成2了
var a; // 无视这个，顶最顶上面去了
fn3(); //1
fn2(); //6
console.log(a);//20

function fn2() {
    console.log(a); // 上一级是fn函数，所以是6
    a = 20;
}

}

function fn3() {
console.log(a); // 上一级是全局作用域，拿全局作用域的a
a = 200; // 不会被前置，拿不到,但是不写 var意味着等同于 window.a = 200;
}

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

文章著作权归饥人谷_sunny和饥人谷所有，转载须说明来源

20170103作业

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

什么是声明前置

求n!，用递归来实现

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

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

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

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

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

你可能感兴趣的:(20170103作业)

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