DIV CSS 佈局教程網

JavaScript 學習總結【4】:流程控制、JSON、定時器與閉包深入
編輯:JavaScript基礎知識     

這是 JavaScript 系列筆記的第四篇,重點整理流程控制、數據交換格式 JSON、定時器、事件對象,以及提升、回調、閉包等容易被忽略卻至關重要的底層知識。

一、流程控制語句

1. if 判斷

if 語句的核心是「條件成立才執行」。if...else 在條件為真時執行 if 後的代碼塊,為假時轉而執行 else 後的代碼塊;透過 if...else 嵌套,可以在多組條件之間挑選對應分支。if 幾乎能接受任意類型的數據,也擅長表達複雜的邏輯關係。

2. switch 語句

當分支數量很多時,switch 比層層嵌套的 if...else 更清爽,它專為多重選擇而設計,但只能處理枚舉式的等值判斷。用 if 也能實現同樣效果,取捨取決於場景與個人習慣。

switch 的執行機制是:先計算括號中的表達式(通常是變量),再拿它依序與每個 case 的值比對;一旦匹配就執行該 case 後的語句,全部不匹配則執行 default。每個 case 結尾都應該寫上 break,否則會「穿透」到下一個 case 繼續執行。

var d = new Date().getDay();
switch (d) {
  case 6: alert("今天是星期六"); break;
  case 0: alert("今天是星期天"); break;
  default: alert("工作日,繼續努力。");
}

需要特別留意:switch 內部使用的是全等(===)比較,而非相等(==)。因此字符串 "5" 與數字 5 並不匹配。

// switch 中字符串與數字不匹配,會走 default
var n = '5';
switch (n) {
  case 5: alert('等於,執行 case'); break;
  default: alert('不等於,執行 default');
}

// if 使用 == 會先做隱式轉換,結果為「等於」
var n = '2';
if (n == 2) { alert('等於'); } else { alert('不等於'); }

// 把 case 改成字符串即可匹配
var n = '2';
switch (n) {
  case '2': alert('等於,執行 case'); break;
  default: alert('不等於,執行 default');
}

// if 使用 === 不轉換類型,結果為「不等於」
var n = '2';
if (n === 2) { alert('等於'); } else { alert('不等於'); }

3. for 循環

現實中很多事情需要重複執行,例如連續打印十份文件。循環就是反覆執行同一段代碼,而每一輪的取值各不相同。

var sum = 0;
for (var rmb = 1; rmb <= 10; rmb++) {
  sum += rmb;
}
alert('一共有:' + sum + '元'); // 55

4. while 循環

while 與 for 功能一致:只要條件為 true 就持續執行,直到條件不再滿足。

var i = 0;
while (i < 5) {   // 條件:成立則繼續
  alert(i);
  i++;            // 更新:讓循環能推進
}
// 對照 for(初始化; 條件; 更新){ 語句 },for 的寫法更緊湊

5. do...while 循環

do...while 的結構與 while 幾乎相同,差別在於它先執行一次代碼塊,再判斷條件。若條件寫得不當,就會陷入死循環,把瀏覽器拖到崩潰。

var num = 6;
do {
  document.write("數字:" + num + "<br>");
  num -= 1;
} while (num > 0);

6. 錯誤處理:try...catch 與 throw

try 用來標記需要監測的代碼段,catch 負責接住 try 中拋出的異常。執行順序是:先跑 try,一旦出錯就跳過 try 剩餘語句、轉入 catch;若全程無誤,catch 不會執行。對於可預見的錯誤,這種結構非常好用。

try {
  document.write("進入 try<br>");
  alert(x);          // 拋出錯誤
  alert('123');      // 不會執行
} catch (e) {
  document.write("進入 catch<br>");
  document.write("錯誤類型:" + e.name + "<br>");
  document.write("錯誤信息:" + e.message);
}

throw 用於主動創建並拋出自定義異常,語法為 throw 異常對象。它常與 try...catch 搭配,用來控制程序流向、給出精確的錯誤提示。

function error() {
  try {
    var x = document.getElementById("txt").value;
    var y = document.getElementById("demo");
    y.style.color = 'red';
    if (x == '') throw '輸入不能為空';
    if (isNaN(x)) throw '請輸入數字';
    var num = [7, 8, 9];
    for (var i = 0; i < num.length; i++) {
      if (x == num[i]) throw '該數字已經存在';
    }
    if (x == 0) throw '輸入不能為 0';
    else if (x > 10) throw '數字太大了';
    else if (x <= 3) throw '數字太小了';
    else {
      y.style.color = 'green';
      y.innerHTML = 'OK';
    }
  } catch (e) {
    y.innerHTML = '錯誤提示:' + e + '!';
  }
}

7. 跳出循環的三種方式

  • break:直接終止整個循環,不再進行後續判斷。
  • continue:只結束本次循環,接著進入下一輪判斷。
  • return:終止函數執行並返回值。
for (var i = 0; i < 6; i++) {
  if (i == 3) break;
  alert(i);            // 0, 1, 2
}
for (var i = 0; i < 6; i++) {
  if (i == 3) continue;
  alert(i);            // 0, 1, 2, 4, 5
}

二、JSON

JSON(JavaScript Object Notation)是 JS 對象表示法,主要承擔數據的存儲與交換,角色近似 XML,但可讀性、可寫性與解析難度都更友好。

其語法是 JS 對象語法的子集:數據以「名稱: 值」的鍵值對形式組織,鍵值對之間用逗號分隔,花括號包裹對象,方括號包裹數組。

"名稱" : "值", "名稱" : "值"

名稱與值都用雙引號包裹,中間以冒號相連。JSON 的值可以是數字(整數或把小數)、字符串、布爾值、對象、數組或 null。JSON 本質是純文本,常用於服務端向網頁傳遞數據。

1. JSON 對象

var json = {"a": 12, "b": "abc", "c": [1, 2, 3]};
alert(json.a);            // 12
json.b = "xyz";           // 修改屬性值
alert(json.c[0]);         // 1

2. JSON 與數組的異同

相同點:都能透過下標取值,都能用循環遍歷。JSON 沒有 length 屬性,無法使用 for 循環,但可以用 for...in 完成同樣的事。

不同點:JSON 的下標是字符串,數組的下標是數字;JSON 沒有 length,數組有。

var arr = [12, 5, 7];
var json = {"a": 12, "b": 5, "c": 7};
alert(arr[0]);        // 12
alert(json["a"]);     // 12
alert(arr.length);    // 3
alert(json.length);   // undefined

for (var i in json) {
  alert('屬性 ' + i + ' 的值是:' + json[i]);
}

數組雖然也能用 for...in,但並不推薦——for...in 遍歷的是對象的可枚舉屬性而非下標序列,數組首選仍是傳統 for 循環。

3. JSON 數組對象

var staff = [
  {"name": "小明", "sex": "男", "id": 1},
  {"name": "小白", "sex": "男", "id": 2},
  {"name": "小紅", "sex": "女", "id": 3}
];
document.getElementById("fname").innerHTML = staff[0].name;
document.getElementById("lname").innerHTML = staff[1].name = '大白'; // 修改並賦值

4. JSON 字符串與對象的互轉

var str = '{"name":"小明","sex":"男","age":21}';
var toObj = JSON.parse(str);      // 字符串 → 對象
alert(toObj.name);                // 小明

var json = {"name": "小紅", "sex": "女", "age": 18};
var toStr = JSON.stringify(json); // 對象 → 字符串
alert(typeof toStr);              // string

5. JSON 的應用場景

當需要描述一組層次化數據時,JSON 既提升可讀性又降低結構複雜度:多個值之中還能嵌套多個值。例如用戶列表,可以全部收進一個變量,先分成若干分組,每組再分成多個條目,每個條目記錄一位用戶的資料。

var userName = {
  "first": [
    {"name": "路飛", "sex": "男", "tel": "aaa"},
    {"name": "索羅", "sex": "男", "tel": "bbb"},
    {"name": "娜美", "sex": "女", "tel": "ccc"}
  ],
  "second": [
    {"name": "卡卡西", "sex": "男", "tel": "ddd"},
    {"name": "鳴人", "sex": "男", "tel": "fff"}
  ]
};
alert(userName.first[1].name);   // 索羅
alert(userName.second[0].tel);   // ddd

6. 延伸:JSONP

談到 JSON,就不能不提 JSONP(JSON with Padding)。它不是新的數據格式,而是一種「使用模式」,讓網頁能跨域名取回數據,用以繞開同源策略的限制。

同源策略由 Netscape 提出,如今所有支援 JavaScript 的瀏覽器都實作它。受其約束,位於某個站點的頁面通常無法與其他站點的服務器溝通——而 HTML 的 <script> 元素是公認的例外。正是利用這一開放特性,網頁得以載入其他來源動態產生的數據,這種做法就被稱為 JSONP。

關鍵點在於:JSONP 取回的內容並不是 JSON,而是任意 JavaScript 代碼,由 JS 解釋器執行,而非由 JSON 解析器解析。

三、JS 定時器

定時器讓代碼在指定時間間隔之後才執行,而不是函數被調用時立刻執行。它在網頁中應用極廣,動態時鐘、限時搶購倒計時都是典型場景。

定時器分兩類:間隔型 setInterval 從設定起每隔一段時間反覆執行;延遲型 setTimeout 在指定時間後執行一次,僅此一次。兩者都掛在 window 對象上。

function show() { alert(1); }

setInterval(show, 1000); // 每隔 1 秒執行一次,無限循環
setTimeout(show, 1000);  // 1 秒後執行一次

1. 動態時鐘

function clock() {
  var d = new Date();
  document.getElementById("demo").innerHTML =
    d.getHours() + ":" + d.getMinutes() + ":" + d.getSeconds();
}
setInterval(clock, 1000);

2. setTimeout 計數

var num = 0;
function start() {
  document.getElementById('demo').value = num;
  num += 1;
  setTimeout(start, 1000);   // 在函數內部再次排隊,實現遞歸計時
}
setTimeout(start, 1000);

3. 清除定時器

clearInterval() 用來關閉 setInterval 建立的定時器,clearTimeout() 用來關閉 setTimeout 建立的定時器。使用時必須把定時器保存到全局變量,否則無從清除。

var time = null;
function start() {
  time = setInterval(function () {
    var d = new Date();
    document.getElementById("txt1").value =
      d.getHours() + ":" + d.getMinutes() + ":" + d.getSeconds();
  }, 1000);
}
function stop() { clearInterval(time); }
start();

四、Event 對象

Event 對象承載事件的狀態,能讀出鼠標按鈕、鼠標位置、鍵盤按鍵等細節。事件通常與函數搭配使用,函數在事件發生之前不會執行。

1. 鼠標坐標

  • screenX / screenY:相對於屏幕,參照點是屏幕左上角。
  • clientX / clientY:相對於瀏覽器可視區,參照點是頁面左上角。
document.onclick = function () {
  alert(event.clientX + ',' + event.clientY); // 可視區坐標
  alert(event.screenX + ',' + event.screenY); // 屏幕坐標
};

2. 鼠標按鍵

button 屬性返回被點擊的按鍵:0 為左鍵,1 為中鍵,2 為右鍵。

document.onmousedown = function () { alert(event.button); };

3. 鍵盤按鍵

keyCode 返回被按下按鍵的鍵碼。ctrlKey、shiftKey、altKey 則是布爾標誌,用來判斷事件發生時對應的修飾鍵是否處於按下狀態。

document.onkeydown = function () {
  if (event.ctrlKey)      alert('Ctrl 被按下');
  else if (event.shiftKey) alert('Shift 被按下');
  else if (event.altKey)   alert('Alt 被按下');
  else                     alert('都沒被按下');
};

實例:回車(鍵碼 13)或 Ctrl + 回車提交內容。

oTxt1.onkeydown = function () {
  if (event.keyCode == 13 || (event.keyCode == 13 && event.ctrlKey)) {
    oTxt2.value += oTxt1.value + '\n';
    oTxt1.value = '';
  }
};

4. 事件流

事件傳遞有兩個方向,它們共同定義了元素觸發事件的順序:

  • 事件冒泡:元素觸發事件後,事件沿著父級、爺級層層向上傳遞,直到 document。
  • 事件捕獲:與冒泡相反,由外層元素先觸發,再觸及內部元素,也就是從祖先走向後代。

兩種事件流都會從 document 開始、在 document 結束,而捕獲型總是先發生。

語法:addEventListener('事件名稱', 函數, 冒泡/捕獲)

addEventListener() 不會覆蓋已有事件,可以為同一元素掛載多個監聽。三個參數分別是事件類型、觸發後要執行的函數,以及決定冒泡(false)或捕獲(true)的布爾值。注意事件名不要加 "on" 前綴,寫 "click" 而不是 "onclick"。

x.addEventListener("click", function () { alert("div1 冒泡"); }, false);
document.body.addEventListener("click", function () { alert("body 捕獲"); }, true);

removeEventListener() 用於移除監聽,但綁定時不能使用匿名函數,否則沒有引用可刪除。

oDiv.addEventListener("mousemove", block, false);
function block() { oP.innerHTML = Math.random() * 10; }
oBtn.onclick = function () {
  oDiv.removeEventListener("mousemove", block, false);
};

event.cancelBubble = true 可以阻止冒泡。例如做一個「點擊顯示、點擊其他位置隱藏」的仿翻譯彈層:若不阻止冒泡,點擊按鈕的同一瞬間,事件會繼續冒泡到 document 而把剛顯示的 div 立刻藏起來。

5. 默認事件

默認事件指瀏覽器自帶的行為,例如在輸入框中按鍵會自動寫入字符、在空白頁右鍵會彈出菜單。若想自定義右鍵菜單,就要阻止默認行為,最簡潔的寫法是 return false;。

實例:只允許輸入數字的輸入框。數字鍵 0~9 的鍵碼是 48~57,超出範圍就攔下;同時放行退格鍵(8)、左方向鍵(37)、右方向鍵(39),方便刪改與移動光標。

oTxt.onkeydown = function () {
  var k = event.keyCode;
  if (k != 8 && k != 37 && k != 39 && (k < 48 || k > 57)) {
    return false;
  }
};

五、值得反覆咀嚼的 JS 知識點

1. 預解析與提升(Hoisting)

JS 引擎的解析分為預解析與執行兩個階段。進入新環境時,引擎會先把該環境中的變量聲明與函數聲明提前處理好,這一步的單位是一個執行環境。

頁面中多個 script 標籤(含外部引入的 JS 文件)各自構成獨立執行環境,預解析不跨代碼段。在一個 script 中聲明、在另一個 script 中引用,會直接報錯。

alert(a(2));            // 4,函數聲明已提升
function a(x) { return x * x; }

alert(b);               // undefined,var 提升但未賦值
var b = 'hello';

var c = function (y) { return y * y; }; // 函數表達式不提升,先調用會報錯

函數內部用 var 聲明的變量屬於私有變量,外部無法訪問。

<script>alert(a);</script>        <!-- 報錯:a is not defined -->
<script>var a = 'hello';</script>

另外兩條規律:同名函數後定義者覆蓋先定義者;變量與函數同名時,函數優先級更高。

alert(a);        // function a(){ alert('hi'); }
var a = 'hello';
function a() { alert('hi'); }
alert(a);        // hello,執行階段被賦值覆蓋

b();             // 2
function b() { alert(1); }
b();             // 2,後一個聲明覆蓋了前一個
function b() { alert(2); }

2. 回調函數

回顧一下調用過程:函數 a 接收一個參數,該參數本身是函數 b;a 執行完畢後再執行 b,這就是回調。官方說法是:回調是一個函數作為參數傳給另一個函數,由母函數完成後調用。此時 b 被稱為回調函數,a 是母函數。

回調函數不是由母函數直接調用,而是在特定事件或條件發生時由另一方觸發,用來響應該事件。JS 回調的本質是異步流程,在異步場景下性能表現優異。

打個比方:朋友來找你,到樓下時打電話。「來找你」是函數 a 開始執行,這段時間「你」可以隨意做別的事,「到樓下」代表 a 執行完畢,「打電話」就是回調函數 b。

function a(callback) {
  alert("我是母函數 a");
  callback();
}
function b() { alert("我是回調函數 b"); }
a(b);

3. 自調用函數(立即執行函數)

用 function 定義並命名的叫函數聲明;用 function 定義、不命名、再賦值給變量的叫函數表達式,這是最常見的表達式寫法。匿名函數屬於函數表達式,可以賦給變量創建函數,也可以賦給事件成為事件處理程序。

兩者的關鍵差異:函數聲明會被提升到當前執行環境頂部;函數表達式要等引擎執行到它所在位置時才逐行解析。因此函數聲明不能自調用,函數表達式可以。

自調用的寫法是在函數體後加一對括號,再用括號把整體包起來,藉此表明它是表達式而非聲明。

(function (a, b) { alert(a * b); }(2, 3)); // 6

4. 構造函數

函數既可用 function 定義,也可用 new 調用。函數即對象,對象擁有屬性與方法:把函數作為某個對象的屬性,稱之為對象方法;而用於創建新對象的函數,就是該對象的構造函數。

5. 閉包

一句話概括:子函數可以使用父函數中的局部變量。前面 window.onload 內定義點擊事件函數的寫法,其實已經用到了閉包。

函數外聲明的是全局變量,函數內聲明的是局部變量。全局變量掛在 window 上,任何位置都能訪問;局部變量只在定義它的函數內部有效。這構成 JS 的作用域鏈:內層函數可以訪問外層函數的局部變量,外層函數無法訪問內層的。即使同名,全局變量與局部變量也是兩個彼此獨立的變量。

要留意:函數內聲明變量若省略 var,該變量會成為全局變量。

所有函數都能訪問上一層作用域,JS 支援函數嵌套,嵌套函數可以讀取上一層的函數變量。閉包就是能訪問上一層作用域變量的函數,即使上一層函數已經執行結束。

閉包的價值可以透過一個計數器需求逐步體會。

方案一:用全局變量計數。缺點是變量到處可改,還沒點擊計數就可能被別處改成 10。

var num = 0;
function count() { return num += 1; }

方案二:把變量收進函數內部。外部改不動了,但每次調用都重新初始化為 0,點多少次都返回 1。

function count() {
  var num = 0;
  return num += 1;
}

方案三:用嵌套函數讓內層去改外層變量。計數正確了,但內嵌函數無法從外部調用。

function count() {
  var num = 0;
  function add() { num += 1; }
  add();
  return num;
}
add(); // 報錯:未定義

方案四:閉包登場。

var count = (function () {
  var num = 0;
  return function () { return num += 1; };
}());

function show() {
  document.getElementById('p1').innerHTML = count();
}

count 接收的是自調用函數的返回值。自調用只執行一次,計數初值定為 0,並返回一個函數表達式;num 被匿名函數的作用域保護起來,外部只能透過 count() 修改。count 得以作為函數調用、並持續訪問上一層作用域的計數值——這就是閉包,函數擁有了自己的私有變量。

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