DIV CSS 佈局教程網

JavaScript 基礎重點整理:從變數作用域到 5 種物件建立與繼承方式
編輯:JavaScript基礎知識     

這份筆記把 JavaScript 最常被考、也最容易混淆的基礎觀念整理成一份清單,從變數作用域一路談到物件建立與繼承的實作方式。

1. 全域變數與區域變數

定義在函式外的變數一定是全域變數。定義在函式內的變數,若宣告了 var 則是區域變數;若沒有宣告 var,則會變成全域變數。

var global = "Global";

test();

function test() {
  var local = "Local";
  document.writeln(global);
  document.writeln(local);
}

document.writeln(global);
document.writeln(local); // ReferenceError: local is not defined

2. 兩種類型的 Cookie

  1. 持久性 Cookie:會被儲存到客戶端的硬碟上,關閉瀏覽器後依然存在,直到過期。
  2. 回話 Cookie:不會寫入硬碟,而是放在瀏覽器行程的記憶體中,瀏覽器關閉時即銷毀。

3. 函式就是物件

在 JavaScript 中,函式(function)本身就是物件,可以賦值、傳參、掛屬性。

4. 沒有方法重載的概念

JavaScript 不支援函式重載。宣告兩個同名的函式,後者會直接覆蓋前者。

5. Function 物件

JavaScript 有一個 Function 物件,所有自訂函式都是 Function 型別。Function 建構式接受的所有參數都是字串,其中最後一個參數是函式主體,前面的參數則是函式真正的形參。

var add = new Function('a', 'b', 'return a + b;');
console.log(add(1, 2)); // 3

6. 隱含的 arguments 物件

每個函式都有一個隱含的 arguments 物件,代表實際傳入的參數集合,arguments.length 即實際傳入的參數個數。

7. 函式名稱的 length 屬性

每個函式物件都有一個 length 屬性,表示該函式期望接受的參數個數;而 arguments.length 表示實際傳入的參數個數。兩者不可混為一談。

8. 五種原始資料型別

Undefined、Null、Boolean、Number、String。(注意:JavaScript 沒有 char 型別。)

  • Undefined 型別只有一個值:undefined。
  • Null 型別只有一個值:null。
  • Boolean 型別有兩個值:true 與 false。

9. typeof 運算子

typeof 是一元運算子,後接變數名稱,用來取得型別,可能回傳五個值:undefined、boolean、number、string、object(以及 function)。

10. 沒有回傳值的函式

若函式沒有宣告回傳值,執行結果是 undefined。

11. null 與 undefined 的關係

可以說 undefined 是從 null 派生出來的,因此相等運算子認為兩者相等:

alert(undefined == null); // true

12. 強制型別轉換

有三種:Boolean(value)、Number(value)、String(value)。

13. Object 物件與屬性列舉

所有物件都繼承自 Object。用 for...in 走訪一個剛建立的 Object,不會印出任何東西,但這不代表它沒有屬性:

var object = new Object();
for (var v in object) {
  alert(v);
}

可以用 propertyIsEnumerable 測試屬性是否可列舉:

alert(object.propertyIsEnumerable("prototype")); // false

回傳 false 說明 Object 的屬性無法列舉。相較之下,window 物件的屬性是可以列舉的:

for (var v in window) {
  console.log(v);
}

在 Chrome 中會看到主控台印出一大堆屬性。

14. 動態新增與刪除屬性

var object = new Object();
alert(object.username);      // undefined
object.username = "zhangsan";
alert(object.username);      // zhangsan
object["password"] = "123";
alert(object.password);      // 123
delete object.username;      // 刪除屬性
alert(object.username);      // undefined

15. 最常見的物件定義方式

var object = {
  username: "zhangsan",
  password: 12345
};
alert(object.username);
alert(object.password);

16. 陣列與排序陷阱

// 方法一
var array = new Array();
array.push(1);
array.push(2);
array.push(3);
alert(array.length);

// 方法二(推薦)
var array = [1, 25, 4];
array.sort();
alert(array);

這裡會印出 1、25、4,並非我們期待的結果。原因是 sort() 預設會先將元素轉成字串(呼叫 toString()),再依字串順序排序。

要按數值大小排序,必須傳入比較函式:

function compare(num1, num2) {
  var temp1 = parseInt(num1);
  var temp2 = parseInt(num2);
  if (temp1 < temp2) {
    return -1;
  } else if (temp1 == temp2) {
    return 0;
  } else {
    return 1;
  }
}

var array = [1, 25, 3];
array.sort(compare);
alert(array);

用匿名函式寫成更簡潔的形式:

var array = [1, 25, 3];
array.sort(function (num1, num2) {
  var temp1 = parseInt(num1);
  var temp2 = parseInt(num2);
  if (temp1 < temp2) {
    return -1;
  } else if (temp1 == temp2) {
    return 0;
  } else {
    return 1;
  }
});
alert(array);

實務上,若確定元素都是數字,array.sort((a, b) => a - b) 就足夠了。

17. JavaScript 定義物件的五種方式

JavaScript 沒有類的概念,只有物件。以下五種方式由簡至繁。

i)基於已有物件擴充屬性與方法

var object = new Object();
object.name = "zhangsan";
object.sayName = function (name) {
  this.name = name;
  alert(this.name);
};
object.sayName("kyle"); // 印出 kyle

最簡單的一種,使用起來不太方便,適合臨時需要一個物件的情況。

ii)工廠方式

不帶參數的版本:

function createObject() {
  var object = new Object();
  object.name = "zhangsan";
  object.password = "123";
  object.get = function () {
    alert(this.name + "," + this.password);
  };
  return object;
}

var object1 = createObject();
var object2 = createObject();
object1.get();
object2.get();

帶參數的版本:

function createObject(name, password) {
  var object = new Object();
  object.name = name;
  object.password = password;
  object.get = function () {
    alert(this.name + "," + this.password);
  };
  return object;
}

var object1 = createObject("zhangsan", "123");
var object2 = createObject("lisi", "456");
object1.get();
object2.get();

兩者的缺點相同:每建立一個物件,記憶體中就多一份 get 方法,不僅浪費空間也影響效能。但我們真正想要的是「屬性各自獨立、方法彼此共用」。改進方式是把方法提到外面:

function get() {
  alert(this.name + "," + this.password);
}

function createObject(name, password) {
  var object = new Object();
  object.name = name;
  object.password = password;
  object.get = get; // 共用同一個函式物件
  return object;
}

var object1 = createObject("zhangsan", "123");
var object2 = createObject("lisi", "456");
object1.get();
object2.get();

iii)建構函式方式

不帶參數:

function Person() {
  // 執行第一行前,JS 引擎會先產生一個物件
  this.name = "zhangsan";
  this.password = "123";
  this.getInfo = function () {
    alert(this.name + "," + this.password);
  };
  // 此處有一個隱含的 return,把先前產生的物件回傳
  // 這正是它與工廠方式最大的不同
}

var p1 = new Person();
p1.getInfo();

帶參數:

function Person(name, password) {
  this.name = name;
  this.password = password;
  this.getInfo = function () {
    alert(this.name + "," + this.password);
  };
}

var p1 = new Person("zhangsan", "123");
var p2 = new Person("lisi", "456");
p1.getInfo();
p2.getInfo();

iv)原型(prototype)方式

prototype 是物件裡的一個屬性。

function Person() {}

Person.prototype.name = "zhangsan";
Person.prototype.password = "123";
Person.prototype.getInfo = function () {
  alert(this.name + "," + this.password);
};

var p1 = new Person();
var p2 = new Person();

p1.name = "kyle"; // 物件建立後再改屬性
p1.getInfo();     // kyle,123
p2.getInfo();     // zhangsan,123

單純使用原型方式有兩個問題。第一,無法在建構函式中為屬性賦初值,只能在物件建立後再改。第二,所有實例共用原型上的屬性,若屬性是參照型別,改動會互相影響:

function Person() {}

Person.prototype.name = new Array();
Person.prototype.password = "123";
Person.prototype.getInfo = function () {
  alert(this.name + "," + this.password);
};

var p1 = new Person();
var p2 = new Person();

p1.name.push("zhangsan");
p1.name.push("lisi");
p1.password = "456";

p1.getInfo(); // zhangsan,lisi,456
p2.getInfo(); // zhangsan,lisi,123

p2 的 name 陣列被 p1 的 push 改動了,這就是共用原型的副作用。

v)原型 + 建構函式混合方式

function Person() {
  this.name = new Array(); // 屬性各自獨立
  this.password = "123";
}

