DIV CSS 佈局教程網

JavaScript 函數、變數與作用域深入剖析
編輯:JavaScript基礎知識     

函數是 JavaScript 的一等公民,而作用域規則決定了變數在哪裡可見、什麼時候被建立。搞懂這兩件事,很多「莫名其妙」的錯誤就會消失。本文從函數定義與呼叫講到閉包、變數提升與塊級作用域。

一、函數的定義與呼叫

function abs(x) {
  if (x >= 0) {
    return x;
  } else {
    return -x;
  }
}

這段定義包含四個部分:function 宣告這是一個函數;abs 是函數名稱;括號內是參數列表,多個參數以逗號分隔;大括號內是函數主體,可以包含任意多條陳述式,甚至完全空白。

執行到 return 時函數立即結束並回傳結果,因此函數內部可以靠條件判斷與迴圈實作出相當複雜的邏輯。若沒有任何 return,函數執行完畢後會回傳 undefined。

函數也是物件

JavaScript 的函數本身就是一個物件,函數名稱只是指向它的變數。因此下面兩種寫法完全等價:

function abs(x) {
  return x >= 0 ? x : -x;
}

var abs = function (x) {
  return x >= 0 ? x : -x;
}; // 這裡的 function (x) {...} 是匿名函數,分號代表賦值陳述式結束

參數:多傳少傳都可以

JavaScript 不檢查呼叫時的參數個數。傳多了會被忽略,傳少了則對應的參數是 undefined:

abs(10);                 // 10
abs(10, 'blablabla');    // 10(多出來的參數被忽略)
abs(-9, 'haha', null);   // 9
abs();                   // NaN,因為 x 是 undefined

若不想讓 NaN 悄悄出現,可以在函數開頭做型別檢查:

function abs(x) {
  if (typeof x !== 'number') {
    throw 'Not a number';
  }
  return x >= 0 ? x : -x;
}

二、arguments 物件

每個函數內部都有一個 arguments,它指向「呼叫者實際傳入的所有參數」,即使函式沒有宣告任何參數也拿得到:

function foo(x) {
  alert(x); // 10
  for (var i = 0; i < arguments.length; i++) {
    alert(arguments[i]); // 10, 20, 30
  }
}
foo(10, 20, 30);
function abs() {
  if (arguments.length === 0) return 0;
  var x = arguments[0];
  return x >= 0 ? x : -x;
}
abs();    // 0
abs(10);  // 10
abs(-9);  // 9

最常見的用法是判斷參數個數,藉此把中間參數變成「可選」:

// foo(a, b, c),接受 2~3 個參數
function foo(a, b, c) {
  if (arguments.length === 2) {
    // 實際只傳了兩個,把 c 視為可選
    c = b;
    b = null;
  }
  // ...
}

三、rest 參數(ES6)

在 ES6 之前,要取得「除了已宣告參數之外」的其餘參數,必須手動用 arguments 迴圈,而且索引要從 2 開始跳過前兩個,寫起來很別扭:

function foo(a, b) {
  var i, rest = [];
  if (arguments.length > 2) {
    for (i = 2; i < arguments.length; i++) {
      rest.push(arguments[i]);
    }
  }
  console.log('a =', a, 'b =', b, 'rest =', rest);
}

ES6 的 rest 參數直接把這件事簡化成一行,前面加上 ...,而且必須放在參數列表最後:

function foo(a, b, ...rest) {
  console.log('a =', a);
  console.log('b =', b);
  console.log(rest);
}
foo(1, 2, 3, 4, 5); // a = 1, b = 2, rest = [3, 4, 5]
foo(1);             // a = 1, b = undefined, rest = []

注意:參數沒填滿時,rest 收到的是空陣列,而不是 undefined。

四、return 與自動分號插入的陷阱

JavaScript 引擎有「在行尾自動補分號」的機制,這讓下面這段看似正常的程式碼出了問題:

function foo() {
  return
  { name: 'foo' }; // 這行永遠不會執行
}
foo(); // undefined

引擎把 return 後面補上了分號,等於 return undefined;。正確的多行寫法是讓左大括號緊跟在 return 之後:

function foo() {
  return {
    name: 'foo'
  };
}

五、變數作用域

用 var 宣告的變數,作用域是「整個函數」;在函數外自然無法存取:

'use strict';
function foo() {
  var x = 1;
  x = x + 1;
}
x = x + 2; // ReferenceError: x is not defined

不同函數各自宣告的同名變數互不干擾:

'use strict';
function foo() {
  var x = 1;
  x = x + 1;
}
function bar() {
  var x = 'A';
  x = x + 'B';
}

閉包:內部函數可以看見外部變數

'use strict';
function foo() {
  var x = 1;
  function bar() {
    var y = x + 1; // bar 可以讀取 foo 的 x
    return y;
  }
  return bar();
}
foo(); // 2

反過來則不行:foo 無法存取 bar 內部的 y,會丟出 ReferenceError。若內外層變數同名,內層會「遮蔽」外層:

'use strict';
function foo() {
  var x = 1;
  function bar() {
    var x = 'A';
    alert('x in bar() = ' + x); // A
  }
  alert('x in foo() = ' + x);   // 1
  bar();
}

六、變數提升(Hoisting)

JavaScript 會先掃過整個函數主體,把 var 宣告「提升」到函數頂部,但賦值仍留在原地:

'use strict';
function foo() {
  var x = 'Hello, ' + y;
  alert(x);
  var y = 'Bob';
}
foo(); // Hello, undefined

引擎實際看到的順序是:

function foo() {
  var y;            // 宣告被提升
  var x = 'Hello, ' + y;
  alert(x);
  y = 'Bob';        // 賦值留在原處
}

因此實務上的好習慣是「在函數開頭一次宣告所有會用到的變數」:

function foo() {
  var x = 1,
      y = x + 1,
      z, i;   // z 與 i 為 undefined

  for (i = 0; i < 100; i++) {
    // ...
  }
}

七、全域作用域與命名空間

不在任何函數內宣告的變數具有全域作用域,實際上會被綁到 window 上:

'use strict';
var course = 'Learn JavaScript';
alert(course);        // Learn JavaScript
alert(window.course); // Learn JavaScript

這也意味著不同 JavaScript 檔若用了相同的全域變數或同名頂層函數,就會互相覆蓋,而且很難察覺。常見的解法是把自己的所有東西收進一個唯一的命名空間物件:

// 全域只保留 MYAPP 這一個變數
var MYAPP = {};

MYAPP.name = 'myapp';
MYAPP.version = '1.0';
MYAPP.foo = function () {
  return 'foo';
};

八、塊級作用域:let 與 const

var 沒有塊級作用域,在 for 迴圈裡宣告的變數出了迴圈依然存在,這正是古典迴圈 closure 問題的來源:

function foo() {
  for (var i = 0; i < 100; i++) { }
  i += 100; // 合法,i 仍然可見
}

ES6 的 let 提供真正的塊級作用域:

function foo() {
  var sum = 0;
  for (let i = 0; i < 100; i++) {
    sum += i;
  }
  i += 1; // ReferenceError
}

const 宣告常數,同樣具有塊級作用域。要注意 const 限制的是「不能重新指派」,物件內容仍可變動:

const PI = 3.14;
PI = 3; // TypeError(部分環境靜默失敗)

const list = [1, 2];
list.push(3); // 合法,參考指向不變

重點回顧

· 函數是物件,宣告式會被提升,函數表達式不會
· arguments 是類陣列,rest 參數是真正的陣列,優先用後者
· return 後不要換行
· var 是函數作用域並有提升行為,let/const 是塊級作用域
· 能用 const 就用 const,其次 let,避免 var

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved