DIV CSS 佈局教程網

JavaScript 核心筆記:型別、值與變數全解
編輯:關於JavaScript     

本文整理自 JavaScript 核心讀書筆記,系統性地梳理了型別、值與變數這三大基礎概念,適合想打好底子的開發者參考。

型別與變數概覽

電腦程式的運行需要對各種「值」(value)進行操作,例如數字 3.14 或文字 "hello world"。在程式語言中,能表示並操作這些值的型別叫做資料型別(type),而支援多種資料型別正是程式語言最基本的特性之一。當程式需要把值保留起來以備日後使用時,便將其賦值給一個變數(variable)——變數是值的符號名稱,可透過名稱取得對值的參照。

JavaScript 的資料分為兩大類:原始型別(primitive type)與物件型別(object type)。

原始型別

原始型別包括數字、字串與布林值。此外還有兩個特殊的原始值:null(空)與 undefined(未定義),它們分別是各自型別的唯一成員,不屬於數字、字串或布林值。

物件型別

除了上述原始值之外,其餘都是物件。物件是屬性(property)的集合,每個屬性由「名/值對」構成,值可以是原始值,也可以是物件。JavaScript 中的全域物件(global object)是一個比較特殊的物件。

普通物件是「命名值」的無序集合。JavaScript 同時定義了幾種特殊物件:

  • 陣列(array):表示帶編號的值的有序集合,擁有專屬語法與特有行為。
  • 函式(function):具備可執行程式碼的物件,透過呼叫來運行並回傳結果。函式最重要的特性是——它們都是真值,且可當作普通物件對待。

若以 new 運算子初始化一個新物件,我們稱之為構造函式(constructor)。每個構造函式定義了一類(class)物件。除了陣列類與函式類之外,JavaScript 還定義了日期(Date)、正則(RegExp)與錯誤(Error)三種常用類別,我們也能定義自己的構造函式來建立所需的類。

垃圾回收與方法

JavaScript 解譯器具備自動垃圾回收(garbage collection)機制,程式可依需建立物件,不必擔心銷毀與記憶體回收——當不再有任何參照指向某物件時,解譯器便會自動回收它佔用的記憶體。

JavaScript 是一種物件導向語言。嚴格來說,這意味著資料型別本身可以定義方法(method)來操作值。例如要對陣列 a 排序,不必把 a 傳入 sort() 函式,而是直接呼叫 a 的方法:

a.sort(); // sort(a) 的物件導向版本

技術上只有物件才能擁有方法,但數字、字串與布林值也擁有自己的方法。在 JavaScript 中,只有 null 與 undefined 無法擁有方法。

可變與不可變型別

JavaScript 的型別也可分為可變(mutable)與不可變(immutable)兩類。物件與陣列屬於可變型別,程式可改變物件屬性值與陣列元素值;而數字、布林值、null 與 undefined 屬於不可變型別。字串雖可視為字元組成的陣列,但在 JavaScript 中它是不可變的——你可以存取字串中任意位置的文字,卻無法修改既有字串的內容。

型別轉換

JavaScript 能自由進行型別轉換。例如在期望字串的地方使用數字,它會自動將數字轉為字串;在期望布林值的地方使用非布林值,它也會相應轉換。這些靈活的轉換規則也影響了「判斷相等」的行為。

變數宣告

JavaScript 的變數是無型別的(untyped),可被賦予任何型別的值,並以 var 關鍵字宣告。JavaScript 採用語法作用域,不在任何函式內宣告的變數稱為全域變數(global variable),它在整個程式中都看得見。

一、數字

與其他語言不同,JavaScript 不區分整數與浮點數,所有數值皆以浮點數表示。當數字直接出現在程式中,我們稱之為數字直接量(numeric literal)。

整數型直接量

十進制整數以數字序列表示。除了十進制,JavaScript 也識別以 0x 或 0X 為前綴的十六進制值,其後緊跟由 0-9 與 a(A)-f(F) 組成的數串(a-f 代表 10-15):

0xff    // 15*16+15 = 255
0xCAFE911

雖然 ECMAScript 不支援八進制直接量,但某些實作允許以數字 0 開頭表示八進制:

0377    // 3*64 + 7*8 + 7 = 255(十進制)

由於各實作對八進制的支援不一,加上 ECMAScript 6 嚴格模式明令禁止使用八進制直接量,因此不建議使用以 0 為前綴的整數直接量。