Person.prototype.getInfo = function () { // 方法共用
  alert(this.name + "," + this.password);
};

var p1 = new Person();
var p2 = new Person();

p1.name.push("zhangsan");
p2.name.push("lisi");

p1.getInfo(); // zhangsan
p2.getInfo(); // lisi

屬性互不干擾,方法共用同一份,這是一種相當實用的寫法。

vi)動態原型方式

function Person() {
  this.name = "zhangsan";
  this.password = "123";

  if (typeof Person.flag == "undefined") {
    Person.prototype.getInfo = function () {
      alert(this.name + "," + this.password);
    };
    Person.flag = true;
  }
}

var p1 = new Person();
var p2 = new Person();
p1.getInfo();
p2.getInfo();

在建構函式中用一個旗標讓所有物件共用方法,同時每個物件擁有自己的屬性。第一次建立物件時,判斷式成立,於是掛上 getInfo 並把旗標設為 true;第二次之後判斷式為假,直接跳過。結果就是屬性互不干擾、方法共享,兼顧了兩種需求。

18. 五種繼承方式

第一種:物件冒充

// 父類
function Parent(username) {
  this.username = username;
  this.sayHello = function () {
    alert(this.username);
  };
}

// 子類
function Child(username, password) {
  // 這三行是關鍵
  this.method = Parent;
  this.method(username);
  delete this.method;

  this.password = password;
  this.sayWorld = function () {
    alert(this.password);
  };
}

var p = new Parent("zhangsan");
var c = new Child("lisi", "123");
p.sayHello();
c.sayHello();
c.sayWorld();

第二種:call()

call 是定義在 Function 物件上的方法,因此每個函式都有。它的第一個參數會被指派給函式中的 this,從第二個參數開始逐一對應形參。

function test(str) {
  alert(this.name + "," + str);
}
var object = new Object();
object.name = "zhangsan";
test.call(object, "html5war"); // 把 object 指派給 this

用 call 實作繼承:

function Parent(username) {
  this.username = username;
  this.sayHello = function () {
    alert(this.username);
  };
}

function Child(username, password) {
  Parent.call(this, username);
  this.password = password;
  this.sayWorld = function () {
    alert(this.password);
  };
}

var p = new Parent("zhangsan");
var c = new Child("lisi", "123");
p.sayHello();
c.sayHello();
c.sayWorld();

第三種:apply()

function Parent(username) {
  this.username = username;
  this.sayHello = function () {
    alert(this.username);
  };
}

function Child(username, password) {
  Parent.apply(this, new Array(username));
  this.password = password;
  this.sayWorld = function () {
    alert(this.password);
  };
}

var p = new Parent("zhangsan");
var c = new Child("lisi", "123");
p.sayHello();
c.sayHello();
c.sayWorld();

apply 與 call 的差別只有一點:apply 的第二個參數是陣列,而 call 傳的是離散的參數。哪個比較好取決於場景——參數數量固定時用 call 更直觀,參數來源本身就是陣列時用 apply 更省事。

第四種:原型鏈方式

function Parent() {}
Parent.prototype.hello = "hello";
Parent.prototype.sayHello = function () {
  alert(this.hello);
};

function Child() {}
Child.prototype = new Parent();
Child.prototype.world = "world";
Child.prototype.sayWorld = function () {
  alert(this.world);
};

var c = new Child();
c.sayHello();
c.sayWorld();

缺點是無法在建構時傳入參數,只能等物件建立完成後再去修改。

第五種:混合方式(推薦)

function Parent(hello) {
  this.hello = hello;
}
Parent.prototype.sayHello = function () {
  alert(this.hello);
};

function Child(hello, world) {
  Parent.call(this, hello); // 借用建構函式傳參
  this.world = world;
}
Child.prototype = new Parent(); // 原型鏈
Child.prototype.sayWorld = function () {
  alert(this.world);
};

var c = new Child("hello", "world");
c.sayHello();
c.sayWorld();

用 call 解決「無法傳參」的問題,用原型鏈解決「方法無法共用」的問題,兩者互補。這正是組合繼承的核心思路,也是 ES6 之前最實用的繼承寫法。

把這 18 個重點整理成一份對照表,基本就涵蓋了 JavaScript 面試中關於變數、型別、物件與繼承的絕大部分考點。

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