DIV CSS 佈局教程網

JavaScript 核心知識總整理:型別、作用域、物件與類別
編輯:關於JavaScript     

本文把 JavaScript 最常被翻查的核心概念整理成一份完整筆記,涵蓋資料型別、變數作用域、嚴格模式、物件與資料結構、函式,以及兩種定義類別的方式。

JavaScript 能實現什麼

  • 豐富網頁功能與使用者介面
  • 實現本地或遠端資料儲存
  • 打造分散式網路應用的前端元件,並在後端管理資料
  • 以 JavaScript 完成完整的分散式 Web 應用

一、資料型別

JavaScript 提供三種元資料型別:string、number、boolean,可用 typeof(v) 測試。另有五種基本引用類型:Object、Array、Function、Date、RegExp。其中 Array、Function、Date、RegExp 屬於特殊類型,嚴格說 Date 與 RegExp 也可視為可封裝的元資料型別。

變數、陣列元素、函式參數與回傳值都不需要宣告型別,型別轉換會自動進行。變數的值可以是:數值(字串、數字或布林)、物件引用(可指向資料、函式、日期或正則)、特殊的 null(通常用於初始化物件),以及 undefined(已宣告但未賦值)。

if (firstName + lastName === "James Bond") ...

numeric 表示 64 位元浮點數,JavaScript 不明顯區分整數與浮點數。若某個運算式的值不等於任何數字,其值會是 NaN,可搭配 isNaN() 使用。

二、變數作用域

ES5 只有兩種作用域:全域與函式作用域,並沒有區塊作用域。因此下面這種常見寫法其實是個陷阱——i 在函式結束後仍然存在。

function foo() {
  for (var i = 0; i < 10; i++) {
    ... // 對 i 做一些事
  }
}

建議把所有變數宣告集中在函式開頭。ES6 之後支援區塊作用域,用 let 宣告即可。

嚴格模式

從 ES5 開始,嚴格模式用於在執行期抓出更多錯誤:所有變數都必須先宣告,對未宣告的變數賦值會丟出例外。在檔案或 script 元素最前面寫入:

use strict;

除非專案依賴的函式庫不相容,否則建議一律開啟。

三、物件與常見資料結構

JavaScript 的物件概念與 OO 語言中的物件不同:物件不需要先具現化類別,也能有自己的方法,除了屬性槽之外還包含方法槽與鍵值槽,共三種 slots。

var person1 = { lastName: "Smith", firstName: "Tom" };
var o1 = Object.create(null); // 沒有任何槽的空物件

屬性可用兩種方式存取:

person1.lastName = "Smith";
person1["lastName"] = "Smith";

JavaScript 物件常見的五種用途:

1. Record(紀錄)——純屬性集合:

var myRecord = {firstName: "Tom", lastName: "Smith", age: 26};

2. Map(映射)——鍵值對集合:

var numeral2number = {"one": "1", "two": "2", "three": "3"};

3. 無型別物件——同時含屬性與方法,不需具現化類別:

var person1 = {
  lastName: "Smith",
  firstName: "Tom",
  getFullName: function () {
    return this.firstName + " " + this.lastName;
  }
};

4. Array List——以索引存取的邏輯資料結構:

var a = [1,2,3];
a[4] = 7;              // 陣列可動態增長
a.push(newElement);    // 新增
a.splice(i, 1);        // 刪除
if (a.indexOf(v) > -1) ...  // 查找
Array.isArray(a);      // 判定是否為陣列

var i = 0;
for (i = 0; i < a.length; i++) { console.log(a[i]); }

a.forEach(function (elem) { console.log(elem); });

var clone = a.slice(0); // 複製

四、Map 的操作

var myTranslation = {
  "my house": "mein Haus",
  "my boat": "mein Boot",
  "my horse": "mein Pferd"
};

myTranslation["my car"] = "mein Auto";   // 新增
delete myTranslation["my car"];          // 刪除
if ("my bike" in myTranslation) ...      // 查找

var i = 0, key = "", keys = [];
keys = Object.keys(myTranslation);
for (i = 0; i < keys.length; i++) {
  key = keys[i];
  console.log(myTranslation[key]);
}

Object.keys(myTranslation).forEach(function (key) {
  console.log(myTranslation[key]);
});

var clone = JSON.parse(JSON.stringify(myTranslation)); // 複製

四種基本資料結構小結

array lists(如 ["one","two","three"])、records(如 {firstName:"Tom", lastName:"Smith"})、maps(如 {"one":1,"two":2}),以及 entity table——一種值為固定 ID 紀錄的特殊 map。

record、map、entity 在概念上有區分,但對 JavaScript 引擎而言都是物件。

五、函式

函式是特殊的 JavaScript 物件,具 name 與 length(參數個數)屬性。判定方式:

if (typeof(v) === "function") {...}

函式表達式與函式宣告:

