JavaScript 是瀏覽器內建、負責行為的程式語言:資料變了,接下來要算什麼。這一篇先不改畫面,只在 Console 把值算對:變數、型別、字串、判斷、迴圈、函式,再到陣列、物件與解構展開。Math、Date、錯誤處理與模組放在選讀。選取元素、重繪列表與非同步請求分在後面兩篇。
認識 JavaScript JavaScript 是瀏覽器用來描述行為的程式語言。這一章先說明它是什麼:和 HTML、CSS 怎麼分工、ECMAScript 是什麼,以及它能在哪些環境執行。接著學最基本的寫法:把程式寫進 HTML、用 Console 看結果、加上註解,再把程式拆成外部檔。選讀看瀏覽器內建的彈窗。
JavaScript 是什麼 網頁分成結構、外觀、行為三層。前兩層你已經寫過,行為這層才開始用程式描述事情發生之後要做什麼。這一節依序看三層的分工、語言的標準版本,以及程式可以執行的環境。
HTML、CSS、JavaScript 的分工 HTML 負責結構,CSS 負責外觀,JavaScript 負責行為。標記與樣式只決定頁面上有什麼、長什麼樣子;點了之後要算什麼、送出前要檢查什麼,這些互動要寫成 JavaScript 才會發生。
ECMAScript 與現代寫法 瀏覽器內建了 JavaScript 的執行能力,讀到 script 就由上往下執行。語言的標準叫做 ECMAScript,2015 年的第 6 版(ES6)加入 let、const、箭頭函式與模組,本課使用 ES6 以後的現代寫法。
名稱裡有 Java,但它和 Java 是兩種不同的語言,語法與執行環境都不一樣。
執行環境:瀏覽器與 Node.js 同一套 JavaScript 可以在兩個地方執行:瀏覽器用它操作網頁與表單,Node.js(讓 JavaScript 離開瀏覽器、在電腦上執行的環境)可以讀寫檔案,pnpm 與 Vite 這類工具也是靠 Node.js 執行。前面安裝的 Node.js 負責工具鏈,寫出來的網頁程式最後仍然送到瀏覽器執行。
graph LR
js["JavaScript"] --> browser["瀏覽器"]
js --> node["Node.js"]
browser --> b1["操作頁面、處理點擊與表單"]
browser --> b2["DevTools 的 Console 查看結果"]
node --> n1["讀寫檔案"]
node --> n2["執行 pnpm、Vite 等用 JavaScript 寫成的工具"]
本篇先在瀏覽器裡學語言本身:值、變數、函式,以及陣列和物件。結果都印到 Console,下一篇才開始用 JavaScript 操作畫面,也就是文件物件模型(DOM)。
撰寫與執行 JavaScript 程式要放進 HTML 才會被瀏覽器執行,結果則要打開 DevTools 的 Console 才看得到。這一節先把程式直接寫在 HTML 裡,認識 Console 與註解,最後再看實務上的做法:把程式拆成外部檔。選讀的最後是瀏覽器內建的彈窗。
內嵌 script 程式可以直接寫在 HTML 的 script 標籤中間,不必另開檔案。瀏覽器讀頁面時由上往下處理,碰到 script 就執行裡面的程式。
觀念
04-js/pages/01-js-inline.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 內嵌 script</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log ('第一段' ); </script > <script > console .log ('第二段' ); </script > </body > </html >
解析
頁面上只看得到那句說明,兩段 script 的結果都在 Console,因為程式沒有改動 HTML。
瀏覽器先執行第一段,再執行第二段,所以 Console 的順序和標籤在檔案裡的先後相同。
本章的輸出區塊只列出文字內容,和 Console 實際畫面(行號、引號、顏色)略有不同。後面的 demo 為了閱讀方便,除了外部檔那一節,程式都寫在同一份 HTML 的 script 裡。
Console 與 console.log Console 是 DevTools 裡顯示程式輸出的面板,也是學習階段最常用的除錯工具。程式呼叫 console 提供的指令(稱為方法)把訊息送進去,頁面本身不會被改動。
打開任一個網頁,按 F12 (Mac 可按 Cmd + Option + J )打開 DevTools 並切到 Console,也可以直接在裡面輸入一行程式再按 Enter,馬上看到結果。這種寫法不會存進檔案,重新整理就消失,適合臨時試算。
Console 會在下一行顯示 150。要讓程式自己把結果印出來,就用下面這些方法。
一覽
console.log 印一般訊息。
console.warn 印黃色提醒。
console.error 印紅色錯誤。
觀念
04-js/pages/02-js-console-log.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > console.log、console.warn 與 console.error</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log ('Hello JavaScript' ); console .log ('一般訊息' ); console .warn ('這是提醒' ); console .error ('這是錯誤' ); </script > </body > </html >
解析
打開 Console 重新整理,由上到下出現四行:兩行一般訊息、一行黃色提醒、一行紅色錯誤。
三種方法只差在顯示的樣式與層級,訊息內容都是括號裡的文字。
頁面中間仍是那句說明,因為這四行都只寫進 Console。
Hello JavaScript 一般訊息 這是提醒 這是錯誤
Console 的篩選器 可以分開顯示一般訊息、提醒與錯誤。為了觀察而留下的輸出,正式上線前要刪掉,避免 Console 堆滿雜訊。
註解 註解是寫給人看的說明,瀏覽器會整段跳過。它也能暫時停用一段程式,不必刪掉。
觀念
04-js/pages/03-js-comment.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 註解</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log ('第一行' ); console .log ('第二行' ); </script > </body > </html >
解析
Console 只有兩行,因為被註解掉的 console.log 和多行註解裡的文字都不會執行。
行尾註解不影響前面那句程式,它仍然照常印出。
若多行註解少了結尾,後面的 console.log 也會被包進去,Console 就只剩第一行。
註解寫原因 「印出第一行」這種註解只是重複程式。比較有用的是說明為什麼這樣寫,例如「這筆先不印,因為值還沒決定」。
外部 script 檔 內嵌的程式只能給單頁使用。實務上把程式放進獨立的 .js 檔,HTML 用 script 的 src 屬性指到它,同一份程式就能掛到多個頁面,HTML 也不會被程式碼撐得很長。
載入與執行順序 瀏覽器讀到帶有 src 的 script,會先載入檔案再執行,寫在它後面的 HTML 要等它跑完才繼續處理。多支外部檔也依照它們在頁面裡的位置,由上往下各跑一次。
graph LR
html["HTML 載入 script"] --> run["瀏覽器由上往下執行"]
run --> log["console.log 印出值"]
log --> panel["DevTools 的 Console"]
本篇的 demo 都把 script 放在 body 最後,頁面內容先被讀到,程式再執行,載入檔案時才不會擋住頁面顯示。
src 的相對路徑 src 寫的是外部檔的位置,路徑寫錯,這支程式就完全不會執行。
觀念
路徑相對於這份 HTML 所在的資料夾。檔案在同一個資料夾,直接寫檔名即可。
檔案在子資料夾,路徑要帶資料夾名稱;檔案在上一層,路徑以 ../ 開頭。
路徑以斜線開頭,是從網站根目錄算起。開發時的根目錄和部署後的根目錄可能不同,所以本課一律用相對路徑。
src="03b-js-console.js" 同一個資料夾 src="js/03b-js-console.js" 子資料夾 js 裡 src="../03b-js-console.js" 上一層資料夾 src="/03b-js-console.js" 網站根目錄
04-js/pages/03b-js-console.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 外部 script 檔</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script src ="03b-js-console.js" > </script > </body > </html >
04-js/pages/03b-js-console.js
解析
HTML 和 js 放在同一個資料夾,src 只寫檔名,瀏覽器就能載入。Console 顯示「外部檔已載入」,表示外部檔跑成功。
把 src 改成 js/03b-js-console.js,這個資料夾底下沒有 js 子資料夾,檔案找不到。用 Live Server 開啟時 Console 會出現 404,直接開檔案時多半是 ERR_FILE_NOT_FOUND。
兩種訊息都代表檔案沒載到,外部檔裡的程式完全沒執行。
選讀:alert、confirm 與 prompt 這三個是瀏覽器內建的函式,會跳出必須先處理的視窗。程式本來就一行一行往下跑,碰到彈窗就停住,等視窗關掉才繼續,這種等待叫做同步阻斷。
觀念
alert 只顯示訊息,沒有可用的回傳值(函式執行完交回來的結果)。
confirm 讓人選確定或取消,回傳 true 或 false。
prompt 讓人輸入文字,回傳輸入的字串;按取消得到 null。
實務上很少用:彈窗會卡住整個分頁,樣式也不能改成網站自己的風格。除錯請改看 Console。
04-js/pages/04-js-dialog.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > alert、confirm 與 prompt</title > </head > <body > <p > 結果在 DevTools 的 Console。每個視窗都要按掉,後面的程式才會繼續。</p > <script > console .log ('alert 之前' ); console .log (alert ('只顯示訊息' )); console .log ('alert 之後' ); console .log ('confirm 之前' ); console .log (confirm ('要繼續嗎' )); console .log ('confirm 之後' ); console .log ('prompt 之前' ); console .log (prompt ('請輸入名字' )); console .log ('prompt 之後' ); </script > </body > </html >
解析
重新整理後跳出 alert,這時 Console 只有「alert 之前」。視窗開著時頁面不能點,後面的 log 也不會出現。
按掉 alert 後,Console 印出 undefined,那是 alert 的回傳值;接著才印「alert 之後」與「confirm 之前」,然後跳出 confirm。
confirm 按確定印出 true,按取消印出 false。
prompt 輸入文字再按確定,印出那個字串;按取消印出 null;沒輸入就按確定,印出空字串,和取消不同。
以下輸出是 confirm 按確定、prompt 輸入「小明」再按確定的結果。
alert 之前 undefined alert 之後 confirm 之前 true confirm 之後 prompt 之前 小明 prompt 之後
變數與資料型別 變數是替值取的名字,程式可以先把值記在名字上,之後要印出或計算,只要寫名字就好。這一章先學怎麼宣告變數、分辨 const 與 let、了解名字有效的範圍,再認識值的種類(資料型別)、不同種類之間的轉換,以及三種容易混淆的特殊值。字串的寫法與方法留到下一章。
變數與常數 宣告變數就是替一個值取名字。這一節依序說明宣告與命名的規則、const 與 let 該怎麼選,以及名字有效的範圍。
宣告變數與命名 宣告時先寫關鍵字(const 或 let),接著是名字、等號與值。名字決定別人讀程式時能不能看懂這個值是什麼,所以要遵守硬性規則,也要照慣例命名。
觀念
宣告的寫法是 const price = 12800;,字串要加引號,數字不加。const 的用法下一小節說明。
名字不能以數字開頭,也不能使用保留字(語法自己要用的詞,例如 return、if)。
名字會區分大小寫,userName 與 UserName 是兩個互不相干的名字。
違反硬性規則時,瀏覽器在開始執行前就報 SyntaxError(語法錯誤,看不懂這行寫法),整份 script 都不會執行,連前面的 console.log 也不會出現。
名字要看得出用途:price 一看就知道是價格,x、temp、data1 看不出來,要換成有意義的名字。
名字由多個英文單字組成時不能有空白,業界依用途有固定的大小寫慣例。這些不是語法規定,但照著寫,別人一看就知道名字是哪一類東西:
const userName = 'Amy' ;const pricePerPerson = 12800 ;const UserCard = '習慣上不拿來當一般變數' ;const MAX_PEOPLE = 12 ;
04-js/pages/05-js-name.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 宣告變數與命名</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const userName = 'Amy' ; const UserName = 'Bob' ; const pricePerPerson = 12800 ; const days3 = 3 ; const returnDate = '2026-12-24' ; console .log (userName, UserName ); console .log (pricePerPerson); console .log (days3, returnDate); </script > </body > </html >
解析
第一行同時印出兩個名字的值。userName 與 UserName 只差一個字母的大小寫,卻各自保存自己的值,不會互相覆蓋,也不會報錯。
名字中間或結尾可以有數字,所以 days3 合法;保留字也只是不能單獨當名字,包含在較長的名字裡(例如 returnDate)沒有問題。
最後兩行是故意寫錯的命名:第一行以數字開頭,第二行用了保留字。若拿掉註解,整份 script 會因 SyntaxError 一行都不執行,上面的三行 console.log 也看不到。
let 與 const 的差別 兩個關鍵字都能宣告變數,差別在於宣告之後,名字能不能再指到別的值。現代寫法預設用 const,只有確定這個名字之後要換成新值時才改用 let,讀程式的人看到 const 就知道它不會變。
觀念
const 宣告之後不能再賦值(用等號放進新值),再寫一次等號會得到 TypeError(型別錯誤),原本的值留著。
let 宣告之後可以用等號換成新值。
先寫 const,寫到後來真的需要換值,再改成 let。
同一個名字在同一層不能宣告兩次,否則是 SyntaxError。
每個名字都要先宣告再用。沒有宣告就直接賦值不會報錯,卻會產生整個程式都能改到的名字,容易出錯。
04-js/pages/06-js-let.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > let 與 const 的差別</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const productName = '無線滑鼠' ; const taxRate = 0.05 ; let price = 12800 ; price = 13900 ; console .log (productName); console .log (taxRate); console .log (price); </script > </body > </html >
解析
三行依序印出字串、固定的稅率 0.05,以及換值之後的價格 13900。
price 用 let 宣告,所以能從 12800 換成 13900;productName 與 taxRate 整段程式都不會變,所以用 const。
最後一行若拿掉註解,Console 會出現 TypeError,錯誤發生的那一刻才停下來,前面三行已經印完。
const 鎖住的是名字與值的對應 數字、字串、布林放進 const 之後就不能換成別的值。陣列與物件是容器,變數裡存的是指向容器的參考,容器裡面的內容能不能改,陣列那一章會一併說明。
區塊作用域 一對大括號形成一個區塊,區塊裡用 let 或 const 宣告的名字,只在這一對大括號裡有效,這個有效範圍叫作用域。範圍分得清楚,同樣的名字才能在不同區塊各自使用而不互相干擾。
觀念
內層可以再宣告一個和外層同名的名字,兩者各自保存自己的值。
內層沒有自己宣告時,會往外層找同名的名字。
內層的名字在右大括號之後就不存在,要讀它會得到 ReferenceError(找不到這個名字)。
04-js/pages/07-js-scope.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 區塊作用域</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const place = '台北' ; const country = '台灣' ; { const place = '花蓮' ; const days = 3 ; console .log (place); console .log (days); console .log (country); } console .log (place); </script > </body > </html >
解析
前兩行是大括號裡面的值:內層的「花蓮」與數字 3。第三行的 country 內層沒有宣告,所以往外層找到「台灣」。
離開大括號後再印 place,回到外層的「台北」,可見內層同名的宣告沒有蓋掉外層。
最後一行若拿掉註解,Console 會說 days 沒有定義,因為它只存在於那一對大括號裡。
不要省略宣告 若內層寫成 place = '花蓮' 而沒有關鍵字,那不是新名字,而是在改外層的 place。外層是 const 時會 TypeError,外層是 let 時則悄悄把外層的值換掉。要一個獨立的內層名字,一定要寫宣告。
var 已淘汰 var 是 ES6(2015)之前宣告變數的唯一寫法,現代程式碼已不再使用。它不認區塊,只認函式範圍(之後學函式時會看到),所以大括號擋不住;同一個名字也能重複宣告而不報錯,容易不小心蓋掉原本的值。讀到舊程式碼遇到 var 時,把它當成較鬆散的 let 來看即可。
{ var place = '台北' ; let spot = '花蓮' ; } console .log (place); var days = 3 ;var days = 5 ;
資料型別與轉型 每個值都有自己的種類,文字是字串、計算用的是數字、成立與否是布林。種類不同,運算規則就不同,連看起來一樣的 3 與 ‘3’ 行為都不同。這一節先認識資料型別,接著學習在種類之間明確轉換,最後分清三種「沒有值」或「無效值」。
資料型別 宣告變數時不必先寫種類,值放進去的那一刻種類就決定了。一個名字固定放同一種用途的值,讀程式的人才不會誤判。這一小節先認識最常用的三種:數字、字串與布林,並用 typeof 查詢種類。
觀念
數字不加引號,整數與小數都是數字。
字串用引號包住,引號裡的數字仍然是文字。本課程統一使用單引號。
布林只有 true 與 false 兩個值,代表成立或不成立。
typeof 後面空一格接上值,結果是種類名稱的字串,不是值本身。
04-js/pages/08-js-types.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > number、string 與 boolean</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const title = '台北城市漫遊' ; const days = 3 ; const price = 12800 ; const onSale = true ; console .log (typeof title); console .log (typeof days); console .log (typeof price); console .log (typeof onSale); console .log (typeof '3' ); </script > </body > </html >
解析
前四行是種類名稱,依序為字串、數字、數字、布林。整數與小數都是 number。
最後一行的 '3' 有引號,所以種類是 string。畫面上長得和數字 3 一樣,但相加與比較的規則不同,下一小節會看到後果。
string number number boolean string
typeof 對陣列與 null 的結果 陣列拿去 typeof 得到的是 object,要確認一個值是不是陣列,改用 Array.isArray,陣列那一章會說明。typeof null 也是 object,這是早期留下來的結果,null 的判斷方式見後面的小節。
型別轉換 不同種類的值碰在一起時,JavaScript 有時會自己轉換,結果常常出乎意料,所以需要轉換時要自己明確地寫。這一小節看三個內建的轉換函式、字串接數字時的陷阱,以及從字串取出數字的兩種做法。
觀念
Number 把值轉成數字,整段都是合法數字才成功,否則得到 NaN(不是有效數字的結果,下一小節說明)。
String 把值轉成字串。
Boolean 判斷值算真還是算假,空字串、0 與 NaN 是假,其餘的字串與數字是真。
字串碰到加號會把旁邊的值接成文字,所以 '5' + 1 是 '51',不是 6。
parseInt 從左邊開始讀,遇到第一個不是數字的字元就停,因此 '12px' 得到 12;第二個參數寫 10 表示用十進位讀。
04-js/pages/09-js-convert.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 型別轉換</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log (Number ('3' ), typeof Number ('3' )); console .log (String (12800 ), typeof String (12800 )); console .log (Number ('3天' ), Number ('' )); console .log (Boolean (0 ), Boolean ('' ), Boolean ('0' )); console .log ('5' + 1 ); console .log (Number ('5' ) + 1 ); console .log (Number ('12px' ), parseInt ('12px' , 10 )); console .log (Number ('3.8' ), parseInt ('3.8' , 10 )); </script > </body > </html >
解析
前兩行是明確轉換的結果:字串 ‘3’ 變成種類為 number 的 3,數字 12800 變成種類為 string 的 ‘12800’。
第三行的「3天」含有非數字,所以 Number 得到 NaN;空字串什麼都沒有,得到 0。
第四行說明三種真假:0 與空字串是 false,文字 ‘0’ 因為不是空的,所以是 true。
'5' + 1 得到字串 51;先用 Number 轉成數字,才會得到 6。
最後兩行比較讀法:’12px’ 對 Number 是 NaN,對 parseInt 是 12;’3.8’ 對 Number 是 3.8,對 parseInt 只取整數部分得到 3。
3 number 12800 string NaN 0 false false true 51 6 NaN 12 3.8 3
判斷 NaN 要用 Number.isNaN Number.isNaN 只有在值本身就是 NaN 時才是 true。全域的 isNaN 會先把值轉成數字,字串 ‘三’ 也會被判成 true,容易誤判,所以不使用。
null、undefined 與 NaN 這三個值都代表「沒有一個可用的值」,但原因不同:有的是還沒給值,有的是刻意留空,有的是運算失敗。分清楚原因,才知道看到它們時該怎麼處理。
觀念
undefined:名字已宣告但還沒給值,系統自己放上的預設結果。
null:程式刻意設定的「沒有值」,要表示空位時自己賦值,不要拿空字串代替。
NaN:數學運算或轉成數字失敗的結果,種類仍是 number。
判斷 null 用嚴格相等 === null,不要用 typeof。嚴格相等是比較兩邊是否完全相同,運算子那一章會詳細說明。
NaN 與包括自己在內的任何值都不嚴格相等,要判斷它必須用 Number.isNaN()。
04-js/pages/10-js-special.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > null、undefined 與 NaN</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > let guide; const backup = null ; const broken = Number ('abc' ); console .log (guide); console .log (backup); console .log (backup === null ); console .log (typeof backup); console .log (broken); console .log (typeof broken); console .log (broken === broken); console .log (Number .isNaN (broken)); </script > </body > </html >
解析
guide 沒有放值,印出 undefined。
backup 是刻意設定的 null,用嚴格相等判斷得到 true;typeof backup 卻回報 object,所以不能靠 typeof 判斷 null。
broken 是轉換失敗的 NaN,種類仍是 number,這代表它是「無效的數字」,不是別的種類。
NaN 與自己比較得到 false,所以要用 Number.isNaN 才能得到 true。
undefined null true object NaN number false true
空字串不是 null 空字串是長度為 0 的字串,仍是一個有值的字串。要表示「沒有值」就用 null,兩者不要混用。
字串 字串是一排有順序的字元,用來表示名稱、句子這類文字。這一章先學怎麼寫出字串、讀取其中一個字元,以及用模板字串把變數嵌進句子,再認識字串方法共用的原型,最後依用途學會查詢、裁切、轉換這幾類最常用的方法。
字串基礎 這一節處理字串的寫法與基本讀取,並學會模板字串。每一個字串方法都建立在這些基礎上。
建立與存取 字串可以用單引號、雙引號或反引號包起來,三種寫法得到的都是字串。包起來之後,可以用 length 知道有幾個字元,也可以用從 0 開始的索引(字元的位置編號)讀出其中一個字元。
觀念
本課程的字串預設用單引號;內容本身含有單引號時,整段改用雙引號包住。
反引號是第三種包法,主要用途是下一小節的模板字串。
length 是屬性,讀到的是字元數,後面不加括號。
索引從 0 開始,第一個字元是索引 0,最後一個字元是 length - 1。
字串不可變(immutable):方法只會交回一個新字串,原來的字串維持不變。
04-js/pages/11-js-string-basic.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 建立與存取</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const single = '台北' ; const double = "it's JS" ; const plain = `城市` ; const title = '台北城市漫遊' ; console .log (single); console .log (double); console .log (plain); console .log (title.length ); console .log (title[0 ]); console .log (title[2 ]); const upper = 'taipei' .toUpperCase (); console .log (upper); console .log ('taipei' ); </script > </body > </html >
解析
三種包法印出的都是字串本身,雙引號那一行保留了內容裡的單引號。
長度是 6,索引 0 是「台」,索引 2 是「城」。
大寫結果是新字串 TAIPEI;最後一行仍是小寫,證明方法沒有改動原來的字串。
台北 it's JS 城市 6 台 城 TAIPEI taipei
不能改掉索引上的字元 字串沒有「改掉某個字元」的寫法,title[0] = '高' 不會報錯,也不會生效(嚴格模式下才會是 TypeError)。想得到不同的文字,就用方法產生新字串,並用 const 接住。
模板字串 模板字串用反引號包住整個句子,句子裡用 ${} 嵌入變數或運算結果。前面學過字串加數字會接成文字,但要接很多段時寫法冗長;模板字串讓句子保持原樣,只在需要的位置放入值,之後組合畫面文字時會大量使用。
觀念
嵌入的語法是 $ 接一對大括號,大括號裡可以放變數,也可以放運算。
反引號內可以直接換行,換行會保留在字串裡。
$ 單獨出現時只是普通字元,後面緊接大括號才是嵌入。
要印出字面的 ${,在 $ 前面加反斜線跳脫,變成 \${。
04-js/pages/12-js-template.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 模板字串</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const title = '台北城市漫遊' ; const place = '台北' ; const days = 3 ; const price = 12800 ; const line = `${place} ・${title} ・${days} 天・NT$${price} ` ; console .log (line); console .log (`總價 NT$${price * days} ` ); const note = `第一行 第二行` ; console .log (note); console .log (`\${price} 會被當成文字` ); </script > </body > </html >
解析
第一個結果是由四個變數組成的一整句字串,不是四次輸出。NT$ 的 $ 是普通字元,緊接著的 ${price} 才是嵌入。
第二個結果在大括號裡先算出 12800 乘以 3,再嵌入句子。
第三個結果分成兩行印出,因為反引號內的換行也是字串的一部分。
第四個結果印出字面的 ${price},因為前面的反斜線讓它不再是嵌入。
台北・台北城市漫遊・3 天・NT$12800 總價 NT$38400 第一行 第二行 ${price} 會被當成文字
字串原型與方法 字串的方法不是複製在每個字串上,而是放在所有字串共用的原型。這一節先說明這個機制,之後陣列、物件看到的方法,運作方式都和這裡一樣;接著依用途學習最常用的字串方法。
原型 每一種型別都有一份共用的內建原型,可以想成該型別專用的工具書,裡面放著它能用的方法。對字串寫上點號呼叫方法時,JavaScript 會到字串原型這本工具書裡找出那支函式來執行;數字有自己的另一本,兩邊互不相通。
觀念
字串的原型是 String.prototype,數字的原型是 Number.prototype。
同型別的所有值共用原型上的同一支函式。方法名稱後面要加括號才會執行,length 這種屬性則直接讀值。
null 與 undefined 沒有原型,對它們寫點號呼叫方法會丟出 TypeError。
04-js/pages/13-js-prototype.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 原型</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const word = 'abc' ; console .log (word.toUpperCase ()); console .log (word); console .log (word.toUpperCase === String .prototype .toUpperCase ); console .log (word.length ); const amount = 42 ; console .log (amount.toFixed (0 )); console .log (amount.toFixed === Number .prototype .toFixed ); const missing = null ; console .log (String .prototype ); </script > </body > </html >
解析
第一組結果是 ABC、abc、true:轉大寫得到新字串,word 沒變,而且 word 用的函式就是字串原型上的那一支。
長度是 3,因為 length 是屬性,所以沒有括號。
數字 42 呼叫方法後印出文字 42,且用的是數字原型上的函式,證明兩種型別各有自己的原型。
對 null 呼叫方法的那一行維持註解;拿掉註解會丟出 TypeError,並中斷後面的程式。
最後一行不在下方的輸出清單裡:在 Console 展開它,可以看到字串所有可用的方法名稱。
不確定有沒有值時 null 與 undefined 沒有原型,直接呼叫方法會丟出 TypeError。值可能不存在時,可以改寫成 ?.(可選串連):左邊是這兩個值就停住,整段得到 undefined。物件那一章會正式教。
不必背完整方法清單 字串方法很多,講義只挑常用的。需要查參數與回傳值時,看 MDN 的 String 即可。
查詢與判斷 這一類方法用來問「某段文字在不在字串裡」,回傳布林值或索引,不會改動原字串。比對時區分大小寫,所以 'A' 與 'a' 視為不同。
觀念
includes:有出現這段文字就回傳 true,否則 false。最常用,用來判斷關鍵字是否存在。
startsWith:是否以這段文字開頭,回傳布林。
endsWith:是否以這段文字結尾,回傳布林。
indexOf:回傳第一次出現的索引,找不到時回傳 -1。
04-js/pages/14-js-string.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 查詢與判斷</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const title = '台北城市漫遊' ; console .log (title.includes ('城市' )); console .log (title.includes ('花蓮' )); console .log (title.startsWith ('台北' )); console .log (title.startsWith ('城市' )); console .log (title.endsWith ('漫遊' )); console .log (title.endsWith ('台北' )); console .log (title.indexOf ('城市' )); console .log (title.indexOf ('花蓮' )); console .log (title); </script > </body > </html >
解析
前六行是三個判斷方法各問一次,對得上是 true,對不上是 false。
「城市」的索引是 2,而找不到「花蓮」時得到 -1,這個值不是有效索引。
最後一行仍是原來的標題,查詢類方法都不會改寫字串。
true false true false true false 2 -1 台北城市漫遊
判斷是否存在,用 includes indexOf 找不到時是 -1,而索引 0 是第一個字元,兩者都會讓「直接拿回傳值當條件」的寫法判斷錯誤。只想知道有沒有,用回傳布林的 includes 最不容易出錯。
擷取與轉換 這一類方法從字串取出一段、清理內容、替換文字、補齊長度或拆成陣列。它們都交回新值,原來的字串不會被改掉,最後要用變數接住結果才能繼續使用。
觀念
trim:去掉前後的空白,中間的空白保留,交回新字串。處理使用者輸入時先做這一步。
slice:依索引裁出一段,格式是起點與終點,終點的字元不包含,只給起點時裁到結尾,交回新字串。
replace:把第一處對上的文字換成新文字,交回新字串。
replaceAll:把所有對上的文字都換掉,交回新字串。
split:依分隔文字拆開,交回陣列。
padStart:在左邊補字,直到長度達到指定值,交回新字串,常用來補零。
04-js/pages/15-js-pad.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 擷取與轉換</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const rawTitle = ' 台北城市漫遊 ' ; const title = rawTitle.trim (); const code = '7' ; console .log (title); console .log (rawTitle.length ); console .log (title.length ); console .log ('花蓮山海三日' .slice (0 , 2 )); console .log ('花蓮山海三日' .slice (2 )); console .log ('京都散步與散步' .replace ('散步' , '五日' )); console .log ('京都散步與散步' .replaceAll ('散步' , '五日' )); console .log ('台北・花蓮・京都' .split ('・' )); console .log (code.padStart (3 , '0' )); console .log (code); </script > </body > </html >
解析
trim 之後長度從 10 變成 6,但 rawTitle 仍是原來帶空白的字串,證明交回的是新字串。
slice(0, 2) 取到索引 1 為止,所以是「花蓮」;slice(2) 從索引 2 一路裁到結尾。
兩種替換的差別看輸出就清楚:前者只換了第一個「散步」,後者兩個都換了。
split 交回的是陣列,不是字串,所以 Console 印出的是中括號包起來的清單,前面的 (3) 是元素個數。
補零後得到 007,但 code 仍是 7;補出來的結果依然是字串,不是數字。
台北城市漫遊 10 6 花蓮 山海三日 京都五日與散步 京都五日與五日 (3) ['台北', '花蓮', '京都'] 007 7
先 trim 再比較 使用者輸入的文字常常夾帶前後空白。先 trim 再用 === 比較,才不會因為多一個空格就對不上。
padStart 補零的結果是字串 編號、時間這類固定寬度的文字用 padStart 補零;補完仍是字串,要拿去做數學運算前必須先轉成數字。
選讀:at 與大小寫轉換 專案較少用到這兩類方法,但日常讀程式碼會遇到:at 可以用負數索引從結尾往回取字元,大小寫轉換則常用在不分大小寫的比對。
觀念
at:依索引取一個字元,負數從結尾倒數,超出範圍得到 undefined,程式不會中斷。
toUpperCase 與 toLowerCase:把英文字母轉成大寫或小寫,中文字元保持原樣,交回新字串。
04-js/pages/15b-js-string-at.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > at 與大小寫轉換</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const city = 'taipei' ; console .log (city.at (0 )); console .log (city.at (-1 )); console .log (city.at (10 )); console .log (city.toUpperCase ()); console .log ('JS' .toLowerCase ()); console .log (city); </script > </body > </html >
解析
索引 -1 取到最後一個字元,這是用中括號索引做不到的;超出範圍時得到 undefined 而不是錯誤。
大小寫轉換都交回新字串,最後一行的 city 仍是原本的小寫。
t i undefined TAIPEI js taipei
運算子與流程控制 程式要先算出新的值,再依結果決定接下來做什麼,有時還要把同一件事重複很多次。運算子負責把現有的值運算成新值,條件判斷依結果決定哪一段程式要執行,迴圈則讓同一段程式重複執行。這一章依序學這三件事。
運算子 運算子是連接值的符號,運算後會得到一個新的值。後面的條件判斷與迴圈,都建立在這些運算結果上。
一覽
算術與賦值:做出新的數字,或把運算結果放回變數。
比較:比大小、比相等,結果是 true 或 false。
邏輯:組合多個條件,也能在兩個值之間挑一個交出來。
空值合併:只在值「不存在」時才補上預設值。
條件運算子:依一個條件,在兩個值之間挑一個。
算術運算子與賦值運算子 算術運算子把數字做成新數字,賦值運算子則把運算後的結果放回變數裡。
觀念
加、減、乘、除與數學相同,先乘除後加減,要先算的部分用括號包起來。
除法的結果可能是小數,不會自動變成整數。
餘數 % 取的是除不盡剩下的數,常用來判斷奇偶。
次方 ** 的左邊是底數,右邊是次方。
複合賦值 += 的意思是「取出變數現在的值,運算後再放回同一個變數」,所以左邊必須是用 let 宣告的變數;-= 同理,是減掉後放回。
04-js/pages/16-js-arith.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 算術運算子與賦值運算子</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > let total = 90 ; const people = 4 ; const each = total / people; console .log (each); console .log (7 % 3 ); console .log (2 ** 3 ); total += 10 ; console .log (total); total -= 20 ; console .log (total); console .log (each); </script > </body > </html >
解析
90 除以 4 得到 22.5,除法保留了小數。
7 除以 3 商 2 餘 1,所以餘數印出 1;2 的 3 次方是 8。
total 先加 10 變成 100,再減 20 變成 80;每一次都是改掉變數本身。
each 是在改動 total 之前算好的值,已經存進自己的變數,所以最後仍是 22.5。
小數不是精確的十進位 JavaScript 的數字是二進位浮點數,0.1 + 0.2 的結果是 0.30000000000000004,不是剛好的 0.3,拿它與 0.3 比相等(下一節學)會得到 false。金額這類要精確的數字,改用最小單位的整數計算,不要拿兩個小數直接比相等。
比較運算子與嚴格相等 比較運算子拿兩個值互相比較,結果一定是布林值 true 或 false,後面的條件判斷就是靠這個結果來決定要走哪一條路。
觀念
大於、小於、大於等於、小於等於的寫法與數學相同,用來比數字的大小。
=== 與 !== 是嚴格比較,連型別都要相同;型別不同就直接視為不相等。
== 與 != 會先自動轉型再比,'20' 與 20 會被當成一樣,容易誤判,新程式不要使用。
字串也能比大小,但比的是字元編碼的順序,不是數字的大小。
04-js/pages/17-js-compare.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 比較運算子與嚴格相等</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const age = 20 ; const ageText = '20' ; console .log (age === 20 ); console .log (age === ageText); console .log (age !== ageText); console .log (age == ageText); console .log (age >= 18 ); console .log ('10' > '9' ); console .log (Number ('10' ) > Number ('9' )); </script > </body > </html >
解析
前三行是嚴格比較:數字 20 對數字 20 是 true;數字 20 對字串 '20' 型別不同,是 false;所以 !== 是 true。
第四行的兩個等號先把字串轉成數字,結果變成 true,這就是它容易誤判的地方。
20 大於等於 18,所以第五行是 true。
字串 '10' 與 '9' 比較時,先比第一個字元,'1' 的編碼比 '9' 小,所以是 false;先用 Number 轉成數字再比,才是數字意義上的 true。
true false true true true false true
比較前先讓兩邊型別一致 表單與輸入框取得的值常是字串,要和數字比較時,先用 Number 轉成數字,再用 === 比。
選讀:Object.is Object.is 與嚴格相等幾乎相同,只多認得兩件事:NaN 與 NaN 視為相同,+0 與 -0 視為不同。日常比較仍然寫 ===。
邏輯運算子 邏輯運算子用來把多個條件組合成一個條件,這一節先看兩邊都是布林值的情況。
觀念
&&(而且):兩邊都成立,結果才成立。
||(或者):任何一邊成立,結果就成立。
!(不是):把成立與不成立反過來。
04-js/pages/18-js-logic.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 邏輯運算子</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const age = 20 ; const hasTicket = true ; const isAdult = age >= 18 ; console .log (isAdult && hasTicket); console .log (isAdult && age > 60 ); console .log (age < 10 || hasTicket); console .log (age < 10 || age > 60 ); console .log (!isAdult); </script > </body > </html >
解析
成年且有票,兩邊都成立,第一行是 true;成年但不到 60 歲,第二行是 false。
不到 10 歲不成立,但有票成立,只要一邊成立就行,第三行是 true;兩邊都不成立,第四行是 false。
最後一行把成年的 true 反過來,得到 false。
用括號標出先後 ! 最先處理,&& 比 || 先處理。條件一多,用括號寫出先看哪一組,就不必背優先順序。
真值、假值與短路求值 && 與 || 不只回傳 true 或 false,而是交出左右其中一邊的值;左邊的值足以決定結果時,右邊就不會被執行,這叫短路求值。要看懂它,得先知道哪些值在判斷時會被當成成立,哪些不會。
觀念
假值(falsy)是在條件判斷時視為不成立的值:false、數字 0、空字串、null、undefined、NaN,另有很少用到的 -0 與 BigInt 的 0n。
其餘的值都是真值(truthy),包括 true、非 0 的數字與有內容的字串(連 '0' 也是)。
&& 的左邊是假值就交出左邊,右邊不執行;左邊是真值才交出右邊。
|| 的左邊是真值就交出左邊,右邊不執行;左邊是假值才交出右邊,常用來補預設值。
Boolean() 能把任何值轉成 true 或 false,用來確認一個值算真值還是假值。
04-js/pages/18b-js-short.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 真值、假值與短路求值</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log (Boolean (false )); console .log (Boolean (0 )); console .log (Boolean ('' )); console .log (Boolean (null )); console .log (Boolean (undefined )); console .log (Boolean (NaN )); console .log (Boolean ('0' )); console .log (Boolean ('hello' )); console .log (Boolean (-1 )); const name = 'Amy' ; const empty = '' ; const count = 0 ; console .log (name && 100 ); console .log (count && 'has' ); console .log (name || '訪客' ); console .log (empty || '訪客' ); const isMember = true ; const isGuest = false ; isMember && console .log ('顯示會員價' ); isGuest && console .log ('不會印出' ); </script > </body > </html >
解析
前六行的值全是假值,印出 false;接著三行有內容或非 0,印出 true,注意字串 '0' 是真值。
左邊 name 有內容,&& 交出右邊,所以是 100;左邊 count 是 0,&& 交出左邊,所以是 0。
左邊 name 有內容,|| 直接交出它,仍是 Amy;左邊是空字串,|| 改交出右邊,得到訪客。
isMember 為 true,右邊才會執行,Console 多出一行;isGuest 為 false,右邊整個被跳過,所以沒有輸出。
false false false false false false true true true 100 0 Amy 訪客 顯示會員價
用 && 當作簡寫只是示範 範例把 && 當成「成立才執行」,只是為了看清短路。實際要決定做不做某件事,用後面條件判斷一章的 if 更清楚。
空值合併運算子 用 || 補預設值有個副作用:0 與空字串也是假值,一樣會被換掉,但它們往往是有效的值。空值合併運算子 ?? 只在左邊是 null 或 undefined(也就是真正「沒有值」)時才改用右邊。
觀念
?? 只在左邊是 null 或 undefined 時交出右邊,0 與空字串會原樣保留。
|| 會把所有假值都換成右邊。
0 與空字串是有效的值時用 ??;連 0 與空字串都要視為「沒有」時才用 ||。
04-js/pages/19-js-nullish.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 空值合併運算子</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const count = 0 ; const missing = null ; const text = '' ; console .log (count || 10 ); console .log (count ?? 10 ); console .log (missing ?? 10 ); console .log (text || '尚無備註' ); console .log ((text ?? '尚無備註' ).length ); </script > </body > </html >
解析
同樣是 0,|| 把它換成 10,?? 則保留 0。
左邊是 null,?? 沒有值可用,改用右邊的 10。
空字串用 || 會換成「尚無備註」;用 ?? 則保留空字串,印出它的長度 0。
?? 不能與 || 或 && 直接混用 在同一個式子裡,?? 與 ||、&& 要用括號隔開,寫成 a || b ?? c 會直接產生語法錯誤。
條件運算子 條件運算子依一個條件,在兩個值之間挑一個,整段式子本身就是一個值,適合「只差一個值」的簡單選擇。
觀念
寫法是 條件 ? 成立的值 : 不成立的值,條件成立取問號後面、冒號前面的值。
整段是一個值,可以直接放進 const 或當成引數。
一行裡不要再套另一層問號;分支超過兩個時,改用後面條件判斷一章的 if。
04-js/pages/19b-js-ternary.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 條件運算子</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const score = 75 ; const result = score >= 60 ? '及格' : '不及格' ; console .log (result); const isMember = false ; const price = isMember ? 80 : 100 ; console .log (price); </script > </body > </html >
解析
75 大於等於 60,條件成立,取冒號左邊的「及格」。
isMember 是 false,條件不成立,取冒號右邊的 100。
條件判斷 條件判斷讓程式依條件決定要執行哪一段。結果有兩種以上、或每種結果要做的事不只一行時,條件運算子就不夠用,改用 if 這組寫法;同一個值要對照多個固定選項時,用 switch 會更好讀。
if、else if、else if 的括號裡放條件,成立就執行緊接的大括號,然後整段結束;都不成立才執行 else。else if 可以接很多段,由上往下找第一個成立的,順序就是優先順序。
觀念
括號裡的條件不是布林時,會依真值、假值判斷。
條件後面不要加分號,否則大括號會被當成另一段永遠會執行的程式。
只做一件事時大括號可以省略,但課堂一律加上,避免之後多加一行時綁錯。
else 不是必須的,沒有它時,不成立就什麼都不做。
04-js/pages/20-js-if.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > if、else if、else</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const score = 75 ; let grade; if (score >= 90 ) { grade = 'A' ; } else if (score >= 80 ) { grade = 'B' ; } else if (score >= 60 ) { grade = 'C' ; } else { grade = 'F' ; } console .log (grade); if (score >= 60 ) { console .log ('通過' ); } </script > </body > </html >
解析
75 沒有達到 90,也沒有達到 80,前兩段都跳過;它達到 60,所以是 C,後面的 else 不會再執行。
若把分數改成 95,第一段就成立,直接得到 A,後面的條件都不看。
因為每條路會放進不同的字,grade 要用 let。
最後一個 if 沒有 else,75 達到 60 所以印出「通過」;分數不到 60 時,這段什麼都不會發生。
門檻要由嚴到寬排 若先寫 score >= 60,90 分也會在這裡成立,後面的 A 與 B 永遠走不到。條件有包含關係時,先寫最嚴格的,再依序放寬。
條件先取成名字 括號裡的比較一長,先把結果放進看得出意思的布林變數,if 只看那個名字。
const isMiddle = score >= 60 && score < 80 ;if (isMiddle) { grade = 'C' ; }
switch 與 case switch 拿一個值,依序和每個 case 比對,對上就執行該段。適合同一個值對照多個固定選項,不適合範圍判斷。
觀念
switch 括號裡放要比對的值,case 後面放比對的值,比對用嚴格相等。
每一段結尾要寫 break 離開 switch;沒寫會繼續往下執行下一段。
default 接住所有沒對上的值,放在最後。
04-js/pages/21-js-switch.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > switch 與 case</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const light = 'green' ; let action; switch (light) { case 'red' : action = '停' ; break ; case 'yellow' : action = '注意' ; break ; case 'green' : action = '行' ; break ; default : action = '號誌異常' ; } console .log (action); </script > </body > </html >
解析
light 是 green,對上第三個 case,action 設成「行」,break 讓程式離開 switch,不會再碰到 default。
若把 green 那一段的 break 拿掉,會繼續往下執行 default,action 被蓋成「號誌異常」。
case 後面不能寫範圍 case score >= 60 比對的是「switch 的值是否嚴格等於 true 或 false」,不是在判斷範圍,所以結果不是想要的。範圍交給 if,固定的字串或編號才用 switch。
switch 合併 case break 的用途是「這段做完就離開」。反過來利用,把幾個 case 疊在一起、中間不寫程式也不寫 break,對上其中任何一個,都會往下掉到同一段程式,這個現象叫 fall-through。它的效果等於「這幾個值任何一個成立」。
觀念
疊在一起的 case 共用最後一個 case 底下的程式,只有那一段需要 break。
中間空著的 case 是常見寫法,大家看得懂;但若某段 case 有寫程式卻故意不寫 break,要加一行註解說明是刻意的,否則別人會以為是漏寫。
04-js/pages/22-js-switch-group.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > switch 合併 case</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const day = '週六' ; let ticket; switch (day) { case '週六' : case '週日' : ticket = '假日票' ; break ; case '週一' : case '週二' : case '週三' : case '週四' : case '週五' : ticket = '平日票' ; break ; default : ticket = '日期有誤' ; } console .log (ticket); </script > </body > </html >
解析
day 是「週六」,對上第一個 case,但那一行沒有程式也沒有 break,於是往下掉到「週日」,再往下執行 ticket = '假日票',遇到 break 才離開。
換成「週日」也會跑到同一段;週一到週五同理,五個值共用「平日票」那一段。
同樣的判斷用 if 要寫成 day === '週六' || day === '週日',選項一多,疊 case 的寫法比較好讀。
迴圈 迴圈讓同一段程式重複執行,不必把相同的程式碼抄很多遍。迴圈每執行一圈就檢查條件,成立就再跑一圈,直到條件不成立為止;所以一定要讓條件有一天會變成 false,否則分頁會卡死,這種情況叫無限迴圈。這一節主線學 for 迴圈;選讀的有 while、break 與 continue,以及 do…while 與巢狀迴圈。
for 迴圈 for 適合已經知道要重複幾次的情況。括號裡分成三段,由分號隔開:計數器(記錄目前第幾圈的變數)從多少開始、什麼條件下繼續、每圈結束後計數器怎麼改。大括號裡是每一圈要做的事。
觀念
計數器用 let 宣告,因為每一圈都要換成下一個數字。
中間的條件是「還可以進下一圈」,不是「最後一圈的號碼」。
第三段的 n += 1 若忘了寫,條件永遠成立,迴圈就停不下來。
計數器宣告在括號裡,迴圈結束後,外面就不能再使用這個名字。
04-js/pages/23-js-for.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > for 迴圈</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > let total = 0 ; for (let n = 1 ; n <= 5 ; n += 1 ) { total += n; console .log (n, total); } </script > </body > </html >
解析
n 從 1 開始,只要還小於等於 5 就執行大括號,結束後加 1,所以一共執行 5 圈。
每一圈把 n 加進 total,印出目前的 n 與累計的合計:1、3、6、10、15。
若條件改成小於 5,最後一圈會被排除,只會印到 4。
常見簡寫 n++ n++ 等於 n += 1,很多程式碼會這樣寫。本課程為了讓寫法一致,統一寫 += 1。
走訪陣列改用 for…of for 用來數已知的次數。要讀陣列裡的每一個值,到陣列那一章會學 for…of。for…in 走的是鍵(屬性名稱),陣列的鍵是 '0'、'1' 這樣的字串,不要用它來取陣列的值;物件的鍵留到物件那一章。
選讀:while、break 與 continue while 只寫繼續的條件,計數器要自己在大括號裡改。不知道會重複幾圈、只知道做到某個狀況為止,就用 while。另外兩個關鍵字可以在迴圈裡控制流程。
觀念
條件用到的變數要在迴圈外先準備好,並在迴圈裡往結束的方向改,否則不會停。
continue 跳過這一圈剩下的程式,直接進下一圈。
break 立刻結束整個迴圈。
兩者都只影響包住它們的那一層迴圈。
04-js/pages/24-js-while.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > while、break 與 continue</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > let count = 3 ; while (count > 0 ) { console .log (count); count -= 1 ; } console .log ('結束' ); for (let n = 1 ; n <= 5 ; n += 1 ) { if (n === 2 ) { continue ; } if (n === 4 ) { break ; } console .log (n); } </script > </body > </html >
解析
while 印出 3、2、1,減到 0 時條件不成立,離開迴圈後印出「結束」。
下面的 for 在 n 是 2 時遇到 continue,這一圈剩下的程式被跳過,所以沒有印 2。
n 是 4 時遇到 break,整個迴圈結束,4 與 5 都不會印,留下的是 1 與 3。
break 不是錯誤 它是你規定的提早結束。例如找到第一筆符合的就可以停,不必把後面的圈數也跑完。
選讀:do…while do…while 把條件放在大括號後面,先執行一圈才檢查。條件成立就再跑一圈,不成立就離開。
觀念
條件寫在大括號後面的括號裡,整段以分號結束。
進入前不檢查,所以至少執行一次。
計數器同樣要在迴圈裡往結束的方向改。
04-js/pages/25-js-do.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > do...while</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > let count = 0 ; console .log ('while 先檢查' ); while (count > 0 ) { count += 1 ; console .log (count); } let tries = 0 ; console .log ('do 先執行' ); do { tries += 1 ; console .log (tries); } while (tries < 1 ); </script > </body > </html >
解析
「while 先檢查」印出後,count 是 0,大於 0 不成立,大括號一次都沒進去,所以沒有數字。
「do 先執行」印出後,先把 tries 加成 1 並印出,然後才檢查;1 不小於 1,於是離開。
兩段在第一次檢查時條件都不成立,差別只在檢查的時機:while 先檢查,執行 0 次;do…while 後檢查,執行 1 次。
選讀:巢狀迴圈 一個迴圈的大括號裡可以再放另一個迴圈。外圈每走一步,內圈就從自己的起點跑完一整輪,總次數是兩層次數相乘。
觀念
外圈的計數器要等內圈整輪結束,才會加 1。
內圈每一輪都從頭開始,不會接著上一輪最後的數字。
兩層要用不同的名字,例如外層 row、內層 col,內層才不會改到外層的數字。
04-js/pages/26-js-nested.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 巢狀迴圈</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > for (let row = 1 ; row <= 2 ; row += 1 ) { for (let col = 1 ; col <= 3 ; col += 1 ) { console .log (row + '×' + col + '=' + row * col); } } </script > </body > </html >
解析
row 先停在 1,內圈的 col 從 1 走到 3,印出三行;內圈結束後,外圈才變成 2,內圈再從 1 重新走到 3。
外圈 2 次、每次內圈 3 次,相乘是 6,所以一共六行。
1×1=1 1×2=2 1×3=3 2×1=2 2×2=4 2×3=6
巢狀不要超過兩層 兩層已經足夠看清誰先跑完。再多一層時,先把最裡面的迴圈收成函式,用名字呼叫它,而不是在迴圈裡再套一層。
函式 函式是把一段程式包起來並取一個名字,需要時呼叫這個名字,裡面的程式才會執行,也就能重複使用而不必重寫。這一章先學怎麼宣告與呼叫,再學把值交給函式、從函式拿回結果、不合理的輸入先擋下來,以及參數沒傳時怎麼補預設值,最後學不定數量的引數。接著把函式本身當成一個值:放進變數、寫成箭頭函式,或交給另一支函式使用。選讀的部分是函式怎麼記住外面的變數。
函式宣告與呼叫 這一節從最基本的寫法開始:先宣告函式並呼叫它,再學參數與引數如何把值交進去、return 如何把結果交出來。之後處理輸入不合理時的提早離開、參數沒傳時的預設值,以及一次收下不定數量的引數。
宣告與呼叫 函式用 function 關鍵字宣告,後面接函式名稱,大括號裡放這支函式要做的事。這一小節的小括號先留空。
觀念
宣告不會執行。檔案讀到函式宣告時,只是把大括號裡的程式記起來。
呼叫才會執行:寫出函式名稱,再加一對小括號。
同一支函式可以重複呼叫,每呼叫一次就再執行一次。
04-js/pages/27-js-function.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 宣告與呼叫</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function sayHello ( ) { console .log ('Hello' ); } sayHello (); sayHello (); sayHello (); </script > </body > </html >
解析
檔案先讀到 sayHello 的宣告,這時大括號裡的程式還沒跑,所以不會印出 Hello。
後面三行才是呼叫,每一行執行一次,Console 因此出現三行 Hello。
參數與引數 函式常常需要外面交給它資料才能工作。參數是宣告時小括號裡用來接值的名稱,引數是呼叫時實際交進去的值,兩者依照位置一一對上。
下圖以 add(3, 5) 為例,引數依序交給宣告裡的參數。
graph LR
subgraph call["呼叫:add(3, 5)"]
A1["引數 3"]
A2["引數 5"]
end
subgraph decl["宣告:function add(a, b)"]
P1["參數 a"]
P2["參數 b"]
end
A1 -- "第 1 個位置" --> P1
A2 -- "第 2 個位置" --> P2
觀念
引數與參數只看位置,不看名字:第一個引數給第一個參數,第二個給第二個。
少傳的參數是 undefined,不要拿它去做運算,結果不會是預期的數字。
多傳的引數沒有參數可接,函式裡看不到,等於被忽略。
參數只活在函式裡面,這是函式作用域,和前面學的區塊作用域相似:函式外面找不到這個名字。
傳入數字、字串、布林這類基本型別時,函式拿到的是複本,在函式裡改參數,不會改到外面的變數。
04-js/pages/28-js-params.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 參數與引數</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function printPair (left, right ) { console .log (left); console .log (right); } printPair (10 , 20 ); printPair (10 ); printPair (10 , 20 , 30 ); function bump (value ) { value = value + 1 ; console .log (value); } let value = 5 ; bump (value); console .log (value); </script > </body > </html >
解析
第一次呼叫兩個引數都有,依序印出 10 與 20。
第二次只傳 10,right 沒有對上引數,所以是 undefined。第三次多傳的 30 沒有參數可接,畫面仍只有 10 與 20。
bump 的參數與外面的 value 同名,但是兩個不同的變數。函式裡把參數改成 6 並印出,函式結束後外面的 value 仍是 5,因為傳進去的是複本。
最後一行若拿掉註解會出現 ReferenceError:left 只活在 printPair 裡,外面找不到。
物件改的是同一份 基本型別傳進函式後,改參數不影響外面。物件在後面的章節才介紹,先記住一件事:物件傳進函式後,若改的是它的欄位,外面看得到,因為兩邊指的是同一份資料。
return 與回傳值 函式不只能做事,還能把結果交回呼叫的地方,這就是 return 的工作。return 同時會立刻結束函式。
觀念
回傳值就是這次呼叫的結果,可以放進變數、嵌進模板字串,或當作另一個函式的引數。
沒有寫 return,或寫了 return; 但右邊沒有值,呼叫的結果都是 undefined。
console.log 只是把值印給人看;後面的程式還要用這個結果,就要 return。
return 會立刻離開函式,函式裡寫在它後面的程式不會執行,下一小節的提早 return 就靠這一點。
04-js/pages/29-js-return.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > return 與回傳值</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function getTotal (price, count ) { return price * count; } function printTotal (price, count ) { console .log (price * count); } const total = getTotal (80 , 3 ); console .log (total); const line = `合計 ${getTotal(80 , 2 )} ` ; console .log (line); console .log (getTotal (getTotal (10 , 2 ), 4 )); console .log (printTotal (80 , 3 )); function blank ( ) { return ; } console .log (blank ()); </script > </body > </html >
解析
getTotal 把 240 交回來放進 total,所以第一行是 240。第二行把 160 嵌進模板字串,第三行把回傳值當成引數:裡面先得到 20,外面再算 20 乘 4,得到 80。getTotal 裡沒有任何 log,這三行都是呼叫端印出來的。
printTotal 自己先印出 240,但它沒有 return,外層的 console.log 印出這次呼叫的結果,所以緊接著是 undefined。
blank 寫了 return 但沒有值,結果同樣是 undefined。
印出來不等於交回來 函式裡有 console.log,只表示 Console 多了一行。把這次呼叫放進變數或模板字串,拿到的仍是 undefined,除非函式有 return。
240 合計 160 80 240 undefined undefined
提早 return 函式收到的參數不一定合理,例如人數傳入 0,除法會算出 Infinity 或 NaN,錯誤的結果還會一路往後傳。提早 return(guard clause)的做法,是在函式一開頭先檢查無效輸入,不合法就立刻 return,後面的主要計算只需要處理正常情況。
觀念
檢查放在函式最上方,一條規則寫一個 if。
有回傳值的函式,不合法時回傳 null,讓呼叫的人知道這次沒有結果,而不是拿到一個看似正常的錯誤數字。
只負責做事的函式,不合法時直接寫 return;,後面的動作就不會執行。
每個 if 都在 return 後結束,不需要 else,通過所有檢查後剩下的就是正常計算。
04-js/pages/30-js-guard.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 提早 return</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function averageRaw (total, count ) { return total / count; } console .log (averageRaw (240 , 3 )); console .log (averageRaw (240 , 0 )); console .log (averageRaw (0 , 0 )); function average (total, count ) { if (count <= 0 ) { console .log ('人數必須大於 0' ); return null ; } if (total < 0 ) { console .log ('分數總和不能是負數' ); return null ; } return total / count; } console .log (average (240 , 3 )); console .log (average (240 , 0 )); console .log (average (-10 , 2 )); function printScore (name, score ) { if (score < 0 || score > 100 ) { console .log (`${name} 的分數無效` ); return ; } console .log (`${name} 考了 ${score} 分` ); } printScore ('Amy' , 88 ); printScore ('Ben' , 120 ); </script > </body > </html >
解析
averageRaw 沒有檢查,人數是 0 時得到 Infinity 或 NaN,這些值傳到後面只會讓錯誤擴大。
average 的第一個 if 擋下人數 0,印出原因並回傳 null,下面的除法完全沒執行。average(-10, 2) 的人數正常,通過第一個 if,卻在第二個 if 因總和是負數被擋下,同樣印出原因並回傳 null。
兩關都通過的 average(240, 3) 才走到最後的除法,得到 80。
printScore 沒有值要交回,檢查不通過時只寫 return;,Ben 印出無效後就結束,不會再印分數。
80 Infinity NaN 80 人數必須大於 0 null 分數總和不能是負數 null Amy 考了 88 分 Ben 的分數無效
預設參數 呼叫時若沒有傳引數,參數就是 undefined。在參數後面用 = 寫預設值,可以在沒傳時自動補上一個合理的值。
觀念
有預設值的參數習慣放在參數列表的尾端,前面的參數仍要照位置傳。
只有引數是 undefined 時才套用預設值,沒傳和明確傳入 undefined 結果相同。
0、空字串、null 都是明確傳入的值,不會被取代。
舊寫法 count = count || 1 會把 0 一起換掉。人數、次數、分數都可能是 0,所以改用預設參數,或前面學過的空值合併。
04-js/pages/31-js-default-param.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 預設參數</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function showCount (count = 1 ) { console .log (count); } showCount (); showCount (3 ); showCount (0 ); showCount (undefined ); showCount (null ); function countByOr (count ) { count = count || 1 ; console .log (count); } countByOr (0 ); function countByNullish (count ) { console .log (count ?? 1 ); } countByNullish (0 ); countByNullish (null ); </script > </body > </html >
解析
showCount 沒傳引數時印出預設的 1,傳 3 印出 3;傳 0 時 0 被留下,因為 0 不是 undefined。
明確傳入 undefined 和沒傳一樣,套用 1;傳入 null 則不套用,第五行是 null。
countByOr 用 || 補值,0 被當成缺值換成 1,這就是舊寫法的問題。
countByNullish 用空值合併,只有 null 或 undefined 才改用右邊,所以 0 留下,null 才變成 1。
其餘參數 有時候無法事先知道會傳幾個引數,例如加總任意多個數字。其餘參數(rest parameters)在最後一個參數前面加上 ...,把該位置之後的引數全部收集成一個陣列。
觀念
其餘參數只能放在參數列表的最後一個,前面的普通參數仍照位置先對上。
收集到的是真正的陣列,沒有傳任何引數時是空陣列。陣列下一章才詳細介紹,這裡只用兩件事:numbers.length 是個數,numbers[0] 用索引讀第一筆。
04-js/pages/32-js-rest.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 其餘參數</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function sumAll (...numbers ) { let total = 0 ; for (let i = 0 ; i < numbers.length ; i += 1 ) { total += numbers[i]; } return total; } console .log (sumAll (10 , 20 , 30 )); console .log (sumAll (5 )); console .log (sumAll ()); </script > </body > </html >
解析
第一次呼叫收集到三個數字,for 迴圈依索引 0、1、2 讀出 10、20、30,加總得到 60。
第二次只有一筆,迴圈跑一次,結果是 5。
第三次沒有引數,長度是 0,迴圈一次都不進,total 維持 0。同一支函式收得下不同數量的引數。
函式表達式 函式本身也是一個值,可以放進變數、當成引數交給別的函式。這一節先學把函式存進變數的函式表達式,再學它的簡寫箭頭函式,最後學把函式交給另一支函式使用。後面的陣列方法與 React 都大量依賴這幾種寫法。
匿名函式 函式表達式把沒有寫名字的函式賦值給變數,再透過變數呼叫,這種沒有名字的函式叫匿名函式。它與宣告式的差別在於何時可以呼叫,下面用提升(hoisting)來說明。
觀念
匿名函式用變數呼叫,變數用 const 保存,避免後來被改成別的值。
函式宣告會被提升(hoisting)到所在作用域的頂端,所以呼叫可以寫在宣告的上面。
函式表達式是一則賦值,賦值那一行還沒執行,變數還沒有指向函式,提早呼叫會出錯。
04-js/pages/33-js-anonymous.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 匿名函式</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log (sumDeclared (2 , 3 )); function sumDeclared (a, b ) { return a + b; } const add = function (a, b ) { return a + b; }; console .log (add (2 , 3 )); </script > </body > </html >
解析
第一行在宣告之前呼叫 sumDeclared 仍印出 5,因為函式宣告已被提升。
add 是函式表達式,要等 const 那一行跑完才指向函式。註解那一行若拿掉,會在賦值前呼叫 add,出現 ReferenceError,後面的程式也不會執行。
賦值之後呼叫 add 印出 5。兩次都是 2 加 3,差別只在名字何時可用。
箭頭函式 箭頭函式是函式表達式的精簡寫法,用 => 取代 function 關鍵字,只做一件小事的函式可以寫成一行。簡寫有固定規則,寫錯時程式不一定報錯,卻會得到意料之外的結果,所以下面逐一說明。
觀念
從匿名函式改成箭頭函式:拿掉 function,在參數的小括號與大括號之間加上 =>。
大括號裡只有一行 return 時,可以連大括號與 return 一起省略,箭頭右邊運算式的結果就是回傳值,稱為隱式回傳。
只有一個參數時語法上可省略小括號,但 Prettier 預設會補回來,課堂一律保留,寫成 (n) => n * 2。
沒有參數時小括號不能省略,要寫成 () =>;兩個以上的參數也一定要有小括號。
一旦寫了大括號,它就是一般的函式區塊,要交回值必須自己寫 return,否則結果是 undefined。
隱式回傳物件時,物件的大括號會被誤認成函式區塊,外面要再包一層小括號:() => ({ ... })。物件在後面的章節才介紹,這裡先記住括號的位置。
箭頭函式不只是寫法不同 箭頭函式沒有自己的 this 與 arguments,也不能用 new 呼叫。this 要到物件那一章才學,屆時再回頭對照。
04-js/pages/34-js-arrow.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 箭頭函式</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const double1 = function (n ) { return n * 2 ; }; const double2 = (n ) => { return n * 2 ; }; const double3 = (n ) => n * 2 ; const sayHi = ( ) => 'Hi' ; const add = (a, b ) => a + b; const forgotten = (n ) => { n * 2 ; }; const pair = (left, right ) => ({ left : left, right : right }); console .log (double1 (4 )); console .log (double2 (4 )); console .log (double3 (4 )); console .log (sayHi ()); console .log (add (2 , 3 )); console .log (forgotten (4 )); console .log (pair (2 , 3 )); </script > </body > </html >
解析
double1、double2、double3 是同一支函式的三種寫法,從完整的函式表達式一步步省略,三行都印出 8。
sayHi 與 add 示範小括號:沒有參數時保留空括號,得到 Hi;兩個參數用括號包起來,右邊的加法直接回傳 5。
forgotten 寫了大括號卻沒有 return,乘法雖然執行了,結果沒有交出來,所以印出 undefined。
pair 把物件包在小括號裡才會當成回傳值,少了那層括號,大括號會被當成函式區塊,拿不到物件。
8 8 8 Hi 5 undefined {left: 2, right: 3}
函式當作參數 函式是值,所以可以像數字或字串一樣當成引數交給另一支函式,由接收的那一方在適當的時機呼叫它。被交進去的函式稱為回呼函式(callback)。這個模式讓同一支函式的流程固定,而變動的部分由外面決定,陣列方法與事件處理都是這樣用的。
觀念
把函式當引數時,只寫函式名稱,不加小括號。加了小括號就變成「現在就呼叫」,交出去的是它的回傳值。
接收的函式用參數名稱加小括號來呼叫它,例如 operation(a, b)。
交進去的函式可以是已宣告的函式名稱、匿名函式或箭頭函式,三種寫法效果相同。
04-js/pages/35-js-callback.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 函式當作參數</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function calc (a, b, operation ) { const result = operation (a, b); console .log (result); } function add (a, b ) { return a + b; } calc (10 , 4 , add); calc (10 , 4 , function (a, b ) { return a * b; }); calc (10 , 4 , (a, b ) => a - b); calc (10 , 4 , (a, b ) => a / b); </script > </body > </html >
解析
calc 本身只負責呼叫 operation 並印出結果,要做哪種運算由第三個引數決定,同一支 calc 因此得到不同結果。
第一次交進宣告好的 add,印出 14;第二次交匿名函式做乘法,印出 40;第三次、第四次交箭頭函式做減法與除法,印出 6 與 2.5。
最後一行若拿掉註解,add() 先被呼叫,沒有引數所以得到 NaN,calc 拿到的不是函式,operation(a, b) 會出現 TypeError。
選讀:閉包 閉包是函式「記住」自己建立當下外層變數的現象。外層函式執行完後,內層函式仍讀得到、也改得到那些變數,前提是內層函式被 return 或當作參數交到外層之外。這種由程式碼寫在哪裡,決定能讀到哪些變數的規則,稱為詞法作用域(lexical scope)。
觀念
內層函式使用了外層的變數,又被交到外層之外,這組綁定就叫閉包。記住的是變數本身,不是當時數字的複本。
外層函式每呼叫一次,就做出一份新的變數;兩次呼叫得到的內層函式,各記各的,互不影響。
外面碰不到那個變數,只能透過交出來的函式讀寫,這叫封裝,用來把狀態藏在函式裡。
下圖對照下方 36-js-closure.html 裡的 script。const first = createCounter() 執行一次函式,裡面的 let count = 0 與兩支函式一起被做出來,再由 return 的物件交給 first。second 是另一次呼叫,拿到的是另一份 count。
graph LR
subgraph run1["const first = createCounter()"]
C1["let count = 0"]
I1["function increment()<br>count += 1"] --> C1
G1["function getCount()<br>return count"] --> C1
R1["return { increment, getCount }"]
R1 --> I1
R1 --> G1
end
subgraph run2["const second = createCounter()"]
C2["let count = 0"]
I2["function increment()"] --> C2
G2["function getCount()"] --> C2
R2["return { increment, getCount }"]
R2 --> I2
R2 --> G2
end
F["first.increment()<br>first.getCount()"] --> R1
S["second.getCount()"] --> R2
X["first.count"] -. "undefined" .-x C1
04-js/pages/36-js-closure.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 選讀:閉包</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function createCounter ( ) { let count = 0 ; function increment ( ) { count += 1 ; return count; } function getCount ( ) { return count; } return { increment : increment, getCount : getCount, }; } const first = createCounter (); console .log (first.increment ()); console .log (first.increment ()); console .log (first.getCount ()); console .log (first.count ); const second = createCounter (); console .log (second.getCount ()); console .log (first.getCount ()); </script > </body > </html >
解析
createCounter 執行時做出 count,並把 increment、getCount 放進回傳的物件。
這次呼叫結束後,外面沒有 count 這個名字,但 first 仍握著那兩支函式,所以 count 還在。
前兩次 increment 把同一份 count 從 0 改成 1、再改成 2。getCount 只讀不改,第三行仍是 2。
first.count 是 undefined,因為 count 不是物件上的欄位,外面碰不到,只能透過交出來的函式操作,這就是封裝。
second 是另一次 createCounter,有自己的 count,所以 getCount 是 0。最後再讀 first,仍是 2,兩份狀態沒有混在一起。
物件的寫法在後面的章節才展開,這裡用它把兩支函式一起交回。
陣列 陣列是一組有順序的值,用從 0 開始的索引取出每一格,length 是目前的格數。這一章先學怎麼建立陣列、增減格子,並看清楚 const 為什麼擋不住格子內容的改變;接著依用途學會搜尋、轉換、篩選、排序等陣列方法,並分清楚哪些會改到原陣列、哪些交回新陣列。最後的選讀用 Set 去掉重複的值。
陣列基礎 這一節處理陣列的寫法、增減格子的方法,以及變數與陣列之間的關係,重點是「哪些動作會直接改到原來那一份」,後面的陣列方法都要先分清楚這一點。
建立與存取 陣列用中括號把值依序寫出來,再用索引取出某一格。索引從 0 開始,所以長度是 3 的陣列,合法索引是 0、1、2;讀到不存在的索引會得到 undefined。
觀念
最後一格的索引是長度減 1,也可以用 at 傳入負數從結尾倒數:at(-1) 是最後一格,at(-2) 是倒數第二格。
陣列在 typeof 裡也是 object,分不出和物件的差別,要判斷是不是陣列,改用 Array.isArray。
for...of 依序取出每一格的值;只有需要索引時,才用 for 搭配計數器,條件寫成小於 length。
04-js/pages/37-js-array.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 建立、索引與 length</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const places = ['台北' , '花蓮' , '京都' ]; console .log (places.length ); console .log (places[0 ]); console .log (places[5 ]); console .log (places.at (-1 )); console .log (Array .isArray (places)); console .log (typeof places); for (const place of places) { console .log (place); } </script > </body > </html >
解析
長度是 3;索引 0 是第一個字串,索引 5 沒有這一格,所以是 undefined;at(-1) 是最後一個字串。
Array.isArray 是 true,但 typeof 仍印出 object,所以不能靠 typeof 判斷陣列。
for...of 依序印出三個字串,變數 place 每一圈拿到的是格子裡的值,不是索引。
3 台北 undefined 京都 true object 台北 花蓮 京都
本篇的輸出區塊是簡化版:Chrome Console 會在陣列前多印長度,例如 (3) ['台北', '花蓮', '京都'],物件則印成 {id: 1, days: 3} 的樣子。
不要用 for…in 走陣列 for...in 走的是鍵。陣列的鍵是 ‘0’、’1’ 這種字串,還可能遇到原型上額外的鍵。要讀每一格的值,用 for...of;走物件的鍵留到下一章。
新增與刪除元素 這一組方法用來在陣列的頭尾增減格子,或在中間插入、刪除。它們都直接改動原來那個陣列,沒有另外交回一份新的。要特別留意回傳值:它們回傳的不是改完的陣列。
一覽
push:加在最後,回傳新的長度。
pop:拿掉最後一格,回傳被拿掉的值。
unshift:加在最前面,回傳新的長度。
shift:拿掉第一格,回傳被拿掉的值。
splice:從指定索引刪掉若干格,也可以在同一位置插入新值,回傳被刪掉的那些值(包成新陣列)。
04-js/pages/38-js-mutate.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 新增與刪除元素</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const places = ['台北' , '花蓮' , '京都' ]; console .log (places.push ('台南' )); console .log (places.pop ()); console .log (places.unshift ('高雄' )); console .log (places.shift ()); console .log (places.splice (1 , 1 , '台東' )); console .log (places); </script > </body > </html >
解析
push 回傳 4,表示加上台南之後有四格;接著 pop 把台南拿回來,陣列回到三格。
unshift 又把長度變回 4,shift 把高雄拿掉,陣列再次回到三個地名。
splice(1, 1, '台東') 從索引 1 刪掉 1 格,被刪掉的是花蓮,所以回傳只有花蓮的陣列;原陣列的索引 1 則換成台東。
4 台南 4 高雄 ['花蓮'] ['台北', '台東', '京都']
回傳值不是陣列本身 push 回傳的是長度,是數字。若寫成 places.push('台南').map(...),數字上面沒有 map,程式會中斷。要接著轉換,先讓 push 改完,再對 places 呼叫方法。
const 與參考 變數裡存的不是陣列的內容,而是指向這個陣列的參考,像一張寫著陣列放在哪裡的字條。
觀念
const 鎖住的是「名字指向哪一個陣列」,不是陣列裡的內容。
改 fruits[0],或呼叫會動到格子的方法,動的是同一個陣列,因此合法。
寫 fruits = [] 是要讓名字改指到另一個陣列,會丟出 TypeError,後面的程式停在這一行。
函式收到陣列參數時,拿到的是同一個參考,函式裡改格子,外面看得到。物件也是同樣的規則,下一章會再看到。
04-js/pages/39-js-const-ref.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > const 與參考</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const fruits = ['apple' , 'banana' , 'cherry' ]; fruits[0 ] = 'kiwi' ; fruits.push ('mango' ); console .log (fruits); function replaceFirst (list ) { list[0 ] = 'pear' ; } replaceFirst (fruits); console .log (fruits[0 ]); console .log (fruits); </script > </body > </html >
解析
索引 0 改成 kiwi、再 push 一格 mango,印出的仍是原來那個陣列,只是格子變了,const 沒有報錯。
replaceFirst 收到同一個參考,把第 0 格改成 pear,函式外面再讀,已經是 pear。
最後一行若拿掉註解,會在重新賦值那一行丟出 TypeError,因為 const 不允許把 fruits 改指到新的空陣列。
['kiwi', 'banana', 'cherry', 'mango'] pear ['pear', 'banana', 'cherry', 'mango']
真的不准改,以及函式裡的修改 Object.freeze 可以凍結第一層,索引不能再改,也不能再加格子;包在裡面的陣列或物件不會一起凍結。非模組的 script 沒有自動的嚴格模式,凍結後再改格子會安靜失敗,嚴格模式才會丟出 TypeError。
若要交給函式一份互不影響的資料,要先複製,寫法在展開運算子 。
陣列原型與方法 陣列的方法放在 Array.prototype,每個陣列共用這一份;字串章的原型 已經說明,自己身上沒有的函式,就到原型上找。這一節依搜尋、轉換、篩選、排序與串接的用途來學,使用前先分清楚每個方法會不會改到原陣列:改原陣列的,要小心別的地方也在用這一份;交回新結果的,要記得用變數接住。
一覽
會改原陣列:前一節的 push、pop、unshift、shift、splice,加上 sort 與 reverse,後兩者回傳的就是原陣列自己。
不改原陣列、交回新結果:其餘的方法,各小節的一覽會逐一說明交回布林、索引、值、新陣列、字串或累計值。唯一的例外是 forEach,它不交回東西,回傳值固定是 undefined。
toSorted、toReversed、toSpliced、with 是 sort、reverse、splice 與「用索引改一格」的不改原陣列版本,交回新陣列。
不要往原型加方法 自己往 Array.prototype 加方法,每一個陣列都會看到它,容易和之後內建的新方法撞名,也會影響別人的程式,所以不要這麼做。
各方法的參數與回傳值,查 MDN 的 Array 最準。
搜尋與判斷 這一類用來問值在不在,或有沒有格子符合條件,原陣列不會被改。
一覽
includes:問值在不在,回傳布林。
indexOf:回傳第一次出現的索引,沒有就是 -1。
find:回傳第一個符合條件的值,沒有就是 undefined。
findIndex:回傳第一個符合條件的索引,沒有就是 -1。
some:問有沒有任何一格符合條件,回傳布林。
every:問是不是每一格都符合條件,回傳布林。
觀念
傳給方法的函式稱為回呼(callback):方法替每一格呼叫它一次,把格子的值當參數交進去,由回傳的 true 或 false 決定符不符合。
找單一個值用 includes;找「符合某條件」的格子,用需要回呼的 find 系列、some 與 every。
includes 能找到 NaN(不是數字的特殊值),indexOf 找不到,所以只想知道「有沒有」時優先用 includes。
04-js/pages/40-js-search.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 搜尋與判斷</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const scores = [88 , 92 , 76 , 92 ]; console .log (scores.includes (92 )); console .log (scores.indexOf (92 )); console .log (scores.find ((score ) => score < 80 )); console .log (scores.findIndex ((score ) => score < 80 )); console .log (scores.some ((score ) => score >= 90 )); console .log (scores.every ((score ) => score >= 60 )); console .log (scores); const mixed = [1 , NaN ]; console .log (mixed.includes (NaN )); console .log (mixed.indexOf (NaN )); </script > </body > </html >
解析
92 第一次出現在索引 1,後面另一個 92 不會被回傳;find 與 findIndex 同樣只取第一個符合的格子。
some 與 every 都回答是或否,原陣列的順序和內容都沒有變。
最後兩行顯示 includes 能找到 NaN,indexOf 卻得到 -1。
true 1 76 2 true true [88, 92, 76, 92] true -1
空陣列的 every 沒有任何一格可以違反條件時,every 的定義是 true,所以空陣列呼叫 every 也會得到 true。要表示「至少有一格」,用 some,或先看 length。
逐一處理與轉換 這一類用來走訪每一格:forEach 負責「做事」,map 負責「換成新值」。兩者都不會刪格子,也不會改原陣列。
一覽
forEach:每一格各執行一次回呼,回傳值固定是 undefined。
map:每一格交給回呼,用回傳值組成一個一樣長的新陣列。
觀念
回呼函式依序收到三個參數:值、索引、整個陣列。
forEach 沒有回傳值,不能放在串接中間,也不能用來產生新陣列;要新陣列,用 map。
map 的回呼若寫了大括號卻忘了 return,新陣列會滿是 undefined。
04-js/pages/41-js-map.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > forEach 與 map</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const prices = [12800 , 15900 , 42800 ]; prices.forEach ((price, index, array ) => { console .log (index, price, array.length ); }); const doubled = prices.map ((price ) => price * 2 ); console .log (doubled); console .log (prices); console .log (prices.forEach ((price ) => price)); </script > </body > </html >
解析
forEach 印出三行,索引從 0 到 2,長度都是 3,每一圈收到的價格都是原來的數字。
map 交回兩倍的新陣列,prices 三個數字都還在。
最後一行是 undefined,那是 forEach 的回傳值。
0 12800 3 1 15900 3 2 42800 3 [25600, 31800, 85600] [12800, 15900, 42800] undefined
回傳值要接住 prices.map(...) 若沒有放進 const,新陣列會被丟掉,原陣列也不會變成兩倍。
篩選與累計 這一類把陣列收成另一份結果,且不改原陣列:filter 留下符合的格子,reduce 把整個陣列收成一個值。
一覽
filter:留下回呼回傳真值的格子,交回較短或一樣長的新陣列。
reduce:每一格依序交給回呼,把回呼回傳的累計值帶到下一格,最後交回一個值。
觀念
filter 的回呼要回傳布林,找不到任何符合的格子時,交回空陣列。
04-js/pages/42-js-filter.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > filter</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const scores = [88 , 92 , 76 , 95 , 61 ]; const passed = scores.filter ((score ) => score >= 80 ); console .log (passed); console .log (scores); console .log (scores.length ); </script > </body > </html >
解析
大於等於 80 的是 88、92、95,組成新陣列。
原陣列仍是五格,filter 交回的是另一份陣列。
[88, 92, 95] [88, 92, 76, 95, 61] 5
觀念:reduce
像滾雪球:回呼的第一個參數是目前的累計,第二個參數是這一格,必須 return 下一次的累計。
第二個參數是累計的起點;省略時會拿第一格當起點、從第二格開始,為了結果的型別明確,建議一律寫出起點。
最常見的用法是加總:回呼每次回傳「目前的累計加上這一格」。
04-js/pages/43-js-reduce.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > reduce</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const prices = [12800 , 15900 , 42800 ]; const total = prices.reduce ((sum, price ) => { return sum + price; }, 0 ); console .log (total); console .log ([].reduce ((sum, price ) => sum + price, 0 )); console .log (prices.reduce ((sum, price ) => sum + price, '' )); </script > </body > </html >
解析
累計從 0 開始,依序加上三個價格,得到 71500。
有起點時,空陣列得到起點 0;若沒給起點,空陣列呼叫 reduce 會丟出 TypeError。
起點是空字串時,每一次相加都是字串相加,三個數字被接成一長串文字,所以起點的種類就是結果的種類。
排序與組合 這一類處理陣列的順序與拼接,其中 sort 與 reverse 會改到原陣列,要特別留意。
一覽
slice:依索引裁出一段(終點不含),不給參數就複製整份,交回新陣列。
concat:把更多值或陣列接在後面,交回新陣列。
join:用分隔字串把每一格接成一個字串。
sort:排序並改動原陣列,預設把格子轉成字串再比。
reverse:倒序並改動原陣列。
toSorted、toReversed:和 sort、reverse 結果相同,但原陣列不變,交回新陣列。
先看三個不改原陣列、都交回新結果的方法:slice、concat 與 join。
04-js/pages/44b-js-combine.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > slice、concat 與 join</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const places = ['台北' , '花蓮' , '京都' ]; console .log (places.slice (1 )); console .log (places.slice (0 , 2 )); console .log (places.concat (['台南' ])); console .log (places.join ('、' )); console .log (places); </script > </body > </html >
解析
slice(1) 從索引 1 裁到結尾;slice(0, 2) 的終點索引 2 不包含,所以只有前兩格。
concat 交回有四個地名的新陣列,join 交回一個字串,不是陣列。
最後一行仍是原本的三個地名,這三個方法都沒有改到它。
['花蓮', '京都'] ['台北', '花蓮'] ['台北', '花蓮', '京都', '台南'] 台北、花蓮、京都 ['台北', '花蓮', '京都']
接著看排序。sort 不給比較函式時,會先把每一格轉成字串再比,所以數字要自己提供比較函式(傳給 sort 的回呼,每次比兩格 a 與 b):回傳負數表示 a 排前面,正數表示 a 排後面,0 表示不動。
下面先用規則相同、但不改原陣列的 toSorted 看比較規則,再看 sort 本身會直接改動原陣列。
04-js/pages/44-js-sort.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 排序</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const scores = [20 , 3 , 100 ]; console .log (scores.toSorted ()); console .log (scores.toSorted ((a, b ) => a - b)); console .log (scores); const fruits = ['cherry' , 'apple' , 'banana' ]; const sorted = fruits.sort (); console .log (fruits); console .log (sorted === fruits); console .log (fruits.toReversed ()); console .log (fruits); </script > </body > </html >
解析
不給比較函式時,20 排在 3 前面,因為比的是字串 ‘20’ 與 ‘3’;給了 (a, b) => a - b 才是數字由小到大。
toSorted 兩次都沒有改到 scores,最後它仍是 20、3、100。
sort 直接把 fruits 排好,而且回傳值與 fruits 是同一個陣列,所以比較結果是 true;之後的 toReversed 只交回倒序的新陣列,fruits 維持排好的順序。
[100, 20, 3] [3, 20, 100] [20, 3, 100] ['apple', 'banana', 'cherry'] true ['cherry', 'banana', 'apple'] ['apple', 'banana', 'cherry']
toSorted 與 sort,以及中文排序 toSorted、toReversed 與 toSpliced、with 都是 ES2023 加入的寫法,現行瀏覽器都支援;要留著原順序時優先用它們,舊程式碼裡則常見先 slice 複製再 sort。字串預設依編碼排序,中文要依語言規則排序時,比較函式寫成 a.localeCompare(b, 'zh-Hant')。
方法串接 方法串接是把前一個方法交回的新陣列,直接接上下一個方法,例如 .filter(...).map(...)。filter 與 map 交回新陣列,所以能繼續接;reduce 交回的是單一累計值,通常放在最後。整條串接都不會改到原陣列。
觀念
每一段處理的都是上一段的回傳值:filter 交給 map 的是較短的新陣列。
串接之後,map 看到的索引屬於篩完的那一份,不是原陣列。
forEach 回傳 undefined,放在中間會讓下一段接到 undefined 而中斷。
04-js/pages/45-js-chain.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 方法串接</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const prices = [12800 , 15900 , 42800 , 6800 ]; const total = prices .filter ((price ) => price < 20000 ) .map ((price ) => price * 2 ) .reduce ((sum, price ) => sum + price, 0 ); console .log (total); console .log (prices); </script > </body > </html >
解析
filter 留下 12800、15900、6800,map 各乘 2,reduce 從 0 加總,得到 71000。
prices 仍是原來的四個數字,整條串接都沒有改到它。
最後一行若拿掉註解,forEach 回傳 undefined,接著呼叫 map 會丟出 TypeError。
71000 [12800, 15900, 42800, 6800]
選讀:Set Set 是一組不會重複的值,同一個值再放一次,數量不會增加,適合問「這個值出現過沒有」或替陣列去重。
觀念
new Set 會依第一次出現的順序留下值;size 是去重後的數量,has 問值在不在,add 再放一個值。
Set 沒有索引,也不能直接呼叫 map;需要陣列方法時,先用 Array.from 依插入順序交出新陣列。
比較值的方式和 includes 類似,所以 NaN 在 Set 裡只會留一份。
04-js/pages/46-js-set.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 選讀:Set</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const places = ['台北' , '花蓮' , '台北' , '京都' ]; const unique = new Set (places); console .log (unique.size ); console .log (unique.has ('花蓮' )); unique.add ('台南' ); console .log (unique.size ); unique.add ('台北' ); console .log (unique.size ); console .log (Array .from (unique)); </script > </body > </html >
解析
四個字串放進去之後,重複的台北只留一份,size 是 3;花蓮還在,has 是 true。
加上台南變成 4;再加一次台北,數量仍是 4。
Array.from 依插入順序交出台北、花蓮、京都、台南。
3 true 4 4 ['台北', '花蓮', '京都', '台南']
Set 轉陣列的另一種寫法 學了展開運算子 之後,也可以把 Set 攤進一對中括號轉成陣列。需要索引、排序,或要用 map 與 filter 處理的清單,仍然用陣列。
物件 物件用名字(key)對應到值(value),把一筆資料的各個欄位放在一起;陣列靠順序找資料,物件靠名字找資料。這一章先學怎麼建立物件、讀寫與刪除欄位、在物件裡寫函式,以及用可選串連安全地讀可能不存在的欄位,再認識物件的原型與 Object 上的靜態方法,最後在選讀補充 Map、方法被拆下來時的 this,以及一支把陣列方法與物件合用的完整範例。
物件基礎 這一節學物件最基本的操作:建立、讀寫欄位、放進函式,以及安全地讀取可能不存在的欄位。
建立與存取屬性 物件字面值用大括號包住一組「名字: 值」,欄位之間以逗號分隔。讀取時最常用點記法;名字放在變數裡、或名字含有減號、空白這類不能當識別字的字元時,改用中括號。讀不存在的欄位不會出錯,只會得到 undefined。
觀念
屬性簡寫:變數名稱與欄位名稱相同時,只寫一次,例如在大括號裡直接寫 title。
計算屬性:建立物件時用中括號包住運算式,欄位名稱到執行時才決定。
點記法與中括號讀到的是同一個欄位;中括號內可以放任何運算式,所以能用變數當欄位名稱。
04-js/pages/47-js-object.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 建立與存取屬性</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const title = '台北城市漫遊' ; const field = 'place' ; const tour = { id : 1 , title, place : '台北' , days : 3 , price : 12800 , [field + 'Code' ]: 'TPE' , }; console .log (tour.title ); console .log (tour['place' ]); console .log (tour[field]); console .log (tour.placeCode ); console .log (tour.guide ); </script > </body > </html >
解析
簡寫的 title 欄位拿到外面變數的值,所以第一行印出標題。
點記法與中括號讀的是同一個欄位;tour[field] 先把變數 field 換成字串 ‘place’,再去讀 place 欄位。
計算屬性由 field 接上 ‘Code’ 組成名稱,所以讀得到 placeCode。
物件裡沒有 guide,讀到的是 undefined,不會中斷程式。
新增修改與刪除屬性 物件建立後仍可以變動:賦值給已有的名字是修改,賦值給還沒有的名字是新增,delete 則拿掉欄位。要檢查欄位在不在,用 in 或 Object.hasOwn。
觀念
修改與新增都用賦值,差別只在名字原本有沒有。
delete 刪掉物件自己的欄位,刪完後再讀會得到 undefined。
in 會往原型(物件繼承來的共用方法所在)上找,Object.hasOwn 只看物件自己身上的欄位。
04-js/pages/48-js-object-update.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 新增修改與刪除屬性</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { id : 1 , title : '台北城市漫遊' , days : 3 , price : 12800 , }; tour.price = 13900 ; tour.seats = 8 ; console .log (tour.price ); console .log ('seats' in tour); console .log (Object .hasOwn (tour, 'seats' )); console .log ('toString' in tour); console .log (Object .hasOwn (tour, 'toString' )); delete tour.seats ; console .log (tour.seats ); console .log (tour.days ); </script > </body > </html >
解析
price 被改成 13900,seats 是新加的,兩個檢查都顯示 seats 在 tour 身上。
toString 是每個物件從原型繼承來的方法,所以 in 回傳 true,hasOwn 回傳 false,這就是兩者的差別。
delete 之後 seats 讀到 undefined,沒有被刪的 days 仍是 3。
13900 true true true false undefined 3
const 擋的是換一個物件 改欄位、加欄位、刪欄位動的都是同一個物件,不受 const 限制;寫成 tour = { id: 2 } 是要換成另一個物件,才會被擋下。
方法 放在物件裡的函式稱為方法。用「物件.方法()」呼叫時,方法裡的 this 就是點號左邊的那個物件,因此方法可以用 this 讀同一個物件上的其他欄位。
觀念
方法簡寫 label() {} 與 label: function () {} 寫法不同、用法相同,新寫的程式用簡寫。
方法必須透過物件呼叫,單獨寫 label() 會找不到這個名字。
方法不要寫成箭頭函式,因為箭頭函式沒有自己的 this;陣列方法的回呼才適合用箭頭。
04-js/pages/49-js-method.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 方法</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { title : '花蓮山海三日' , days : 3 , label ( ) { return this .title + '・' + this .days + ' 天' ; }, }; console .log (tour.label ()); </script > </body > </html >
解析
呼叫 tour.label() 時,點號左邊是 tour,所以 this.title 與 this.days 讀到 tour 的兩個欄位,接成一行字交回。
方法被拆下來會怎樣 把方法複製到別的變數再呼叫,this 就不再指向原物件。這個情況見選讀的「方法呼叫時的 this」。
可選串連 讀深層欄位時,中間某一層若是 null 或 undefined,再往下用點號讀會丟出 TypeError。可選串連 ?. 放在點號前面:左邊有值就照常往下讀,左邊是 null 或 undefined 就停下來,整段得到 undefined,不會中斷。
觀念
?. 只擋 null 與 undefined;0、空字串、false 都算有值,會繼續往下讀。
停下來得到 undefined 之後,若要補預設值,接上前面學過的 ??。
04-js/pages/50-js-optional.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 可選串連</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { title : '台北城市漫遊' , guide : { name : '林' } }; const other = { title : '花蓮山海三日' }; console .log (tour.guide ?.name ); console .log (other.guide ?.name ); console .log (other.guide ?.name ?? '未定' ); </script > </body > </html >
解析
第一個物件有 guide,所以讀得到「林」;第二個物件沒有 guide,可選串連在這裡停下,得到 undefined。
再接 ??,undefined 被換成預設的「未定」。
最後一行沒有 ?.,other.guide 是 undefined,再讀 name 就會丟出 TypeError。
物件原型與方法 物件和字串一樣有共用的原型 Object.prototype,toString 這類方法放在那裡,用點號呼叫。另一類方法直接放在 Object 本身,稱為靜態方法,呼叫時把物件當參數傳進去,例如 Object.keys(tour)。這一節學習用靜態方法取得物件的欄位,並用迴圈逐一走訪。
靜態方法 keys、values、entries 把物件自己的欄位整理成陣列,fromEntries 則反過來把陣列組回物件,四個都不會改動原物件。順序依欄位建立的順序;名稱是整數形式(如 ‘1’)的欄位例外,會先由小到大排在最前面。
一覽
Object.keys(obj):交回欄位名稱的陣列。
Object.values(obj):交回欄位值的陣列。
Object.entries(obj):交回「[名稱, 值]」兩格陣列所組成的陣列,名稱與值都保留。
Object.fromEntries(entries):反過來把「[名稱, 值]」的陣列組回新物件。
觀念
這三個方法要寫成 Object.keys(tour) 的形式;物件自己身上沒有 keys 這個欄位。
因為交回的是陣列,所以可以接著使用上一章的陣列方法。
04-js/pages/51-js-keys.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 靜態方法</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { id : 1 , title : '台北城市漫遊' , days : 3 }; console .log (Object .keys (tour)); console .log (Object .values (tour)); console .log (Object .entries (tour)); console .log (Object .fromEntries (Object .entries (tour))); console .log (tour.keys ); console .log (typeof tour.toString ); </script > </body > </html >
解析
keys 得到三個欄位名稱,values 得到對應的值,兩者的順序一致。
entries 的每一格又是一個兩格陣列,左邊是名稱,右邊是值;Object.fromEntries 把它組回一個和原本內容相同的新物件。
tour.keys 是 undefined,因為 keys 不在這個物件上,要透過 Object 呼叫。
toString 從原型取得,所以 typeof 是 function。
['id', 'title', 'days'] [1, '台北城市漫遊', 3] [['id', 1], ['title', '台北城市漫遊'], ['days', 3]] {id: 1, title: '台北城市漫遊', days: 3} undefined function
走訪欄位 想逐一處理物件的每個欄位,把 Object.entries 的結果交給 for…of 迴圈。每一圈拿到的是一組兩格陣列,索引 0 是欄位名稱,索引 1 是值。
觀念
迴圈變數是兩格陣列,不是欄位名稱本身。
迴圈只是讀取,不會改掉原物件。
04-js/pages/52-js-entries.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 走訪欄位</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { id : 1 , title : '台北城市漫遊' , days : 3 }; for (const pair of Object .entries (tour)) { console .log (pair[0 ], pair[1 ]); } </script > </body > </html >
解析
三組資料依建立順序印出,左邊是欄位名稱,右邊是值。
每一圈的 pair 都是新的兩格陣列,原物件的欄位完全不變。
for…in 會走到繼承來的鍵 for...in 走的是可列舉的鍵,範圍包含原型上的;Object.keys 只給物件自己的欄位。走訪物件請用 keys、values 或 entries 配 for…of。
選讀:Map 物件的鍵一律是字串(或 Symbol),數字 1 與字串 ‘1’ 會變成同一個欄位。Map 是另一種「鍵對值」的集合,鍵可以是任何型別,數字 1 與字串 ‘1’ 是不同的鍵。固定欄位的一筆資料仍然用物件,只有鍵不固定、型別不限時才考慮 Map。
觀念
用 set 放入「鍵、值」,用 get 以鍵取出,size 是目前的筆數。
鍵不存在時 get 得到 undefined;get(1) 與 get(‘1’) 是不同的兩格。
Map 與 Set 一樣是內建的集合;需要順序、要用 map 與 filter 處理的清單仍用陣列。
04-js/pages/53-js-map.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 選讀:Map</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const prices = new Map (); prices.set (1 , 12800 ); prices.set (2 , 15900 ); console .log (prices.get (1 )); console .log (prices.get ('1' )); console .log (prices.size ); </script > </body > </html >
解析
數字鍵 1 取出 12800;字串 ‘1’ 不是同一把鍵,所以得到 undefined。
放入兩筆,size 是 2。
選讀:方法呼叫時的 this this 的值取決於「怎麼呼叫」,而不是函式寫在哪裡。用「物件.方法()」呼叫時,this 是點號左邊的物件;把方法複製到另一個變數再呼叫,左邊沒有物件,this 就不再是原物件。
觀念
同一個函式,透過物件呼叫與單獨呼叫,this 不同。
單獨呼叫時 this 不是原物件:在一般的 script 裡是 window,讀不到這些欄位;嚴格模式下是 undefined,讀欄位會丟出 TypeError。
事件處理函式會再遇到這個問題,到時再回頭看這一節。
04-js/pages/54-js-this.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 方法呼叫時的 this</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { title : '花蓮山海三日' , days : 3 , label ( ) { return this .title + '・' + this .days + ' 天' ; }, }; console .log (tour.label ()); const copied = tour.label ; console .log (copied ()); </script > </body > </html >
解析
第一行透過 tour 呼叫,this 是 tour,兩個欄位都讀得到。
第二行把函式本身放進 copied 再呼叫,左邊沒有物件,this 不是 tour,兩個欄位都是 undefined,所以字串變成「undefined・undefined 天」。
花蓮山海三日・3 天 undefined・undefined 天
選讀:綜合練習 這一節把陣列方法、物件與函式放在同一支檔:陣列的每一格是物件,函式接收陣列,用 filter、map、find 交回新的結果,原陣列不被改動。
觀念
函式的第一個參數是整份陣列,不寫死某個陣列的名字,換一份資料仍可重複使用。
篩選用嚴格相等 ===,數字不要和字串比。
filter 留下符合條件的格子,map 取出需要的欄位,find 找出第一筆符合的,沒有就是 undefined。
04-js/pages/55-js-tours.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 綜合練習</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tours = [ { id : 1 , title : '台北城市漫遊' , place : '台北' , days : 3 , price : 12800 }, { id : 2 , title : '花蓮山海三日' , place : '花蓮' , days : 3 , price : 15900 }, { id : 3 , title : '京都紅葉散步' , place : '京都' , days : 5 , price : 42800 }, ]; const filterByDays = (list, days ) => { return list.filter ((tour ) => tour.days === days); }; const titlesOf = (list ) => { return list.map ((tour ) => tour.title ); }; const findById = (list, id ) => { return list.find ((tour ) => tour.id === id); }; console .log (titlesOf (filterByDays (tours, 3 ))); console .log (findById (tours, 1 )); console .log (findById (tours, 9 )?.title ); console .log (tours.length ); </script > </body > </html >
解析
filterByDays 留下 days 嚴格等於 3 的兩筆,titlesOf 再把它們收成標題陣列。
findById 對上 id 1,交回整筆物件。
id 9 不存在,find 得到 undefined,所以後面用 ?. 讀 title,結果是 undefined 而不會中斷。
原陣列長度仍是 3,京都那筆還在,證明這些方法都沒有改動原陣列。
['台北城市漫遊', '花蓮山海三日'] {id: 1, title: '台北城市漫遊', place: '台北', days: 3, price: 12800} undefined 3
選讀:內建物件 內建物件是 JavaScript 隨語言附帶、不用自己建立就能使用的現成工具。這一章介紹兩個:Math 提供數學常數與運算,Date 處理日期與時間。它們和用大括號自己寫出來的物件不同,後者是一筆自己的資料,前者是語言提供的功能。整章是選讀,專案用到時回來查即可。
Math Math 把數學常數與函式收在同一個名字上,用點號直接呼叫,不必也不能建立。這一節從常數與基本運算開始,接著是取整數、最大最小值與亂數,最後用這些組成一個大樂透號碼產生器。
Math 不能 new new Math() 會丟出 TypeError。常數與方法全語言共用,不需要另外做出一個 Math。
一覽
常數:Math.PI 是圓周率,Math.E 是自然常數。
運算:abs 取絕對值,pow 算次方,sqrt 算平方根。
取整數:round、floor、ceil、trunc 都回傳整數,差在往哪個方向收。
比大小:max 與 min 在傳入的數字裡挑最大與最小。
亂數:random 回傳 0 以上、小於 1 的小數。
常數與基本運算 圓周率、絕對值、次方與平方根都放在 Math 上。次方也可以用前面學過的 **,結果與 Math.pow 相同。
04-js/pages/56-js-math.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 常數與基本運算</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log (Math .PI ); console .log (Math .E ); console .log (Math .abs (-10 )); console .log (Math .pow (2 , 3 )); console .log (2 ** 3 ); console .log (Math .sqrt (16 )); </script > </body > </html >
解析
前兩行是固定常數,每次執行都一樣。
絕對值把 -10 收成 10。
Math.pow(2, 3) 與 2 ** 3 都是 8。
16 的平方根是 4。
3.141592653589793 2.718281828459045 10 8 8 4
取整數與四捨五入 四個取整數的方法都把小數收成整數,差別在方向:就近、往小、往大,或直接砍掉小數。正數時 floor 與 trunc 結果相同,到了負數才分得出來。
04-js/pages/57-js-round.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 取整數與四捨五入</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log (Math .round (2.7 )); console .log (Math .floor (2.7 )); console .log (Math .ceil (2.1 )); console .log (Math .trunc (2.9 )); console .log (Math .floor (-2.3 )); console .log (Math .trunc (-2.3 )); console .log (Math .round (2.5 )); console .log (Math .round (-2.5 )); </script > </body > </html >
解析
2.7 四捨五入是 3,往小收是 2。2.1 往大收是 3,2.9 去掉小數是 2。
-2.3 用 floor 往小收成 -3,用 trunc 朝 0 砍成 -2。
剛好 .5 時 round 往正無限大的方向收,所以 2.5 是 3,-2.5 是 -2;它不是「離 0 較遠的那一邊」。
最大值、最小值與亂數 Math.max 與 Math.min 在傳進去的數字裡挑一個,個數不限;資料在陣列裡時,用展開語法把元素攤成參數(展開在下一章正式介紹)。
Math.random 沒有參數,每次呼叫回傳 0 以上、小於 1 的小數,不會等於 1。要得到指定範圍的整數,先把小數放大成區間的寬度,用 floor 砍掉小數,再平移到起點,包成 getRandomInt。公式是 Math.floor(Math.random() * (max - min + 1)) + min,min 與 max 都可能抽到。
04-js/pages/58-js-random.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 最大值、最小值與亂數</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log (Math .max (1 , 5 , 3 )); console .log (Math .min (1 , 5 , 3 )); const scores = [72 , 95 , 88 ]; console .log (Math .max (...scores)); console .log (Math .random ()); function getRandomInt (min, max ) { return Math .floor (Math .random () * (max - min + 1 )) + min; } console .log (getRandomInt (1 , 10 )); </script > </body > </html >
解析
1、5、3 的最大是 5,最小是 1。陣列展開後同樣用 Math.max,得到 95。
亂數那一行是 0 到小於 1 的小數,getRandomInt(1, 10) 是 1 到 10 的整數,這兩行每次執行都不同。
大樂透產生器 台灣大樂透是從 1 到 49 抽出 6 個不重複的號碼。這個完整示範用 Set 記住已抽過的號碼,while 在湊滿 6 個之前繼續抽,最後轉回陣列由小到大排好;這兩者在前面章節的選讀已介紹過。
04-js/pages/59-js-lotto.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 綜合練習:大樂透產生器</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function getLottoNumbers ( ) { const numbers = new Set (); while (numbers.size < 6 ) { const n = Math .floor (Math .random () * 49 ) + 1 ; numbers.add (n); } return Array .from (numbers).sort ((a, b ) => a - b); } const picked = getLottoNumbers (); console .log (picked); console .log (picked.length ); console .log (new Set (picked).size ); </script > </body > </html >
解析
每個號碼是 1 到 49 的整數。抽到重複的號碼放進 Set 不會讓 size 增加,所以迴圈會繼續,直到湊滿 6 個。
Array.from 把 Set 轉成陣列,sort 的比較函式 (a, b) => a - b 讓數字由小到大排,並且改的是這個陣列本身。
長度是 6,再放進 Set 數量仍是 6,表示沒有重複。第一行的號碼每次執行都不同。
[8, 15, 22, 27, 34, 45] 6 6
Chrome Console 會把陣列寫成 (6) [8, 15, ...],內容以數字為準。
Date Date 表示一個時間點,內部存的是與時區無關的毫秒數,顯示時才依電腦時區換算。這一節先學建立、讀取與修改,再學時間戳記與 UTC 時區這兩個容易搞混的觀念,最後是格式化、日期計算與跨年倒數。
一覽
建立:new Date() 是現在,new Date(年, 月, ...) 指定本地時間,new Date('ISO 字串') 由字串建立。
讀取:getFullYear、getMonth、getDate、getDay、getHours、getMinutes、getSeconds 讀出本地時間的各個欄位。
修改:對應的 set 開頭方法,直接改掉這個物件。
毫秒:getTime 與 Date.now() 取得時間戳記。
輸出:toISOString 輸出 UTC 字串,toLocaleString 系列與 Intl.DateTimeFormat 輸出給人看的文字。
月份從 0 開始 getMonth 與建立時的月份參數都是 0 到 11,0 是 1 月,11 是 12 月。印給人看時要加 1。星期的 getDay 也是從 0 開始,0 是星期日。
建立指定日期 new Date() 沒有參數時是現在。要指定時間,依序傳入年、月、日、時、分、秒,沒傳的欄位是日從 1、其餘從 0。這種寫法一律解讀成本地時間,月份要傳 0 到 11,所以 5 月傳 4。也可以傳 ISO 格式的字串;字串怎麼被解讀,見後面的 UTC 與時區。
04-js/pages/63-js-date.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 建立指定日期</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const now = new Date (); const birthday = new Date (1990 , 4 , 15 , 8 , 30 , 0 ); const dayOnly = new Date (2026 , 7 , 1 ); const isoLocal = new Date ('2026-08-01T12:00:00' ); console .log (now.getFullYear ()); console .log ( birthday.getMonth () + 1 , birthday.getDate (), birthday.getHours (), birthday.getMinutes () ); console .log (dayOnly.getHours (), dayOnly.getMinutes ()); console .log (isoLocal.getMonth () + 1 , isoLocal.getDate (), isoLocal.getHours ()); </script > </body > </html >
解析
第一行是執行當下的年份,每次執行都不同。
月份索引 4 加 1 是 5 月,日期 15,時間 8 時 30 分。
只傳年月日時,時與分都是 0。
帶 T 與時間、沒有時區的字串,被讀成本地的 8 月 1 日 12 時。
new Date 與 Date 的差異 同樣是 Date 這個名字,有沒有 new 差很多。new Date() 做出日期物件,物件上才有 getFullYear 這類方法。不加 new 的 Date() 只回傳當下時間的字串,字串上沒有日期方法。這是歷史遺留的寫法,實務上永遠加 new。
Date.now() 不建立物件,直接回傳毫秒數的時間戳記。
04-js/pages/62-js-date-call.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > new Date 與 Date 的差異</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > console .log (typeof new Date ()); console .log (typeof Date ()); console .log (typeof Date ().getFullYear ); console .log (typeof new Date ().getFullYear ); console .log (typeof Date .now ()); </script > </body > </html >
解析
new Date() 是 object,Date() 是 string,Date.now() 是 number。
getFullYear 後面沒有括號,只是讀取屬性;字串沒有這個屬性,所以得到 undefined,程式不會中斷。
物件上的 getFullYear 是 function。
object string undefined function number
讀取日期與時間 讀取用 get 開頭的方法,只看值,不改原本的時間。getDate 是幾號,getDay 是星期,名字只差一個字,要印出幾號用前者。時、分、秒各自有對應的方法。
04-js/pages/64-js-date-get.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 讀取日期與時間</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const point = new Date (2026 , 7 , 1 , 14 , 30 , 45 ); console .log (point.getFullYear ()); console .log (point.getMonth () + 1 ); console .log (point.getDate ()); console .log (point.getDay ()); console .log (point.getHours (), point.getMinutes (), point.getSeconds ()); </script > </body > </html >
解析
年份 2026,月份索引 7 加 1 是 8 月,日期是 1。
2026 年 8 月 1 日是星期六,getDay 得到 6。
14 時 30 分 45 秒是建立時傳入的時間。
設定日期與時間 set 開頭的方法會直接改掉原來那一個日期物件。要留著改之前的時間,就先用 new Date(date) 複製一份,再對複本呼叫 set。數字超出該欄的範圍時會自動進位,例如 1 月 setDate(32) 會進到 2 月 1 日。
04-js/pages/65-js-date-set.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 設定日期與時間</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const date = new Date (2026 , 0 , 15 , 10 , 20 , 30 ); console .log (date.getDate (), date.getHours (), date.getMinutes ()); date.setFullYear (2027 ); date.setMonth (5 ); date.setDate (20 ); console .log (date.getFullYear (), date.getMonth () + 1 , date.getDate ()); date.setHours (14 , 30 , 45 ); date.setMinutes (5 ); date.setSeconds (8 ); date.setMilliseconds (250 ); console .log ( date.getHours (), date.getMinutes (), date.getSeconds (), date.getMilliseconds () ); const base = new Date (2026 , 6 , 15 , 10 , 0 , 0 ); const tomorrow = new Date (base); tomorrow.setDate (base.getDate () + 1 ); const nextMonth = new Date (base); nextMonth.setMonth (base.getMonth () + 1 ); const nextHour = new Date (base); nextHour.setHours (base.getHours () + 1 ); console .log (base.getDate (), tomorrow.getDate ()); console .log (base.getMonth () + 1 , nextMonth.getMonth () + 1 ); console .log (base.getHours (), nextHour.getHours ()); const overflow = new Date (2026 , 0 , 1 ); overflow.setDate (32 ); console .log (overflow.getMonth () + 1 , overflow.getDate ()); </script > </body > </html >
解析
第一行是改之前的 15 日 10 時 20 分。接下來的 set 都改在同一個物件上,月份索引 5 讀回來是 6 月。
setHours 可以一次寫入時、分、秒,接著分、秒、毫秒各自再改。
base 保持 15 日、7 月、10 時不變;三個複本分別是明天 16 日、下個月 8 月、下一小時 11 時。
1 月 1 日設成 32 號,進位成 2 月 1 日。
15 10 20 2027 6 20 14 5 8 250 15 16 7 8 10 11 2 1
月底改月份 把 1 月 31 日用 setMonth 改成 2 月,2 月沒有 31 日,會進位成 3 月 3 日(2026 年)。月底的日期加減月份時要留意。
時間戳記 時間戳記(timestamp)是從 1970-01-01 00:00:00 UTC 起算經過的毫秒數,這個起點稱為 Unix epoch。它是一個 number,與時區無關,所以適合比較、儲存,以及計算兩個時間相差多久。
觀念
Date.now() 取得當下的毫秒,getTime 讀出某個 Date 的毫秒,new Date(毫秒) 把毫秒轉回 Date。
Unix 系統與許多後端 API 的時間戳記以秒為單位,JavaScript 用毫秒:秒要乘 1000 才能放進 Date,毫秒除以 1000 再取整才是秒。
兩個 Date 相減,JavaScript 會先轉成毫秒再相減,結果是 number。
04-js/pages/61-js-timestamp.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 時間戳記</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const epoch = new Date (0 ); console .log (epoch.toISOString ()); console .log (epoch.toString ()); const point = new Date ('2026-08-01T00:00:00Z' ); console .log (point.getTime ()); console .log (Date .now ()); const unixSeconds = 1785542400 ; console .log (new Date (unixSeconds * 1000 ).toISOString ()); console .log (Math .floor (point.getTime () / 1000 )); const start = new Date (2026 , 7 , 1 ); const end = new Date (2026 , 7 , 2 ); console .log (end - start); console .log (end.getTime () - start.getTime ()); </script > </body > </html >
解析
new Date(0) 是 epoch。ISO 字串是 UTC 午夜,本地時間在台灣是 08:00,所以第二行是 1970 年 1 月 1 日 08:00。
getTime 讀出 2026-08-01 午夜 UTC 的毫秒,下一行是執行當下,每次都不同。
秒乘 1000 轉回同一個 UTC 午夜,毫秒除以 1000 取整得到 Unix 的秒。
兩個 Date 相減與 getTime 相減都是 86400000,也就是一天的毫秒。
1970-01-01T00:00:00.000Z Thu Jan 01 1970 08:00:00 GMT+0800 (台北標準時間) 1785542400000 1792731067778 2026-08-01T00:00:00.000Z 1785542400 86400000 86400000
第二行以台灣 UTC+8 為例,括號內的時區名稱依執行環境而定。
UTC 與時區 UTC 是協調世界時,全世界共用的基準;各地的鐘面是在這個基準上加減時差,台灣是 UTC+8,所以 UTC 的 00:00 是台灣的 08:00。Date 物件存的只是一個時間點,顯示時才依電腦時區換算,同一個時間點在不同時區的電腦上會顯示成不同的鐘面時間。
用字串建立 Date 時,有沒有寫時區,會決定這個時間點落在哪裡,這是最常見的陷阱。
觀念
字串結尾有 Z(代表 UTC)或 +08:00 這類時差,時間點就是明確的,在任何電腦上都相同。
只有日期的 '2026-08-01' 被當成 UTC 午夜,台灣的本地時間是同日 08:00。
有時間但沒有時差的 '2026-08-01T12:00:00' 被當成本地時間,在不同時區的電腦上是不同的時間點。
toISOString 一律顯示 UTC;getHours 讀本地小時,getUTCHours 讀同一時間點的 UTC 小時。
04-js/pages/60-js-utc.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > UTC 與時區</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const point = new Date ('2026-08-01T12:00:00+08:00' ); console .log (point.toString ()); console .log (point.toLocaleString ('zh-TW' )); console .log (point.toISOString ()); console .log (point.getHours (), point.getUTCHours ()); const dateOnly = new Date ('2026-08-01' ); console .log (dateOnly.toISOString (), dateOnly.getHours ()); const localNoon = new Date ('2026-08-01T12:00:00' ); console .log (localNoon.getHours (), localNoon.toISOString ()); const utcNoon = new Date ('2026-08-01T12:00:00Z' ); console .log (utcNoon.getHours (), utcNoon.toISOString ()); </script > </body > </html >
解析
前兩行是本地的 12:00,第三行是同一個時間點的 UTC,所以是 04:00,結尾 Z。
getHours 是 12,getUTCHours 是 4,台灣相差 8 小時。
只有日期的字串是 UTC 午夜,本地小時在台灣是 8。
沒有時差的中午是本地 12 時,轉成 UTC 是 04:00;帶 Z 的中午是 UTC 12 時,台灣本地是 20 時。
Sat Aug 01 2026 12:00:00 GMT+0800 (台北標準時間) 2026/8/1 下午12:00:00 2026-08-01T04:00:00.000Z 12 4 2026-08-01T00:00:00.000Z 8 12 2026-08-01T04:00:00.000Z 20 2026-08-01T12:00:00.000Z
以台灣 UTC+8 為例。帶 Z 或 +08:00 的字串,ISO 輸出在任何地方都相同;沒有時差的字串,輸出會隨電腦時區改變。需要精確時,就在字串上寫明時區。
日期格式化 Date 本身沒有格式,要把它印給人看,用 toLocaleString 系列依地區與選項產生文字:本尊含日期與時間,名字中間加 Date 只有日期,加 Time 只有時間。第一個參數是語言標籤,如 zh-TW;沒傳時會跟著使用者的瀏覽器設定,不同電腦印出的文字會不同。
第二個參數是選項物件,可以指定年月日的樣貌、是否 12 小時制,以及要換算成哪個時區。同樣的選項也能交給 Intl.DateTimeFormat:先建立一個格式器,再套用到任意日期,需要格式化很多筆時只建立一次比較有效率。
年月日的樣貌可以逐項指定,也可以用現成的組合,分成 full、long、medium、short 四種長度。
時區用 timeZone 指定,不寫就是執行環境的本地時區。
04-js/pages/66-js-date-format.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 日期格式化</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const point = new Date (2026 , 7 , 1 , 14 , 30 , 45 ); console .log (point.toLocaleString ('zh-TW' )); console .log (point.toLocaleDateString ('zh-TW' )); console .log (point.toLocaleTimeString ('zh-TW' )); console .log ( point.toLocaleDateString ('zh-TW' , { year : 'numeric' , month : 'long' , day : 'numeric' , weekday : 'long' , }) ); console .log (point.toLocaleTimeString ('zh-TW' , { hour12 : false })); const full = new Intl .DateTimeFormat ('zh-TW' , { dateStyle : 'full' , timeStyle : 'short' , }); console .log (full.format (point)); const tokyo = new Intl .DateTimeFormat ('zh-TW' , { dateStyle : 'medium' , timeStyle : 'medium' , timeZone : 'Asia/Tokyo' , }); console .log (tokyo.format (point)); </script > </body > </html >
解析
前三行指定 zh-TW,分別是日期加時間、只有日期、只有時間。
第四行用選項取得「2026年8月1日星期六」這種完整寫法,第五行改成 24 小時制。
Intl.DateTimeFormat 的 full 加 short 產生「2026年8月1日 星期六 下午2:30」,樣式與 toLocaleString 的選項是同一套。
最後指定 Asia/Tokyo 時區,台灣 14:30 換算成東京是 15:30。
2026/8/1 下午2:30:45 2026/8/1 下午2:30:45 2026年8月1日星期六 14:30:45 2026年8月1日 星期六 下午2:30 2026年8月1日 下午3:30:45
實際文字可能因瀏覽器版本與語言資料而有細微差別,例如空白或「下午」的寫法。
日期計算 兩個 Date 相減得到毫秒,除以一天的毫秒數 1000 * 60 * 60 * 24 就換成天數。往前或往後推幾天,用 get 讀出再 set 寫回,進位會自動處理;兩個 Date 也可以直接用大於、小於符號比較先後,因為比的是毫秒。
04-js/pages/66b-js-date-diff.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 日期計算</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const start = new Date (2026 , 7 , 1 ); const end = new Date (2026 , 7 , 10 ); const ms = end - start; console .log (ms); console .log (ms / (1000 * 60 * 60 * 24 )); function daysBetween (from , to ) { return Math .round ((to - from ) / (1000 * 60 * 60 * 24 )); } console .log (daysBetween (new Date (2026 , 0 , 1 ), new Date (2026 , 11 , 31 ))); const deadline = new Date (2026 , 7 , 1 ); deadline.setDate (deadline.getDate () + 30 ); console .log (deadline.getMonth () + 1 , deadline.getDate ()); console .log (new Date (2026 , 7 , 1 ) < new Date (2026 , 7 , 2 )); </script > </body > </html >
解析
8 月 1 日到 8 月 10 日相差 777600000 毫秒,換成 9 天。
自訂的 daysBetween 多包一層 Math.round,避免因為日光節約時間造成一天只有 23 或 25 小時而出現小數;台灣沒有日光節約,不會遇到。
8 月 1 日加 30 天,讀回是 8 月 31 日。
最後一行比較兩個日期,8 月 1 日早於 8 月 2 日,所以是 true。
Temporal 是 Date 的接班人 Date 的月份從 0 開始、物件可變、時區處理容易出錯,所以語言新增了 Temporal 來取代它。Temporal 已進入 TC39 Stage 4,Firefox 139、Chrome/Edge 144 與 Node 26 起可直接使用,但 Safari 截至目前仍只有 Technology Preview,尚未成為 Baseline;目前的專案仍以 Date 為主,本課不教 Temporal。
跨年倒數 目標放在今年的 12 月 31 日 23:59:59,用現在時間去減,得到剩下的毫秒,再用 Math.floor 與 % 拆成天、時、分、秒。月份傳 11 才是 12 月。
04-js/pages/67-js-countdown.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 綜合練習:跨年倒數</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function getCountdownToNewYear ( ) { const now = new Date (); const target = new Date (now.getFullYear (), 11 , 31 , 23 , 59 , 59 ); const diff = Math .max (0 , target - now); const sec = Math .floor (diff / 1000 ) % 60 ; const min = Math .floor (diff / (1000 * 60 )) % 60 ; const hr = Math .floor (diff / (1000 * 60 * 60 )) % 24 ; const day = Math .floor (diff / (1000 * 60 * 60 * 24 )); console .log (`距離今年跨年還有 ${day} 天 ${hr} 小時 ${min} 分 ${sec} 秒` ); } getCountdownToNewYear (); </script > </body > </html >
解析
目標用今年的年份配上 12 月 31 日 23:59:59,12 月的索引是 11。
差若是負的,代表時間已過,Math.max 把它收成 0,避免印出負數。
毫秒先換成秒,再用餘數依 60、60、24 取出不滿一分、一小時、一天的部分,天數是剩下的整天,不再取餘數。
實際數字依執行時間而定;已經過了那個時間,四個數字都會是 0。
距離今年跨年還有 69 天 11 小時 38 分 49 秒
解構與展開 解構把陣列的某一格或物件的某個欄位取成變數,展開把已有的格子或欄位攤進新的陣列、新的物件或函式的引數。這一章先學解構的三種寫法,再學展開的三種用法,最後把兩者合起來,學會「不改動原資料、改交回一份新資料」的不可變更新。React 的狀態與元件參數大量依賴這幾個寫法。
解構賦值 解構是把「取值並命名」寫成一行:陣列看位置,物件看欄位名,函式的參數也能直接拆開傳進來的物件。解構只是多了幾個變數,原來的陣列和物件完全不受影響。
陣列解構 陣列解構在左邊用中括號依位置取名字,右邊放陣列。第一個名字對到索引 0,想跳過的位置留空。它常用在函式一次回傳多個值的場合,呼叫的一方用中括號把值分別接住。
觀念
左邊名字的順序就是索引的順序。
想跳過的位置留空,兩旁的逗號不能省。
函式只能回傳一個值,回傳陣列再解構,就能一次拿到兩個以上的值。
04-js/pages/68-js-array-destructure.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 陣列解構</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const titles = ['台北城市漫遊' , '花蓮山海三日' , '京都紅葉散步' ]; const [first, second] = titles; console .log (first); console .log (second); const [, , third] = titles; console .log (third); console .log (titles.length ); function getRange ( ) { return [1 , 10 ]; } const [min, max] = getRange (); console .log (min, max); </script > </body > </html >
解析
first 對到索引 0,second 對到索引 1。
兩個空位讓 third 對到索引 2,所以是京都紅葉散步。
長度仍是 3,解構沒有拿掉任何一格。
getRange 回傳的陣列依序解構成 min 與 max,印出 1 和 10。
React 的 useState 就是陣列解構 之後會看到 const [count, setCount] = useState(0)。useState 回傳一個兩格的陣列,第 0 格是目前的值,第 1 格是更新用的函式,名字由你在左邊自己取。
物件解構 物件解構在左邊用大括號寫欄位名,右邊放物件。對到的是名字,和寫的順序無關。欄位不存在時可以給預設值,想換一個變數名則用冒號重新命名。
觀念
大括號裡寫的是物件的欄位名。
冒號右邊是新的變數名,原欄位名不再是變數。
預設值只在取到的值是 undefined(包含沒有這個欄位)時才用上,0、空字串與 null 都會原樣留著。
04-js/pages/69-js-destructure.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 物件解構</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { title : '京都紅葉散步' , place : '京都' , days : 5 , price : 0 }; const { title, place } = tour; const { days : duration } = tour; const { guide = '未定' , price = 999 } = tour; console .log (title, place); console .log (duration); console .log (guide); console .log (price); </script > </body > </html >
解析
title 與 place 直接取得欄位的值,不必寫 tour.title 與 tour.place。
days 被改名為 duration,所以印出的是 5。
tour 沒有 guide 欄位,預設值「未定」才用上。
price 的值是 0,不是 undefined,所以保留 0,預設值 999 沒有出場。
函式參數解構 函式的參數位置也能直接寫大括號。呼叫時仍然傳入整個物件,函式裡只取需要的欄位當變數。React 的元件正是用這種寫法接收 props。
觀念
呼叫端傳的是一整顆物件,不是把欄位分開傳。
大括號裡沒寫到的欄位不會消失,仍留在原物件上。
預設值與重新命名的寫法,和物件解構相同。
04-js/pages/70-js-param-destructure.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 函式參數解構</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { title : '台北城市漫遊' , price : 12800 , days : 3 }; function label ({ title, price, unit = 'NT$' } ) { return `${title} ・${unit} ${price} ` ; } console .log (label (tour)); console .log (tour.days ); </script > </body > </html >
解析
label 收到整顆 tour,參數的大括號取出 title 與 price,unit 沒有傳,用預設的 NT$,接成一行字。
days 沒有寫進參數,物件上的 days 仍是 3。
解構搭配其餘 解構時在最後面加上 ...名字,可以把「沒被取走的剩下部分」收成一個新的陣列或物件。這和函式章教過的其餘參數是同一個寫法,只是這次用在解構的左邊,細節請回頭看 JavaScript 基礎:值、函式、陣列與模組 的「其餘參數」。
觀念
陣列解構的其餘收成陣列,物件解構的其餘收成物件。
其餘一定放在最後,後面不能再有名字。
用物件解構的其餘,可以得到「少了某幾個欄位」的新物件。
04-js/pages/70b-js-rest-destructure.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 解構搭配其餘</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const places = ['台北' , '花蓮' , '京都' , '台南' ]; const [head, ...others] = places; console .log (head); console .log (others); const tour = { id : 7 , title : '花蓮山海三日' , days : 3 , price : 15900 }; const { id, ...info } = tour; console .log (id); console .log (info); </script > </body > </html >
解析
head 取走第 0 格,others 是剩下三格組成的新陣列。
id 被取走,info 是不含 id 的新物件,原來的 tour 沒有變。
台北 ['花蓮', '京都', '台南'] 7 { title: '花蓮山海三日', days: 3, price: 15900 }
展開運算子 展開運算子是三個點 ...,把已有的格子或欄位攤開。寫在中括號裡得到新陣列,寫在大括號裡得到新物件,寫在函式呼叫的引數位置則是逐個傳進參數。前兩種得到的是新的陣列或物件,不會動到原來那一份。
陣列展開 三個點寫在中括號裡,把另一個陣列的格子依序攤進來,結果是一個新陣列。可以在前面、中間或後面再接其他值,也可以只展開自己來複製一份。
觀念
新陣列和原陣列是兩個獨立的陣列,改其中一個不會影響另一個。
展開可以和其他值寫在同一對中括號裡,順序就是寫的順序。
04-js/pages/71-js-array-spread.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 陣列展開</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const places = ['台北' , '花蓮' , '京都' ]; const more = [...places, '台南' ]; console .log (places); console .log (more); const copy = [...places]; copy.push ('高雄' ); console .log (places); console .log (copy); </script > </body > </html >
解析
more 在後面多了台南,places 仍是三個地名。
copy 是另一份,push 高雄之後只有 copy 變長,places 沒變。
['台北', '花蓮', '京都'] ['台北', '花蓮', '京都', '台南'] ['台北', '花蓮', '京都'] ['台北', '花蓮', '京都', '高雄']
物件展開 三個點寫在大括號裡,把另一個物件的欄位攤進新物件。同名欄位以寫在後面的為準,所以「先展開,再寫要改的欄位」就是複製並覆蓋。這是淺拷貝:第一層的數字與字串是獨立的新值,但巢狀的陣列或物件仍是同一個參考。
觀念
後寫的同名欄位蓋過先攤開的,沒寫到的欄位照樣複製過去。
改新物件第一層的值,不會影響原物件。
巢狀的陣列或物件只複製了參考,兩邊看到的是同一份。
04-js/pages/72-js-spread.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 物件展開</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const tour = { title : '台北城市漫遊' , days : 3 , price : 12800 , tags : ['城市' ], }; const discounted = { ...tour, price : 11800 }; console .log (tour.price ); console .log (discounted.price ); console .log (discounted.title ); discounted.tags .push ('步行' ); console .log (tour.tags ); console .log (discounted.tags ); </script > </body > </html >
解析
discounted 的 price 被後寫的 11800 蓋過,原物件仍是 12800。
title 沒有被改寫,所以新物件的標題還是台北城市漫遊。
tags 是巢狀陣列,展開時複製的是參考。從新物件 push 之後,原物件的 tags 也變成兩個字串。這是淺拷貝的陷阱,後面的不可變更新會教怎麼避開。
12800 11800 台北城市漫遊 ['城市', '步行'] ['城市', '步行']
整份深層複製用 structuredClone 展開只複製第一層。連巢狀的陣列和物件都要完整複製時,用 structuredClone(tour),它交回一份完全獨立的新資料。它無法複製函式,遇到時會丟出錯誤。
函式呼叫時展開 三個點寫在呼叫的引數位置,把陣列的格子依序送進參數。它不能單獨成一行,只能出現在中括號、大括號或引數列表裡。
觀念
陣列的第 0 格給第一個參數,後面依序對上。
展開是「把已有的陣列拆開」,其餘參數是「把多出來的引數收成陣列」,兩者方向相反。
04-js/pages/73-js-spread-call.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 函式呼叫時展開</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function total (a, b, c ) { return a + b + c; } const prices = [12800 , 15900 , 42800 ]; console .log (total (...prices)); console .log (total (prices[0 ], prices[1 ], prices[2 ])); console .log (Math .max (...prices)); </script > </body > </html >
解析
展開把三個價格依序送進 a、b、c,和是 71500。
第二行逐個傳入,結果相同,可見展開就是省掉逐個取值的寫法。
Math.max 本來要一個一個傳數字,展開讓它直接找出陣列裡的最大值 42800。
不可變更新 不可變更新的意思是:不修改原來的物件或陣列,而是用展開做出一份改好的新資料,再用新資料取代舊的。React 靠「新舊參考是否不同」判斷狀態有沒有改變,直接修改原資料畫面就不會更新,所以這是之後寫 React 時每天用到的寫法。
更新物件欄位 要改物件的一個欄位時,先展開原物件,再寫上要改的欄位,得到一個新物件。巢狀的物件也要用同樣的方式,從裡到外每一層都展開一次,不然那一層仍會共用同一個參考。
觀念
不直接寫 obj.欄位 = 新值,而是 { ...obj, 欄位: 新值 }。
巢狀物件要逐層展開:外層展開之後,裡面要改的那一層也再展開一次。
新舊兩個物件是不同的參考,用 === 比較會是 false,這正是 React 看到的「有變化」。
04-js/pages/73b-js-immutable-object.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 更新物件欄位</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const user = { name : 'Amy' , age : 28 , address : { city : '台北' , zip : '100' } }; const older = { ...user, age : 29 }; console .log (user.age , older.age ); console .log (user === older); const moved = { ...user, address : { ...user.address , city : '高雄' } }; console .log (user.address .city ); console .log (moved.address .city ); console .log (moved.address .zip ); </script > </body > </html >
解析
older 的 age 是 29,原來的 user 仍是 28。兩個物件不是同一個,比較結果是 false。
moved 把 address 換成新物件:先展開舊的 address,再覆蓋 city。所以新物件的城市是高雄,原物件仍是台北。
zip 沒有寫到,由展開自動帶過來,仍是 100。
新增與刪除陣列項目 陣列的不可變更新有三個固定寫法:新增用展開加上新項目,刪除用 filter 留下不要刪的,修改某一項用 map 逐項處理、遇到目標才換成新物件。三種寫法都交回新陣列,原陣列不動。filter 與 map 的用法在陣列方法一章已經學過。
觀念
新增:[...list, 新項目],要加在前面就把新項目寫在展開前面。
刪除:list.filter(...) 留下條件成立的項目,不要的自然消失。
修改:list.map(...) 對每一項決定「原樣交回」或「交回改過的新物件」。
04-js/pages/73c-js-immutable-array.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 新增與刪除陣列項目</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const todos = [ { id : 1 , text : '買牛奶' , done : false }, { id : 2 , text : '寫講義' , done : false }, ]; const added = [...todos, { id : 3 , text : '運動' , done : false }]; console .log (added.length ); const removed = todos.filter ((todo ) => todo.id !== 1 ); console .log (removed); const toggled = todos.map ((todo ) => todo.id === 2 ? { ...todo, done : true } : todo, ); console .log (toggled); console .log (todos); </script > </body > </html >
解析
added 有 3 筆,新項目在最後。
removed 只剩 id 為 2 的那一筆。
toggled 的第二筆是用展開做出的新物件,done 變成 true,第一筆原樣交回。
最後印出的 todos 仍是兩筆、done 都是 false,證明三次操作都沒有動到原陣列。
3 [ { id: 2, text: '寫講義', done: false } ] [ { id: 1, text: '買牛奶', done: false }, { id: 2, text: '寫講義', done: true } ] [ { id: 1, text: '買牛奶', done: false }, { id: 2, text: '寫講義', done: false } ]
push、splice、直接賦值會改到原資料 todos.push(...)、todos[0].done = true 這類寫法直接修改原陣列或原物件。在 React 的狀態上這樣寫,畫面不會更新,要改用上面的新資料寫法。陣列的 sort 與 reverse 也會直接改原陣列,可改用回傳新陣列的 toSorted 與 toReversed。
選讀:錯誤處理 程式跑起來之後仍可能中斷,例如名字打錯、對這個值呼叫它沒有的方法,或數值超出範圍。中斷時 Console 會留下錯誤類型、說明與行號,讀懂它就能找到出錯的那一行。這一章先認識常見的錯誤類型與讀懂錯誤訊息,再整理除錯技巧,最後補上 finally、自訂錯誤與輸入驗證。try、catch 與 throw 的基本寫法放在 JavaScript:非同步、Fetch 與瀏覽器儲存 的錯誤處理基礎,專案會用到,所以那裡是必教,這一章直接沿用。
錯誤類型與訊息 錯誤發生後若沒有接住,同一支腳本在該行之後的程式不會再跑。這一節先分清楚四種常見類型,再學怎麼從 Console 的紅字讀出原因與位置。
常見錯誤類型 四種錯誤看名稱就能分開:每個錯誤物件都有 name(類型)與 message(這次為什麼觸發)。第一種語法錯誤在腳本開始跑之前就會被找出來,其餘三種要執行到那一行才發生。示範把能接住的三種放進 try,語法錯誤那一行只留在註解,否則整份腳本不會執行。
觀念
SyntaxError:程式不符合語法,例如括號或引號沒有成對。整份腳本在執行前就停住。
ReferenceError:用到還沒宣告的名字。
TypeError:這個值不支援該操作,例如對數字呼叫字串方法,或對 null 讀屬性。
RangeError:數值超出允許範圍,例如陣列長度設成負數。
04-js/pages/74-js-error-type.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 錯誤類型</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > try { console .log (notDeclared); } catch (error) { console .log (error.name ); console .log (error.message ); } try { const score = 80 ; console .log (score.toUpperCase ()); } catch (error) { console .log (error.name ); console .log (error.message ); } try { const scores = new Array (-1 ); console .log (scores); } catch (error) { console .log (error.name ); console .log (error.message ); } console .log ('三種錯誤都接住了' ); </script > </body > </html >
ReferenceError notDeclared is not defined TypeError score.toUpperCase is not a function RangeError Invalid array length 三種錯誤都接住了
解析
註解那一行若真的寫進去,Console 只會出現一則 missing ) after argument list,下面的 try 都不會跑。
三個 catch 各自印出 name 與 message,最後一行出現,表示腳本沒有中斷。
ReferenceError 的說明帶有那個不存在的名字;TypeError 指出數字 score 沒有字串方法。
RangeError 來自長度為負的陣列。長度 0 仍是合法的空陣列,不會進這個 catch。
讀懂錯誤訊息 沒被接住的錯誤會以紅字停在 Console。先看類型與說明知道出了什麼事,再看行號回到腳本裡的那一行;函式一層層怎麼呼叫過來,則記錄在呼叫堆疊裡。用 try 接住之後紅字不會自動出現,要自己把類型與說明印出來,後面的程式才會繼續。
觀念
紅字要同時看類型、說明與行號:類型與說明告訴你原因,行號告訴你位置。
error.name 是類型,error.message 是說明。
沒接住的紅字下方會列出呼叫堆疊(stack),由出錯點往回列出是哪些函式呼叫過來的。
04-js/pages/75-js-error-message.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 讀懂錯誤訊息</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function formatScore (score ) { return score.toFixed (0 ); } function label (score ) { return formatScore (score); } try { console .log (label (null )); } catch (error) { console .log (error.name ); console .log (error.message ); } console .log ('程式繼續' ); </script > </body > </html >
TypeError Cannot read properties of null (reading 'toFixed') 程式繼續
解析
name 是 TypeError,message 指出無法對 null 讀取 toFixed。
label 把 null 傳進 formatScore,出錯點在 formatScore,呼叫它的是 label,堆疊會依這個順序列出。
若拿掉 try,Console 會出現帶行號的紅字,「程式繼續」不會印。接住之後它仍會出現。
除錯技巧 紅字只告訴你結果,中間的值要自己印出來看。逐步追蹤、表格與計時都能用 console 完成;想在某一行暫停檢查變數,就在那一行寫 debugger。示範把暫停那一行放在註解裡,頁面才會一次跑完。
觀念
console.log 在關鍵步驟印出目前的值,用來確認程式有走到這裡。
console.table 把陣列或物件畫成表格;console.time 與 console.timeEnd 用同一個標籤量出耗時。
debugger 在 DevTools 打開時會暫停,可以逐行檢查當下的變數;在 Sources 面板點行號設中斷點,效果相同而且不必改程式。
用常數 DEBUG 控制除錯訊息:改成 false 就全部不印,不必逐行刪除。
04-js/pages/76-js-debug.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 除錯技巧</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > const DEBUG = true ; function debugLog (message ) { if (DEBUG ) { console .log ('[DEBUG]' , message); } } function sumScores (scores ) { debugLog ('開始加總' ); console .time ('加總' ); let total = 0 ; for (let i = 0 ; i < scores.length ; i++) { total += scores[i]; console .log (`第 ${i} 個:${scores[i]} ,目前 ${total} ` ); } console .timeEnd ('加總' ); return total; } const rows = [ { name : '小明' , score : 85 }, { name : '小華' , score : 92 }, { name : '小李' , score : 78 }, ]; console .table (rows); console .log (sumScores ([10 , 20 , 30 ])); </script > </body > </html >
┌─────────┬────────┬───────┐ │ (index) │ name │ score │ ├─────────┼────────┼───────┤ │ 0 │ '小明' │ 85 │ │ 1 │ '小華' │ 92 │ │ 2 │ '小李' │ 78 │ └─────────┴────────┴───────┘ [DEBUG] 開始加總 第 0 個:10,目前 10 第 1 個:20,目前 30 第 2 個:30,目前 60 加總: 0.092ms 60
解析
前三筆資料在 Console 會畫成表,欄位是 name 與 score;上面的文字表格是同一份輸出的另一種呈現。
帶 [DEBUG] 的那行表示函式已開始。迴圈每一圈印出索引、這一筆與累計。
耗時的毫秒數每次不同,上面只是某一次的結果。最後的 60 是回傳值。
debugger 被註解,所以不會暫停。取消註解且 DevTools 開著時,會停在那一行。
進階錯誤處理 這一節處理 try 與 catch 之外的三件事:收尾用的 finally、自己定義的錯誤類型,以及把錯誤用在輸入驗證。它們都建立在 08 教過的 try、catch 與 throw 之上。
finally finally 接在 catch 後面,這次有沒有出錯都會執行,適合把收尾工作集中放在一處。就算 try 或 catch 裡已經寫了 return,收尾仍會先跑完,值才交回呼叫端,所以 Console 會先看到收尾行,再看到回傳值。
觀念
有出錯或沒出錯,finally 都會執行。
return 不會跳過它:先執行 finally,才把值交出去。
04-js/pages/78-js-finally.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > finally</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function readScore (record ) { try { return record.score ; } catch (error) { console .log (error.name ); return null ; } finally { console .log ('讀取結束' ); } } console .log (readScore ({ score : 90 })); console .log (readScore (null )); </script > </body > </html >
解析
第一筆有分數,try 準備回傳 90,但會先印「讀取結束」,外面才印 90。
第二筆是 null,讀屬性時出錯,catch 印出 TypeError 並準備回傳 null,finally 仍先印收尾。
兩次呼叫都有收尾行,表示它不看這次有沒有出錯。
自訂錯誤 內建的 Error 可以再分出一種自己的錯誤類型,讓 catch 能分辨「驗證失敗」與「其他問題」。做法是宣告一個繼承 Error 的類別,並把 name 改成新名字。class 與 extends 是物件導向的語法,這裡只要照著示範的樣子寫即可。
觀念
新的錯誤類別繼承 Error,建構式先用 super 傳入訊息,再設定 this.name。
用 instanceof 判斷接到的是不是這個類別;其他錯誤仍是一般的 Error。
04-js/pages/80-js-custom-error.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 自訂錯誤</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > class ValidationError extends Error { constructor (message ) { super (message); this .name = 'ValidationError' ; } } function checkUser (user ) { if (!user) { throw new ValidationError ('資料不能為空' ); } if (!user.name ) { throw new ValidationError ('名稱不能為空' ); } if (user.age < 0 ) { throw new Error ('年齡不能為負數' ); } return user.name + ' 通過' ; } function run (user ) { try { console .log (checkUser (user)); } catch (error) { if (error instanceof ValidationError ) { console .log ('驗證' , error.name , error.message ); } else { console .log ('其他' , error.name , error.message ); } } } run ({ name : 'Amy' , age : 25 }); run (null ); run ({ age : 25 }); run ({ name : 'Amy' , age : -1 }); </script > </body > </html >
Amy 通過 驗證 ValidationError 資料不能為空 驗證 ValidationError 名稱不能為空 其他 Error 年齡不能為負數
解析
資料齊全時印出名稱與「通過」,沒有進入 catch。
null 與缺少名稱都丟出 ValidationError,前面標「驗證」,並印出 name 與 message。
年齡為負丟的是一般 Error,前面標「其他」,instanceof 讓這兩種走進不同的分支。
輸入驗證 輸入驗證是在使用資料之前先檢查它。把檢查獨立寫成一個函式:通過就回傳 true,不通過就主動丟錯;呼叫端只負責接住,成功與失敗都在同一個流程裡處理。不同的問題帶不同的 name 或 message,就能分辨是哪一關沒過。
觀念
檢查函式通過時回傳 true,不通過就 throw,自己不負責印錯誤。
型別不對丟 TypeError;空字串或格式不對丟一般的 Error,用 message 區分。
04-js/pages/81-js-validate.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 輸入驗證</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script > function validateEmail (email ) { if (typeof email !== 'string' ) { throw new TypeError ('電子郵件必須是字串' ); } if (email.length === 0 ) { throw new Error ('電子郵件不能為空' ); } if (!email.includes ('@' )) { throw new Error ('電子郵件格式不正確' ); } return true ; } function processEmail (email ) { try { validateEmail (email); console .log ('驗證成功' , email); } catch (error) { console .log (error.name ); console .log (error.message ); } } processEmail ('user@example.com' ); processEmail ('' ); processEmail ('invalid-email' ); processEmail (123 ); </script > </body > </html >
驗證成功 user@example.com Error 電子郵件不能為空 Error 電子郵件格式不正確 TypeError 電子郵件必須是字串
解析
含有 @ 的字串通過所有檢查,印出驗證成功與原信箱。
空字串與缺少 @ 都是 Error,兩句 message 不同;空字串在長度檢查就停住。
數字不是字串,name 是 TypeError。型別檢查先失敗,後面的檢查不會再跑,所以檢查的順序要由寬到細。
選讀:ES Module 程式變長之後,全部寫在同一支檔案會很難維護,名字也容易互相衝突。ES Module 是 ES2015 定下的模組標準:每支檔案有自己的作用域,需要分享的名字用 export 送出,另一支檔案再用 import 接進來。課程專案的 React 程式到處都是 import 與 export,但不理解這一章也能照著寫出 React,所以這裡只講必要的觀念:為什麼要拆檔、怎麼載入模組,以及具名與預設兩種匯出。
什麼是 ES Module 早期的頁面把好幾支 script 一路掛下去,它們共用頁面上的同一層名字。這一節說明這會帶來什麼問題、模組怎麼解決,以及瀏覽器載入模組時和一般 script 有哪些不同。
為什麼要拆檔 一支檔案塞滿資料與運算,改一個名字就要在很長的程式裡找;拆成多支檔案之後,每一支只負責一件事,容易閱讀也容易重複使用。
問題在於一般的 script 共用同一層名字。兩支檔案宣告了同名的 var 或函式,後載入的會蓋掉先載入的;宣告了同名的 const,則在載入時就會直接報錯。
模組解決了這個問題:每支模組檔都有自己的作用域,沒有 export 的名字留在檔案裡,別的檔案碰不到。要讓別人用,就明確送出;要使用別人的,就明確接進來,彼此的依賴一目了然。
載入模組 要把 JS 檔當成模組載入,script 標籤要加上 type=”module”,它和一般的 script 有三個差別。
預設延後執行(等同 defer):下載時不會擋住 HTML 的解析,等文件解析完才依出現的順序執行。
自動使用嚴格模式:例如沒有宣告就賦值會直接報錯。
必須透過伺服器載入:網址是 http 或 https 開頭才行。直接用檔案總管打開,網址是 file:// 開頭,在 Chrome 等瀏覽器裡模組會被 CORS 規則擋下,Console 出現類似 blocked by CORS policy 的錯誤;各家瀏覽器對 file:// 的限制不完全相同,但可靠的做法一律是用本機伺服器,例如 VS Code 的 Live Server 外掛,或之後專案用的 Vite 開發伺服器。
import 的路徑從這支檔自己算起 同一個資料夾裡的檔案要寫 ./ 開頭的相對路徑,並且帶上副檔名 .js。漏了其中一個,模組就載不進來,後面的程式也不會跑。(Vite 等打包工具允許省略副檔名,但瀏覽器直接載入時不行。)
匯出與匯入 export 把名字送出去,import 再把它接進來。匯出有兩種形式:具名匯出可以有很多個,匯入時名字要對得上;預設匯出每個檔案只有一個,匯入時可以自己取名。React 元件檔常常預設匯出一個元件,所以兩種都會看到。
先用一段註解把兩種形式對照在一起,下面兩小節再各自用完整的頁面示範:
export const a = 1 ;export const b = 2 ;import { a, b } from './x.js' ;export default function f ( ) {}import f from './x.js' ;
具名匯出與匯入 具名匯出就是在宣告前面加上 export,一支檔案可以有很多個。匯入的一方用大括號列出要用的名字,名字必須和匯出的一模一樣,對不上時 Console 會報錯。示範把陣列與函式放在資料檔,入口檔只負責匯入再印出結果。
觀念
資料檔用 export 送出名字;沒有 export 的 const 留在檔案內,其他檔案看不到。
入口檔的 import 路徑以它自己的位置為準,要寫 ./ 開頭與 .js 副檔名。
頁面只掛入口那一支 script,資料檔由 import 帶進來。
04-js/pages/82-js-module.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 具名匯出與匯入</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script type ="module" src ="82-js-module.js" > </script > </body > </html >
04-js/pages/82-js-module-data.js export const tours = [ { id : 1 , title : '台北城市漫遊' , place : '台北' , days : 3 , price : 12800 }, { id : 2 , title : '花蓮山海三日' , place : '花蓮' , days : 3 , price : 15900 }, { id : 3 , title : '京都紅葉散步' , place : '京都' , days : 5 , price : 42800 }, ]; export const filterByDays = (list, days ) => { return list.filter ((tour ) => tour.days === days); };
04-js/pages/82-js-module.js import { tours, filterByDays } from './82-js-module-data.js' ;const titles = filterByDays (tours, 3 ).map ((tour ) => tour.title );console .log (titles);console .log (tours.length );
解析
入口檔自己沒有寫陣列,資料與函式都是從資料檔接進來的。它留下天數等於 3 的兩筆,再取出標題。
資料檔匯出了三筆資料,所以長度是 3。
若改用 file:// 直接打開頁面,這兩支檔都不會執行,Console 只會看到載入被擋下的錯誤。
改名與整包匯入 大括號裡的 as 只改變這一支檔裡的名字,資料檔的匯出名字不變。星號寫法則把所有具名匯出收成一個物件,再用點記法取用。
import { filterByDays as byDays } from './82-js-module-data.js' ;import * as data from './82-js-module-data.js' ;console .log (byDays (data.tours , 3 ));
預設匯出 預設匯出用 export default,一支檔案最多只能有一個,寫第二個會在載入時報錯。匯入時不加大括號,名字由匯入的一方自己決定。檔案主要只提供一個函式或元件時適合用預設匯出;要同時交出好幾個平起平坐的名字時,用具名匯出,呼叫的人一看大括號就知道有哪些名字。兩種可以同時存在於同一支檔案。
觀念
預設匯入沒有大括號,名字可以自取,不必和原本的函式同名。
預設與具名同時匯入時,預設寫在前面,具名放進大括號。
04-js/pages/83-js-default.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 預設匯出</title > </head > <body > <p > 結果在 DevTools 的 Console。</p > <script type ="module" src ="83-js-default.js" > </script > </body > </html >
04-js/pages/83-js-price.js export default function formatPrice (price ) { return `NT$${price} ` ; } export const currency = 'TWD' ;
04-js/pages/83-js-default.js import formatPrice, { currency } from './83-js-price.js' ;console .log (formatPrice (12800 ));console .log (currency);
解析
formatPrice 是預設匯出,匯入時沒有大括號,名字是入口檔自己取的。
currency 是具名匯出,所以放在大括號裡,名字必須對得上。
第一行把 12800 嵌進模板字串,得到 NT$12800;第二行印出貨幣代碼 TWD。
React 元件檔常是這個形狀:預設匯出元件本身,其餘的常數或輔助函式用具名匯出。
回家作業 這份作業只用必教內容,資料取自專案的行程清單。起始檔已經放好八筆資料,不需要上網或安裝任何東西。課堂上不會批改,也不講解;每一題都附上完成後該看到的結果,可以自己對照。做完或卡住時,再看練習 repo 根目錄 homework/06-js-basics/ 裡的標準答案。
起始檔與資料 作業的起始檔在練習專案的 04-js/homework/06-homework.html,裡面已經宣告好陣列 tours,每一筆行程是一個物件,欄位有編號、標題、地區、主題、天數、價格、是否精選。只有部分行程多了 guide 欄位,記錄領隊姓名。把程式寫在標示的位置,結果都印到 Console。
04-js/homework/06-homework.html <!DOCTYPE html > <html lang ="zh-Hant" > <head > <meta charset ="UTF-8" /> <meta name ="viewport" content ="width=device-width, initial-scale=1.0" /> <title > 06 回家作業</title > </head > <body > <p > 結果在 DevTools 的 Console。把你的程式寫在資料下面。</p > <script > const tours = [ { id : 'taipei-beitou' , title : '台北大稻埕與北投溫泉三日' , region : '台北' , theme : '城市' , days : 3 , price : 18600 , featured : true , guide : { name : '阿凱' } }, { id : 'keelung-jiufen' , title : '基隆北海岸與九份兩日' , region : '基隆' , theme : '海岸' , days : 2 , price : 9200 , featured : false }, { id : 'hualien-taroko' , title : '花蓮太魯閣與七星潭四日' , region : '花蓮' , theme : '山海' , days : 4 , price : 26800 , featured : true , guide : { name : '小薇' } }, { id : 'taitung-chishang' , title : '台東池上與成功海岸三日' , region : '台東' , theme : '山海' , days : 3 , price : 21400 , featured : true }, { id : 'tainan-anping' , title : '台南府城與安平兩日' , region : '台南' , theme : '古都' , days : 2 , price : 8800 , featured : false }, { id : 'kaohsiung-qijin' , title : '高雄港都與旗津三日' , region : '高雄' , theme : '城市' , days : 3 , price : 14200 , featured : false }, { id : 'kinmen-villages' , title : '金門聚落與戰地三日' , region : '金門' , theme : '離島' , days : 3 , price : 16800 , featured : false }, { id : 'kyoto-nara' , title : '京都嵐山、伏見與奈良五日' , region : '京都' , theme : '日本' , days : 5 , price : 52800 , featured : true }, ]; </script > </body > </html >
題目 題目一:整理成一行文字 把每一筆行程整理成「標題|天數 天|NT$價格」的字串,放進新陣列,再逐行印出。原本的 tours 不能被改動。
完成後第一行應該是:
台北大稻埕與北投溫泉三日|3 天|NT$18600
題目二:精選行程由便宜到貴 找出精選的行程,依價格由低到高排序,只印出標題。排序時不能改動原本的 tours,也就是說印完這一題之後,tours 的順序仍然和起始檔相同。
完成後應該依序看到:
台北大稻埕與北投溫泉三日 台東池上與成功海岸三日 花蓮太魯閣與七星潭四日 京都嵐山、伏見與奈良五日
題目三:三天以上最便宜的三個地區 只看天數至少 3 天的行程,由便宜到貴找出前三筆,印出地區與價格。排序同樣不能改動原本的 tours。
完成後應該看到:
題目四:每種主題有幾筆行程 用陣列的累計方法,把行程依主題統計成一個物件,鍵是主題、值是筆數,最後印出這個物件。
完成後應該看到:
{ 城市: 2, 海岸: 1, 山海: 2, 古都: 1, 離島: 1, 日本: 1 }
題目五:領隊姓名與預設值 為每一筆行程印出領隊姓名。沒有安排領隊的行程要顯示「尚未安排」。使用可選串連與空值合併,不要用 if 判斷。
完成後八行依序是:阿凱、尚未安排、小薇,之後五行都是尚未安排。
題目六:調整價格,原資料不動 寫一個函式,接收行程陣列、行程編號與新的價格,回傳一份新的陣列:只有該編號的行程價格被換掉,其他行程原封不動。用展開與陣列方法完成,不要直接修改傳進來的陣列或物件。
用 taitung-chishang 與 19800 呼叫之後,請確認兩件事:新陣列裡那一筆的價格是 19800,而原本的 tours 裡仍然是 21400。
本篇重點回顧 標題帶「選讀」的章節(閉包、Set、Map、this、Math 與 Date、錯誤處理、ES Module)可以先跳過,之後需要時再回來查。
JavaScript 負責網頁的行為,標準名稱是 ECMAScript,本課使用 ES6 之後的現代寫法,並在 Console 觀察結果。
變數預設用 const,需要重新賦值才用 let;const 鎖住的是綁定,物件與陣列的內容仍可修改。
字串方法一律回傳新字串,不會改動原值;要把變數嵌進句子,用模板字串。
比較用嚴格相等,空值給預設值用 ??,多個固定選項的對照用 switch,重複的工作用 for。
函式用參數接收資料、用 return 交回結果;箭頭函式常拿來當作傳給其他函式的回呼。
陣列方法要先分清楚「會改動原陣列」和「回傳新結果」,map、filter、find、reduce 是之後處理列表資料的主力。
物件用欄位名稱對應到值,可能不存在的欄位用可選串連 ?. 讀取。
解構把陣列或物件的值拆成變數,展開用來複製與合併;更新資料時不改原物件,而是複製後改一個欄位。
上網查這篇的說法時,用括號裡的英文當關鍵字。
專有名詞中英對照 認識 JavaScript
執行環境(runtime)
內嵌(inline script)
註解(comment)
文件物件模型(DOM)
相對路徑(relative path)
變數與資料型別
變數(variable)
字串(string)
資料型別(data type)
數字(number)
常數(constant)
宣告(declaration)
保留字(reserved word)
小駝峰(camelCase)
大駝峰(PascalCase)
全大寫(UPPER_SNAKE_CASE)
布林(boolean)
賦值(assignment)
全域(global)
區塊作用域(block scope)
綁定(binding)
型別轉換(type conversion)
整數(integer)
小數(floating-point number)
字串
方法(method)
字元(character)
索引(index)
模板字串(template literal)
原型(prototype)
不可變(immutable)
字面值(literal)
插值(interpolation)
跳脫(escape)
屬性(property)
運算子與流程控制
迴圈(loop)
嚴格相等(strict equality)
真值(truthy)
假值(falsy)
運算子(operator)
條件判斷(conditional statement)
邏輯運算子(logical operator)
條件運算子(conditional operator)
空值合併(nullish coalescing)
算術運算子(arithmetic operator)
賦值運算子(assignment operator)
比較運算子(comparison operator)
短路求值(short-circuit evaluation)
預設值(default value)
三元運算子(ternary operator)
計數器(counter)
巢狀迴圈(nested loop)
無限迴圈(infinite loop)
函式
函式(function)
箭頭函式(arrow function)
呼叫(function call)
回傳值(return value)
參數(parameter)
引數(argument)
基本型別(primitive)
副作用(side effect)
預設參數(default parameter)
其餘參數(rest parameter)
函式表達式(function expression)
匿名函式(anonymous function)
宣告提升(hoisting)
隱式回傳(implicit return)
閉包(closure)
詞法作用域(lexical scope)
陣列
陣列(array)
參考(reference)
回呼(callback)
嚴格模式(strict mode)
累計(accumulator)
方法串接(method chaining)
物件
物件(object)
物件字面值(object literal)
靜態方法(static method)
可選串連(optional chaining)
點記法(dot notation)
識別字(identifier)
屬性簡寫(shorthand property)
選讀:內建物件
內建物件(built-in object)
四捨五入(rounding)
亂數(random number)
時區(time zone)
時間戳記(Unix timestamp)
協調世界時(UTC)
時差(time zone offset)
本地時間(local time)
解構與展開
展開運算子(spread syntax)
解構賦值(destructuring assignment)
不可變更新(immutable update)
淺拷貝(shallow copy)
深層複製(deep clone)
選讀:錯誤處理
除錯(debugging)
堆疊追蹤(stack trace)
自訂錯誤(custom error)
語法錯誤(syntax error)
錯誤物件(error object)
執行期錯誤(runtime error)
選讀:ES Module
模組(module)
匯出(export)
匯入(import)
具名匯出(named export)
預設匯出(default export)