進階任務3（主線任務）：函數與作用域

任務

  1. 函數聲明和函數表達式有什么區別
    答：函數聲明：function functionName(){}
    ??函數表達式：var fn = function(){}
    ??函數聲明會提前，函數表達式可以省略標識符（函數名）。
  2. 什么是變量的聲明前置？什么是函數的聲明前置
    答：所謂的變量聲明前置就是在一個作用域塊中，所有的變量都被放在塊的開始處聲明。和變量聲明前置一樣，執行代碼之前會先讀取函數聲明，只要函數在代碼中進行了聲明，無論它在哪個位置上進行聲明，js引擎都會將它的聲明放在范圍作用域的頂部。
  3. arguments 是什么
    答：arguments是一個類數組對象。代表傳給一個function的參數列表。
    arguments對象是函數內部的本地變量；arguments 已經不再是函數的屬性了。可以在函數內部通過使用 arguments 對象來獲取函數的所有參數。這個對象為傳遞給函數的每個參數建立一個條目，條目的索引號從0開始。它包括了函所要調用的參數。object對象。類數組。
  4. 函數的"重載"怎樣實現
    答：在JS中，沒有重載。同名函數會覆蓋。但可以在函數體針對不同的參數調用執行相應的邏輯。
    如下面的例子：
  function printPeopleInfo(name, age, sex){
    if(name){
      console.log(name);
    }

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

    if(sex){
      console.log(sex);
    }
  }
  printPeopleInfo('Byron', 26);//Byron 26
  printPeopleInfo('Byron', 26, 'male');//Byron 26 male
  1. 立即執行函數表達式是什么？有什么作用
    答：
(function(){
    var a = 1;
})()

作用： 隔離作用域。
其他寫法

(function fn1() {});

// 在數組初始化器內只能是表達式
[function fn2() {}];

// 逗號也只能操作表達式
1, function fn3() {};
  1. 求n!，用遞歸來實現
    答：
    遞歸：
    自己調用自己
    設定終止條件
    優點: 算法簡單
    缺點: 效率低
    求n!
function factor(n){
 if(n === 1) { 
return 1 
} 
return n * factor(n-1) } factor(5)
  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, '男');
/*name: 饑人谷
age: 2
sex: 男
name valley*/

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

  getInfo('男');
/* name: 男
 age: undefined
 sex: undefined
name valley*/
  1. 寫一個函數，返回參數的平方和？
function sumOfSquares(){ 
    var sum=0; 
    for(var i=0;i<arguments.length;i++){
     sum=sum+arguments[i]*arguments[i];
     } 
  console.log(sum); 
} 
var result = sumOfSquares(2,3,4) 
var result2 = sumOfSquares(1,3) 
console.log(result) //29 
console.log(result2) //10
  1. 如下代碼的輸出？為什么
console.log(a); 
var a = 1; 
console.log(b);//b is not defined
  1. 如下代碼的輸出？為什么
sayName('world');//hello  world，函數聲明前置
sayAge(10);//sayAge is not a function，函數表達式不前置
function sayName(name){
    console.log('hello ', name);
}
var sayAge = function(age){
    console.log(age);
};
  1. 如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼
var x = 10
bar() 
function foo() {
  console.log(x)
}
function bar(){
  var x = 30
  foo()
}

/* 1. globalContext = { 
     AO:{ x:10
         foo:function
         bar:function
   },
 Scope:null
    }

    foo.[[scope]] = globalContext.AO
    bar.[[scope]] = globalContext.AO

  2.調用bar() barContext = { 
  AO:{ x:30 }, 
Scope:bar.[[scope]] = globalContext.AO 
} 
x變成30
 3.調用foo() fooContext = { 
AO:{}, 
Scope:foo.[[scope]] = globalContext.AO 
} 
輸出10 */
  1. 如下代碼輸出什么? 寫出作用域鏈查找過程偽代碼
var x = 10;
bar() 
function bar(){
  var x = 30;
  function foo(){
    console.log(x) 
  }
  foo();
}   

/* 1. globalContext = { 
      AO:{ x:10 
      bar:function
  },
        Scope:null
    }
    bar.[[scope]] = globalContext.AO
    2.調用bar() 
barContext = { 
AO:{ x:30 }, 
Scope:bar.[[scope]] // globalContext.AO } 
foo.[[scope]] = barContext.AO 
3.調用foo()
 fooContext = { AO:{}, 
scope:foo.[[scope]] } 
輸出結果為30 */
  1. 以下代碼輸出什么? 寫出作用域鏈的查找過程偽代碼
var x = 10;
bar() 
function bar(){
  var x = 30;
  (function (){
    console.log(x)
  })()
}

/*1. globalContext = { 
AO:{ x:10
 bar:function }, 
Scope:null
 }
 bar.[[scope]] = globalContext.AO 
2.調用bar()
 barContext = { 
AO:{ x:30 
function }, 
Scope:bar.[[scope]] //globalContext.AO } 
function.[[scope]] = barContext.AO 
3.調用立即執行函數 
functionContext = { AO:{}, 
Scope:function.[[scope]]//barContext.AO } 
結果為30*/
  1. 以下代碼輸出什么？ 寫出作用域鏈查找過程偽代碼
  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)

/*1.
   globalContext = {
        AO:{
            a:1
            fn:function
            fn3:function
        },
        Scope:null } 
  fn.[[scope]] = globalContext.AO 
  fn3.[[scope]] = globalContext.AO 
  2.調用fn() 
fnContext = {
        AO:{
            a:undefined
            fn2:function
        }, 
  Scope:fn.[[scope]] // globalContext.AO } 
  fn2.[[scope]] = fnContext.AO 
  3. fn3Context = {
        AO:{
            a:200
        }, 
  Scope:fn3Context.[[scope]]//globalContext.AO } 
  fn2ConText = {
        AO:{
            a:20
        }, 
  Scope:fn2ConText.[[scope]]//fnContext.AO } 
  開始執行 
  console.log(a)//undefined 打印 
  var a = 5//fnContext中a變成5 
  console.log(a)//5 
  a++//fnContext.AO中a變為6 
  調用fn3()
   fn3()中 console.log(a)//globalContext.AO中的a值為1，打印 
  a = 200//globalContext.AO中的a變為200 
  調用fn2() 
  console.log(a);//fnContext.AO中的a值為6，打印 
  a = 20;//fnContext.AO中的a變為20 
  繼續執行fn() 
  console.log(a)//fnContext.AO中的a值為20，打印 
  fn()結束 
  console.log(a)//globalContext.AO中a值為200，打印
  //輸出的結果 undefined 5 1 6 20 200 
  */
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 1. 函數聲明和函數表達式有什么區別 使用function關鍵字聲明一個函數時，聲明不必放到調用的前面。//函數聲...
    _李祺閱讀 281評論 0贊 0
  • 1.函數聲明和函數表達式有什么區別。 函數聲明使用function來進行聲明，函數聲明提升，所以不論執行語句的位置...
    Rising_suns閱讀 307評論 0贊 0
  • JavaScript中的函數運行在它們被定義的作用域里，而不是它們被執行的作用域里。 函數聲明和函數表達式有什么區...
    畢子歌閱讀 419評論 0贊 0
  • 1，函數聲明和函數表達式有什么區別 1、背景介紹 定義函數的方法主要有三種： 1：函數聲明(Function De...
    進擊的前端_風笑影閱讀 453評論 0贊 0
  • 1.函數聲明和函數表達式有什么區別 函數聲明不必放在調用前面 函數表達式必須放在調用前面 2.什么是變量的聲明前置...
    LINPENGISTHEONE閱讀 305評論 0贊 0