var myFunction = function theNameOfMyFunction () {...}

function theNameOfMyFunction () {...}
// 等價於
var theNameOfMyFunction = function theNameOfMyFunction () {...}

省略名稱就是匿名函式,在其他語言中稱為 lambda 表達式,常用來當作排序等 API 的比較器:

var list = [[1,2],[1,3],[1,1],[2,1]];
list.sort(function (x, y) {
  return ((x[0] === y[0]) ? x[1] - y[1] : x[0] - y[0]);
});

閉包:函式可以存取定義位置之外的變數,因此不必把外部結果透過參數傳進來。

var sum = function (numbers) {
  var result = 0;
  numbers.forEach(function (n) { result += n; });
  return result;
};
console.log(sum([1,2,3,4]));

arguments 物件:可用來存取函式內的所有參數,有 length 與索引,但它不是 Array 的實例,所以不能用 forEach 等方法。因此也可以定義不帶參數的函式:

var sum = function () {
  var result = 0, i = 0;
  for (i = 0; i < arguments.length; i++) {
    result = result + arguments[i];
  }
  return result;
};
console.log(sum(0,1,1,2,3,5,8)); // 20

若想在 arguments 上使用陣列方法,可以借 call 借用:

var sum = function () {
  var result = 0;
  Array.prototype.forEach.call(arguments, function (n) {
    result = result + n;
  });
  return result;
};

Function.prototype.call 與 apply 的存在,就是為了改變函式運行時的 context。

六、定義類別的兩種寫法

類別在 JavaScript 中需要滿足:能指定名稱與各層級的屬性和方法、能檢驗實例歸屬、能支援屬性與方法繼承。ES6 之前沒有統一規範,常見做法有兩種:以建構函式搭配原型鏈,或是以 Object.create 為核心的 factory 物件。

寫法一:基於建構函式(ES6 class 語法)

class Person {
  constructor(first, last) {
    this.firstName = first;
    this.lastName = last;
  }
  toString() {
    return this.firstName + " " + this.lastName;
  }
  static checkLastName(ln) {
    if (typeof(ln) !== "string" || ln.trim() === "") {
      console.log("Error: invalid last name!");
    }
  }
}

Person.instances = {};   // 類層級的靜態屬性
class Student extends Person {
  constructor(first, last, studNo) {
    super(first, last);
    this.studNo = studNo;
  }
  // 覆寫父類方法
  toString() {
    return super.toString() + "(" + this.studNo + ")";
  }
}

寫法一(ES5 版本)

// 1. 建構函式,this 指向新建立的物件
function Person(first, last) {
  this.firstName = first;
  this.lastName = last;
}

// 2. 實例層方法
Person.prototype.toString = function () {
  return this.firstName + " " + this.lastName;
};

// 3. 靜態方法
Person.checkLastName = function (ln) {
  if (typeof(ln) !== "string" || ln.trim() === "") {
    console.log("Error: invalid last name!");
  }
};

// 4. 靜態屬性
Person.instances = {};
// 5. 定義子類,並呼叫父類建構函式完成屬性繼承
function Student(first, last, studNo) {
  Person.call(this, first, last);
  this.studNo = studNo;
}

// 6. 透過 prototype 安裝方法繼承
Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;

// 7. 覆寫父類方法
Student.prototype.toString = function () {
  return Person.prototype.toString.call(this) + "(" + this.studNo + ")";
};

// 8. 具現化
var pers1 = new Person("Tom", "Smith");
alert("The full name of the person are: " + pers1.toString());

寫法二:基於 Factory 的類別

定義一個帶有 create 方法的物件,內部呼叫預先定義好的 Object.create 來產生實例。

var Person = {
  name: "Person",
  properties: {
    firstName: {range: "NonEmptyString", label: "First name", writable: true, enumerable: true},
    lastName:  {range: "NonEmptyString", label: "Last name",  writable: true, enumerable: true}
  },
  methods: {
    getFullName: function () {
      return this.firstName + " " + this.lastName;
    }
  },
  create: function (slots) {
    var obj = Object.create(this.methods, this.properties);
    // 加上 direct type 屬性
    Object.defineProperty(obj, "type", {
      value: this, writable: false, enumerable: true
    });
    // 初始化
    Object.keys(slots).forEach(function (prop) {
      if (prop in this.properties) obj[prop] = slots[prop];
    });
    return obj;
  }
};

var pers1 = Person.create({firstName: "Tom", lastName: "Smith"});
alert("The full name of the person are: " + pers1.getFullName());

這裡的 Person 物件實際上代表一個 factory-based 類別,每個屬性宣告都透過 Object.create 的第二個參數描述其 writable 與 enumerable 特性。兩種寫法沒有絕對優劣:class 語法語意清楚、工具支援好;factory 寫法則在需要嚴格控制屬性描述與避免 new 時更靈活。

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