浮點型直接量

浮點型直接量可含小數點,採用傳統實數寫法;也可使用指數計數法,即在實數後接字母 e 或 E,再跟正負號與整數指數,代表實數乘以 10 的指數冪。其語法可概括為:

[digits][.digits][(E|e)[(+|-)]digits]
    3.14
    2345.455
    .33333333333333333
    6.02e23    // 6.02*10 的 23 次方
    1.255454E-23 // 1.255454*10 的負 23 次方

JavaScript 的算術運算

除了基本的 +、-、*、/ 與求餘(%)運算子外,JavaScript 還透過 Math 物件的屬性與函式提供更複雜的運算:

Math.pow(2, 53) // => 9007199254740992
Math.round(.6)  // => 1.0  四捨五入
Math.ceil(.6)   // => 1.0  向上求整
Math.floor(.6)  // => 0.0  向下求整
Math.abs(-5)    // => 5    求絕對值
Math.max(x, y, z) // 回傳最大值
Math.min(x, y, z) // 回傳最小值
Math.random()   // 產生 0 到 1 之間的偽隨機數
Math.PI         // 圓周率 π
Math.E          // 自然對數的底數 e
Math.sqrt(3)    // 3 的平方根
Math.pow(3, 1/3)// 3 的立方根
Math.sin(0)     // 三角函式,另有 Math.cos、Math.atan 等
Math.log(10)    // => 2.302585092994046 自然對數
Math.log(512) / Math.LN2   // 以 2 為底的 512 的對數
Math.log(100) / Math.LN10  // 以 10 為底的 100 的對數
Math.exp(3)     // e 的三次冪

當運算結果超過可表示的數值上限(溢出 overflow)時,結果為特殊的無窮大值 Infinity;負數超過範圍則為 -Infinity。下溢(underflow)發生在運算結果無限接近零、比可表示的最小值還小時,此時會回傳特殊的「負零」。

JavaScript 預定義了全域變數 Infinity 與 NaN。ECMAScript 3 中這兩個值可讀寫,ECMAScript 5 則將其定義為唯讀:

Infinity                    // 正無窮大
Number.POSITIVE_INFINITY    // 同值,唯讀
1 / 0                       // 同值
Number.MAX_VALUE + 1        // 結果仍是 Infinity
Number.NEGATIVE_INFINITY    // 負無窮大
NaN                         // 非數字值
Number.NaN                  // 同值,唯讀
0/0                         // 結果仍是 NaN
Number.MIN_VALUE/2          // 發生下溢,結果為 0
-Number.MIN_VALUE/2         // 負零
-1/Infinity                 // 負零
-0                          // 負零

NaN 有個特殊之處:它與任何值都不相等,包括自身,因此不能用 x == NaN 來判斷,而應使用 x != x(僅當 x 為 NaN 時結果為 true)。函式 isNaN() 若參數為 NaN 或非數字值則回傳 true;isFinite() 則在參數不是 NaN、Infinity 或 -Infinity 時回傳 true。

二進位浮點數與四捨五入誤差

實數有無限多個,但 JavaScript 以浮點數只能表示有限個,因此使用實數時往往只是真實值的近似。JavaScript 採用 IEEE-754 浮點數表示法,這是二進位表示法,能精確表示 1/2、1/8、1/1024 等分數,卻無法精準表示 0.1 這類十進位小數:

var x = .3 - .2;
var y = .2 - .1;
alert(x == y) // => false 兩值不相等
x == .1       // => false 0.3-0.2 不等於 0.1
y == .1       // => true  0.2-0.1 等於 0.1

由於捨入誤差,0.3 與 0.2 的近似差實際上不等於 0.2 與 0.1 的近似差(真實模擬環境中 0.3-0.2 = 0.09999999999999998)。這問題存在於所有採用二進位浮點數的語言中。若要做重要的金融計算,可考慮以大整數(例如以「分」而非「元」為單位)運算來避開誤差。

日期與時間

JavaScript 核心包含 Date() 構造函式,用來建立日期與時間物件,並提供簡單的 API 供日期計算:

var zhen = new Date(2011, 0, 1);       // 2011 年 1 月 1 日
var later = new Date(2011, 0, 1, 17, 10, 30); // 同一天的具體時刻
var now = new Date();                  // 當前日期與時間
var elapsed = now - zhen;              // 日期相減,計算間隔毫秒數
later.getFullYear();  // => 2011
later.getMonth();     // => 0(從 0 開始計數的月份)
later.getDate();      // => 1(從 1 開始計數的天數)
later.getDay();       // => 5(星期幾,0 代表週日)
later.getHours();     // => 當地時間小時
later.getUTCHours();  // => 以 UTC 表示的小時

二、文字

字串(string)是一組 16 位值組成的不可變有序序列,每個字元通常來自 Unicode 字元集。字串長度(length)即所含 16 位值的個數,索引從 0 開始。空字串長度為 0,JavaScript 並沒有「字元型」。

字元集與編碼

JavaScript 採用 UTF-16 編碼的 Unicode 字元集。最常用的字元以 16 位內碼表示,無法用 16 位表示者則依 UTF-16 規則以兩個 16 位值組成的「代理項對」表示,因此一個長度為 2 的字串可能只代表一個 Unicode 字元:

var p = "π"; // π 由 16 位內碼表示 0x03c0
var e = "e"; // e 由 17 位內碼表示 0x1d452
p.length // => 1,p 包含一個 16 位值
e.length // => 2,e 經 UTF-16 編碼後包含兩個值

JavaScript 的字串操作方法皆作用於 16 位值而非字元,且不會對代理項對做單獨處理。

字串直接量

字串直接量由單引號或雙引號括起的字元序列構成。單引號定界的字串中可含雙引號,反之亦然:

""                              // 空字串
'testing'
"3.14"
'name="myform"'
"wouldn't you prefer O'Reilly's book?"

ECMAScript 3 要求字串直接量寫在一行,ECMAScript 5 則允許拆分為多行,每行以反斜線(\)結尾;若希望換行則使用 \n。

轉義字元

在字串中,反斜線(\)後接一個字元即構成轉義字元:

\o   // NUL 字元
\b   // 退格符
\t   // 水平定位字元
\n   // 換行符
\v   // 垂直定位字元
\f   // 換頁符
\r   // 回車符
\"   // 雙引號
\\   // 反斜線
\xXX  // 由兩位十六進位指定的 Latin-1 字元
\xXXXX // 由四位十六進位指定的 Unicode 字元

字串的使用

將 + 運算子用於字串代表字串連接:

var msg = "hello" + "world"; // 產生 "helloworld"

字串長度可用 length 屬性取得(s.length)。此外字串還提供許多方法:

var s = "hello,world";
s.charAt(0);              // "h" 第一個字元
s.charAt(s.length - 1);   // "d" 最後一個字元
s.substring(1, 4);        // "ell"
s.slice(1, 4);            // "ell" 同上
s.slice(-3);              // 最後出現的 3 個字元
s.indexOf("l");           // 2,字元 l 首次出現的位置
s.lastIndexOf("l");       // 10,字元 l 最後一次出現的位置
s.indexOf("l", 3);        // 位置 3 之後 l 首次出現的位置
s.split(",");             // => ["hello","world"]
s.replace("h", "H");      // => "Hello,world"
s.toUpperCase();          // => "HELLO,WORLD"

在 JavaScript 中字串固定不變,replace()、toUpperCase() 等方法都會回傳新字串,原字串本身並未改變。字串也可當作唯讀陣列,用方括號存取單一字元:s[0] => "h"。

模式匹配

JavaScript 定義了 RegExp() 構造函式來建立表示文字模式匹配的物件,這些模式稱為「正則表達式」。正則表達式雖非基本資料型別,卻有直接量寫法,兩條斜線之間的文本即構成一個正則表達式:

/^HTML/               // 匹配以 HTML 開始的字串
/[1-9][0-9]*/         // 匹配一個非零數字,後接任意個數字
/\bjavascript\b/i      // 匹配單字 javascript,忽略大小寫

RegExp 物件與字串都定義了可利用正則表達式進行匹配的方法:

var text = "testing:1,2,3";
var pattern = /\d+/g;   // 匹配所有含一個或多個數字的實例
pattern.test(text);     // => true,匹配成功
text.search(pattern);   // => 9,首次匹配成功的位置
text.match(pattern);    // => ["1","2","3"] 所有匹配組成的陣列
text.replace(pattern, "#"); // => "testing:#,#,#"
text.split(/\D+/);      // => ["","1","2","3"],以非數字字元截取

三、布林值

布林值代表真或假,只有 true 與 false 兩個值。JavaScript 中比較運算的結果通常就是布林值:

a == 4

布林值常用於控制語句,例如 if/else:

if (a == 4)
  b = b + 1;
else
  a = a + 1;

任意值都能轉為布林值,以下六個值會被轉為 false:

undefined
null
0
-0
NaN
""  // 空字串

其他所有值(包括所有物件)都會轉為 true。這六個被轉為 false 的值有時稱為「假值」。布林值包含 toString() 方法,此外還有 &&、|| 與一元 ! 三個重要的布林運算子:

if ((x == 0 && y == 0) || !(z == 0)) {
  // x 與 y 都是零,或 z 是非零
}

四、null 與 undefined

null 是 JavaScript 的關鍵字,表示特殊的「空值」。對 null 執行 typeof 會回傳 object,因此可將 null 視為一個特殊的物件值,代表「非物件」。null 通常被視為其自身型別的唯一成員,用來表示數字、字串或物件是「無值」的。

undefined 則是第二個表示「值空缺」的值,代表變數尚未初始化,或物件屬性/陣列元素不存在。它是預定義的全域變數(並非關鍵字),以 typeof 測試會回傳 "undefined"。

null 與 undefined 雖不同,但都表示「值的空缺」,且以 == 判斷時被視為相等(需用 === 才能區分)。在期望布林值的地方兩者皆為假值,且都不含任何屬性與方法,對它們取值會產生型別錯誤。

五、全域物件

全域物件(global object)在 JavaScript 中有著重要用途,其屬性即全域定義的符號。解譯器啟動時會建立一個全域物件並賦予初始屬性,包括:

  • 全域屬性:undefined、Infinity、NaN
  • 全域函式:isNaN()、parseInt()、eval()
  • 構造函式:Date()、RegExp()、String()、Object()、Array()
  • 全域物件:Math、JSON

在客戶端 JavaScript 中,window 物件充當全域物件。若程式宣告了一個全域變數,它就是全域物件的一個屬性。

六、包裝物件

字串並非物件,卻擁有屬性與方法,這是因為當參照字串屬性時,JavaScript 會以 new String(s) 的方式暫時將它轉為物件來處理屬性參照,處理完畢後這個臨時物件便被銷毀:

var s = "hello world";
var word = s.substring(s.indexOf(" ") + 1, s.length); // 使用字串屬性
document.write(word);

數字與布林值同樣具備各自的方法,透過 Number() 與 Boolean() 建立臨時物件來呼叫(null 與 undefined 沒有包裝物件,存取其屬性會發生型別錯誤)。以下程式說明了臨時物件的特性:

var s = "test";
s.len = 4;   // 試圖設定屬性,但作用於臨時物件,隨即被銷毀
var t = s.len; // => undefined

也可顯式建立包裝物件:

var s = "test", n = 1, b = true;
var S = new String(s);
var N = new Number(n);
var B = new Boolean(b);

== 運算子會將原始值與其包裝物件視為相等,但 === 則視為不等,typeof 也能看出兩者的差異。

七、不可變的原始值與可變的物件參照

原始值(undefined、null、布林值、數字、字串)與物件(含陣列與函式)有著根本差異:原始值不可變更,任何方法都無法改變它。

var s = "hello world";
s.toUpperCase(); // 回傳 "HELLO WORLD",並未改變 s
s                // => "hello world"

原始值的比較是「值的比較」,只有值相等時才相等。而物件是「參照型別(reference type)」,其比較是參照的比較——即使兩個物件擁有完全相同的屬性與值,只要不是同一個物件就不相等:

var o = {x: 1}, p = {x: 1};
o === p;  // => false,兩個獨立物件永不相等
var a = [], b = [];
a === b;  // => false,兩個獨立陣列永不相等

將物件賦值給變數,只是複製了參照,物件本身並未被複製:

var a = [];
var b = a;  // b 參照同一個陣列
b[0] = 1;
a[0]        // => 1,a 也會被修改
a === b     // => true,a 與 b 參照同一個陣列

若要得到物件或陣列的複本,必須顯式複製每個屬性或元素:

var a = ['a', 'b', 'c']; // 待複製的陣列
var b = [];              // 複製到的目標空陣列
for (var i = 0; i < a.length; i++) {
  b[i] = a[i];
}

同理,要比較兩個獨立陣列,必須逐一比較元素:

function equalArrays(a, b) {
  if (a.length != b.length) return false; // 長度不同則不相等
  for (var i = 0; i < a.length; i++)     // 遍歷所有元素
    if (a[i] !== b[i]) return false;     // 任一元素不等則不相等
  return true;                           // 否則相等
}

八、型別轉換

JavaScript 的型別轉換非常靈活:

10 + "object"     // => "10object"
"7" * "4"         // => 28,兩個字串均轉為數字
var n = 1 - "x"   // => NaN,字串 x 無法轉為數字
n + " objects"    // => "NaN objects"

原始值轉字串的情形已明確定義;轉數字則較微妙——以數字表示的字串可直接轉為數字(前後允許空格),但含非數字字元則結果為 NaN。有些轉換看來奇怪:true 轉為 1,false 與空字串 "" 轉為 0。原始值轉物件則透過 String()、Number() 或 Boolean() 建立各自的包裝物件,而 null 與 undefined 用在期望物件的地方會造成型別錯誤。

轉換與相等性

由於 JavaScript 能靈活轉換型別,== 相等運算子的含義也隨之變得多樣。以下比較結果皆為 true:

null == undefined // 這兩值被認為相等
"0" == 0          // 比較前字串轉為數字
0 == false        // 布林值轉為數字
"0" == false      // 字串與布林值都轉為數字

需特別注意:一個值轉換為另一個值,並不意味著兩者相等。if 語句會把 undefined 轉為 false,但這不表示 undefined == false。

顯式型別轉換

最簡單的顯式轉換方式是使用 Boolean()、Number()、String() 或 Object()(不加 new 時作為轉換函式):

Number("3")     // => 3
String(false)   // => "false"
Boolean([])     // => true
Object(3)       // => new Number(3)

某些運算子也會做隱式轉換:

x + ""   // 等同 String(x)
+x       // 等同 Number(x),也可寫成 x - 0
!!x      // 等同 Boolean(x)

Number 類別的 toString() 可接受表示基數的參數(範圍 2-36):

var n = 17;
b_string = n.toString(2);      // 轉為 10001
o_string = "0" + n.toString(8); // 轉為八進位 021
hex_string = "0x" + n.toString(16); // 轉為十六進位 0x11

另有三個方法控制數字到字串的輸出格式:

var n = 123456.789;
n.toFixed(0);       // "123457"
n.toFixed(2);       // "123456.79"
n.toFixed(5);       // "123456.78900"
n.toExponential(1); // "1.2e+5"
n.toExponential(3); // "1.235e+5"
n.toPrecision(4);   // "1.235e+5"
n.toPrecision(7);   // "123456.8"
n.toPrecision(10);  // "123456.7890"

字串轉數字方面,parseInt() 只解析整數,parseFloat() 可解析整數與浮點數:

parseInt("3many nice")   // => 3
parseFloat("3.14meters") // => 3.14
parseInt("-12.34")       // => -12
parseInt("0xff")         // => 255
parseFloat(".1")         // => 0.1
parseInt("0.1")          // => 0
parseInt(".1")           // => NaN,不能以 . 開始

parseInt() 還可接受第二個參數指定基數(2-36):

parseInt("11", 2)   // => 3(1*2+1)
parseInt("ff", 16)  // => 255
parseInt("zz", 36)  // => 1295
parseInt("077", 8)  // => 63
parseInt("077", 10) // => 77

物件轉原始值

所有物件都轉為 true。物件到字串與物件到數字的轉換透過 toString() 與 valueOf() 兩個方法完成。預設的 toString() 不會回傳有趣的值:

({x:1, y:2}).toString(); // => "[object object]"

許多類別定義了更具體的 toString():

[1, 2, 3].toString();                    // => "1,2,3"
(function(x){f(x);}).toString();         // => 函式的原始碼字串
/\d+/g.toString();                        // => /\d+/g
new Date(2015, 0, 1).toString();          // => 可讀的日期字串

valueOf() 則傾向於將物件轉為原始值。陣列、函式與正則表達式繼承預設方法,回傳物件本身;日期類別的 valueOf() 回傳自 1970 年 1 月 1 日以來的毫秒數:

var d = new Date(2015, 0, 1);
d.valueOf(); // => 1420041600000

九、變數宣告

使用變數前應先以 var 宣告,也可一次宣告多個並同時指定初始值:

var i;
var sum;
var i, sun;
var message = "hello";
var i = 0, j = 0, k = 0;

在 for 與 for/in 迴圈中也可使用 var 宣告迴圈變數:

for (var i = 0; i < 10; i++) log(i);
for (var i = 0, j = 10; i < 10, j = 100; i++, j--) console.log(i * j)
for (var p in o) console.log(p);

JavaScript 的變數是無型別的,同一變數可被賦予不同型別的值:

var i = 10;
i = "ten";

十、變數作用域

變數的作用域(scope)是原始碼中定義該變數的區域。全域變數擁有全域作用域,在程式任何地方都看得見;在函式內部宣告的變數則是局部變數,只在函式體內有效。函式參數也是局部變數。函式內局部變數的優先級高於同名全域變數:

var scope = "global"; // 全域變數
function checkscope() {
  var scope = "local"; // 同名的局部變數
  return scope;
}
checkscope(); // => "local"

雖然全域作用域下可省略 var,但宣告局部變數時則必須使用 var,否則會不小心改動全域變數或污染全域命名空間:

scope = "global"; // 甚至不用 var 宣告全域變數
function checkscope2() {
  scope = "local";  // 修改了全域變數
  myscope = "local"; // 隱式宣告了一個新的全域變數
  return [scope, myscope];
}
checkscope2(); // => ["local","local"],產生了副作用
scope          // => "local",全域變數被修改
myscope        // => "local",全域命名空間被搞亂

函式定義可以嵌套,因而形成多層局部作用域:

var scope = "global scope"; // 全域變數
function checkscope() {
  var scope = "local scope"; // 局部變數
  function nested() {
    var scope = "nested scope"; // 嵌套作用域內的局部變數
    return scope;
  }
  return nested();
}
checkscope(); // => "nested scope"

函式作用域與宣告提前

類似 C 語言的語言具有「塊級作用域(block scope)」,變數在宣告它們的區塊外不可見;而 JavaScript 沒有塊級作用域,取而代之的是「函式作用域(function scope)」——變數在宣告它們的函式體及所有嵌套函式體內都有意義。

function test(o) {
  var i = 0; // i 在整個函式體內皆有定義
  if (typeof o == "object") {
    var j = 0; // j 在函式體內有定義,不僅在這個區塊內
    for (var k = 0; k < 10; k++) { // k 在函式體內有定義,不僅在迴圈內
      console.log(k); // 輸出 0-9
    }
    console.log(k);  // k 已定義,輸出 10
  }
  console.log(j);    // j 已定義,但可能未初始化
}

由於函式作用域的特性,變數在宣告之前甚至就「可用」,這被非正式地稱為宣告提前(hoisting):函式裡宣告的所有變數(但不含賦值)都會被提前到函式頂部:

var scope = "global";
function f() {
  console.log(scope); // 輸出 "undefined",而非 "global"
  var scope = "local"; // 變數在這裡賦初值,但本身在函式內任何地方皆有定義
  console.log(scope); // 輸出 "local"
}

上述過程等價於將變數宣告「提前」至函式頂部,同時把初始化留在原處:

function f() {
  var scope;          // 在函式頂部宣告局部變數
  console.log(scope); // 變數存在,但值為 "undefined"
  scope = "local";    // 在此初始化並賦值
  console.log(scope); // 這裡它具有我們期望的值
}

作為屬性的變數

宣告 JavaScript 全域變數時,其實就是定義了全域物件的一個屬性。以 var 宣告的屬性不可配置,無法用 delete 刪除;而未經宣告就賦值的變數則是全域物件正常且可刪除的屬性:

var truevar = 1;    // 宣告一個不可刪除的全域變數
fakevar = 2;         // 建立全域物件一個可刪除的屬性
this.fakevar2 = 3;   // 同上
delete truevar       // => false,變數並未被刪除
delete fakevar       // => true,變數被刪除
delete this.fakevar2 // => true,變數被刪除

作用域鏈

JavaScript 是基於詞法作用域的語言:透過閱讀包含變數定義的原始碼,就能知道變數的作用域。全域變數在程式中始終有定義;局部變數則在宣告它的函式體內及其嵌套的函式內始終有定義。

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