DIV CSS 佈局教程網

JavaScript 基礎函數大整理:從函數建立到閉包與單例模式
編輯:關於JavaScript     

JavaScript 的函數是一等公民,這句話背後其實包含了很多具體含義:函數可以像值一樣被賦值、傳參、附加屬性,也可以作為建構器、被閉包包住、拿來做模組封裝。本文把這些基礎但關鍵的用法系統性地整理一遍,每一節都附上可直接執行的程式碼。

一、函數的三種建立方式

函數宣告(function declaration)會被提升,因此在宣告之前就能呼叫。

function add() {
  alert("函數建立成功");
}
add();

函數運算式(function expression)不會提升,必須先賦值給變數才能使用。

var testFunction = function () {
  alert("這是一個匿名函數");
};
testFunction();

建構器方式,以字串形式組出函數本文,較少使用且不利於優化:

var fn = new Function('x', 'return x * 2');

二、函數就是物件

函數可以掛屬性,這點常被忽略卻很實用:

function ball() {}
ball.name1 = "testing";     // 為函數物件加上屬性
alert(ball.name1);          // 讀取
alert(typeof ball);         // "function"

三、函數的參照傳遞

函數可以被賦值給變數、放進物件成為方法,多個物件也可以共用同一個函數參照:

function sayName(name1) { alert(name1); }

var obj1 = new Object();
var obj2 = new Object();
obj1.sayMyName = sayName;    // 把參照交給物件,形成方法
obj2.sayMyName = sayName;

obj1.sayMyName("張三");
obj2.sayMyName("李四");

因為共用同一個參照,函數物件上的屬性變化會被所有持有者看到:

function add() {}
add.message = "chaiyesong";

var ptr1 = add;
var ptr2 = add;
add.message = "123";
alert(ptr1.message);   // "123",ptr1 與 add 指向同一個函數物件
alert(ptr2.message);   // "123"

但若把變數重新指向另一個函數,只是改變了該變數的參照,原本共用同一物件的關係就被切斷了:

var ptr = add;
ptr  = function () { alert("ptr"); };   // ptr 指向新函數
add  = function () { alert("two"); };   // add 也指向另一個新函數
add();   // "two"
ptr();   // "ptr"

四、用 new 呼叫函數:建構器語義

任何函數都可以用 new 呼叫,此時函數內部的 this 會指向新建立的物件。

function Ball(message) { alert(message); }

var ball0 = new Ball("testing");
ball0.name1 = "ball-0";
alert(ball0.name1);

也可以把函數參照掛到物件的屬性上,透過該屬性呼叫:

var ball0 = new Object();
ball0.construct = Ball;          // 把函數參照指向物件的建構器
ball0.construct("ceshi");        // 透過這個屬性執行函數
ball0.name1 = "testing";
alert(ball0.name1);

五、prototype:共享屬性與方法

掛在 prototype 上的屬性與方法由所有實例共享,這是節省記憶體的關鍵。而寫在建構器內部的屬性則是每個實例各自獨立。

function Fish(name1, color1) {
  this.name1 = name1;      // 每隻魚各自擁有
  this.color1 = color1;
}
Fish.prototype.LivesIn = "water";   // 所有魚共享
Fish.prototype.price = 20;

var fish1 = new Fish("mackrel", "gray");
var fish2 = new Fish("goldfish", "orange");
var fish3 = new Fish("salmon", "white");

for (var i = 1; i <= 3; i++) {
  var fish = eval("fish" + i);      // 取得指向該實例的參照
  alert(fish.name1 + "," + fish.color1 + "," + fish.LivesIn + "," + fish.price);
}

把方法掛在 prototype 上的效益更明顯——若寫在建構器裡,每次 new 都會重新建立一份函數,實例一多就很浪費:

function Employee(name, salary) {
  this.name = name;
  this.salary = salary;
}
Employee.prototype.getSalary = function getSalaryFunction() {
  return this.salary;
};
Employee.prototype.addSalary = function addSalaryFunction(addition) {
  this.salary = this.salary + addition;
};

var boss1 = new Employee("Joan", 200000);
alert(boss1.getSalary());     // 200000

六、立即執行函數(IIFE)

把匿名函數包在小括號裡再立刻呼叫,可以建立一個一次性的作用域:

(function (x, y) {
  alert(x + y);        // 5
})(2, 3);

也可以把執行結果回傳給變數:

var f2 = function () {
  return "ok";
}();
alert(f2);             // "ok"

七、閉包(Closure)

閉包指的是函數連同它能存活的外部作用域一起被保留。最典型的應用是讓變數在函數執行完畢後仍然留在記憶體中:

function box() {
  var age = 100;
  return function () {     // 真正被呼叫的是這個內部函數
    age++;
    return age;
  };
}
var b = box();
alert(b());   // 101
alert(b());   // 102
alert(b());   // 103

box() 早已執行完畢,但它的內部函數仍持有 age 的參照,因此 age 不會被回收,狀態得以在多次呼叫之間延續。

閉包另一個常見用途是封裝私有成員:

function Box() {
  var age = 100;                    // 私有變數
  function run() {                  // 私有函數
    return '運行中...';
  }
  this.get = function () {          // 對外公開的特權方法
    return age + run();
  };
}
var box = new Box();
alert(box.get());                   // "100運行中..."
// alert(box.age);                  // undefined,外部無法存取

也可以搭配 getter / setter 做受控存取:

function Person(value) {
  var user = value;
  this.getUser = function () { return user; };
  this.setUser = function (value) { user = value; };
}

八、閉包經典陷阱:迴圈中的變數捕獲

這是最容易出錯的一段。下面的程式碼不會輸出 0 到 4,而是全部輸出 5:

function box() {
  var arr = [];
  for (var i = 0; i < 5; i++) {
    arr[i] = function () { return i; };   // 捕獲的是同一個 i
  }
  return arr;
}
var b = box();
for (var i = 0; i < b.length; i++) {
  document.writeln(b[i]());    // 全部印出 5
}

原因是所有閉包共用同一個 i 變數,迴圈結束後 i 的值是 5。

解法一:用 IIFE 建立獨立作用域並回傳結果。

function box1() {
  var arr1 = [];
  for (var i = 0; i < 5; i++) {
    arr1[i] = (function (num) {
      return num;          // 把當下的 i 當作值傳入
    })(i);
  }
  return arr1;
}

解法二:IIFE 回傳函數本身,讓每個閉包各自記住自己的 num。

function box3() {
  var arr3 = [];
  for (var i = 0; i < 5; i++) {
    arr3[i] = (function (num) {
      return function () { return num; };
    })(i);
  }
  return arr3;
}
var b3 = box3();
for (var i = 0; i < b3.length; i++) {
  document.writeln(b3[i]());   // 0 1 2 3 4
}

而在支援 ES6 的環境中,只要把 var 換成 let 就解決了——let 在每次迴圈迭代都建立新的 bindings:

for (let i = 0; i < 5; i++) {
  arr[i] = function () { return i; };   // 正確輸出 0 1 2 3 4
}

九、IIFE 用於立即釋放記憶體

把一段一次性邏輯包進 IIFE,執行完畢後區域變數就能被回收:

function box(count) {
  (function () {
    for (var i = 0; i < count; i++) { /* ... */ }
  })();
  // 這裡無法存取 i,作用域已經結束
}

十、單例模式(Singleton)

寫法一:物件字面量回傳公開介面。

var box = function () {
  var user = 'TT';                    // 私有變數
  function run() {                    // 私有函數
    return '運行中...';
  }
  return {
    publicGo: function () {           // 對外公開的介面
      return user + run();
    }
  };
}();
alert(box.publicGo());                // "TT運行中..."

寫法二:實例化自訂物件後掛上方法。

function Desk() {}
var box = function () {
  var user = 'TT';
  function run() { return '運行中...'; }

  var desk = new Desk();              // 實例化自訂物件
  desk.publicGo = function () {
    return user + run();
  };
  return desk;
}();
alert(box.publicGo());

兩種寫法的差別在於「用來承載公開方法的載體」是物件字面量還是自訂物件的實例。前者更簡潔,是實務上的主流選擇;後者適合需要繼承或 instanceof 判斷的場景。

十一、閉包中的 this 指向

這是一個關鍵但常被誤解的細節:閉包中的 this 指向 window,而不是建立閉包的那個物件。

var user = 'The Window';
var obj = {
  user: 'The Object',
  getUserFunction: function () {
    return function () {
      return this.user;      // 這個 this 是 window
    };
  }
};
document.writeln(obj.getUserFunction()());   // "The Window"

要讓內部函數存取外層物件的 this,實務上有三種做法:用一個 var self = this 把參照存下來;用 bind() 綁定 this;或改用箭頭函數,因為箭頭函數沒有自己的 this,會直接沿用外層的 this。

總結

這批程式碼背後其實只有幾個核心概念:函數是物件所以能被賦值與傳遞;prototype 決定屬性是共享還是獨立;new 改變 this 的指向;而閉包讓內部函數保有對外部作用域的參照。把這四點想清楚,上面所有看似零散的技巧都會連成一條線。理解之後,多數場合都能用更簡潔的 ES6+ 語法(let/const、箭頭函數、class、解構)改寫得更清楚。

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