【 Python x JS 】雙刀流

基本型別

文字的世界： 字串 (String)

在這裡，我們探討了 Python 和 JavaScript 中的字串（String）型別。字串是程式語言中的基本概念，用於存儲和操作文本資料。雖然 Python 和 JavaScript 在語法上有所不同，但它們對字串的處理方式有許多相似之處。

Python 中的字串 (str)

• 在 Python 中，字串是由單引號 ('') 或雙引號 (" ") 包圍的一系列字符。
• 字串是不可變的，這意味著一旦建立，字串的內容就不能被修改。
• 字串型別在 Python 中用 str 表示。

Python 程式碼範例

my_str = "Hello, World!"
print(my_str)  # 輸出: Hello, World!
print(type(my_str))  # 輸出: <class 'str'>

JavaScript 中的字串 (string)

• 與 Python 類似，JavaScript 中的字串也是由單引號、雙引號，或反引號（用於模板字串）包圍的字符序列。
• JavaScript 的字串同樣是不可變的。
• 字串型別在 JavaScript 中用 string 表示。

JavaScript 程式碼範例

let myString = "Hello, World!";
console.log(myString);  // 輸出: Hello, World!
console.log(typeof myString);  // 輸出: 'string'

綜合比較

• 在 Python 和 JavaScript 中，字串用來表示文本資料。
• 兩種語言中，字串的操作和處理方法類似，提供了許多內建的方法來檢查、處理和操作字串。
• 字串在這兩種語言中都是不可變的，一旦建立，其內容就不能被修改。

數字的世界：int、float、Number、BigInt

在這個例子中，我們探討了 Python 和 JavaScript 中的數字型別，包括整數 (int), 浮點數 (float), 數字 (Number), 大整數 (BigInt)。每種語言對這些型別的處理方式有所不同。

Python 的數字型別

整數 (int)

• 代表整數，沒有小數部分。
• 例如：my_int = 10。

浮點數 (float)

• 代表帶有小數的數字。
• 例如：my_float = 10.5。

Python 程式碼範例：

my_int = 10
my_float = 10.5
print(my_int, my_float)  # 輸出: 10 10.5
print(type(my_int), type(my_float))  # 輸出: <class 'int'> <class 'float'>

JavaScript 的數字型別

數字 (Number)

當在 JavaScript 中使用 Number 型別時，可以表示整數和浮點數。JavaScript 不區分整數和浮點數，所有數字都被視為 Number 型別。以下是一些示範：

以下是加上程式碼突顯的版本：

1. 整數

let integerNumber = 42;
console.log(integerNumber); // 42
console.log(typeof integerNumber); // 'number'

在這個範例中，我們宣告了一個整數變數 integerNumber，並賦予它值 42。我們使用 console.log 來輸出它的值，結果是 42，同時我們使用 typeof 來確認它的型別，結果是 'number'。

2. 浮點數

let floatingPointNumber = 3.14;
console.log(floatingPointNumber); // 3.14
console.log(typeof floatingPointNumber); // 'number'

這裡我們宣告了一個浮點數變數 floatingPointNumber，賦予它值 3.14。同樣地，我們使用 console.log 輸出它的值（3.14），並使用 typeof 確認它的型別為 'number'。

3. 整數和浮點數都是 Number

let combinedNumber = 100.0;
console.log(combinedNumber); // 100
console.log(typeof combinedNumber); // 'number'

這個範例中，我們宣告了一個數字變數 combinedNumber，它的值是 100.0。儘管它包含小數點，但 JavaScript 仍然將其視為 'number' 型別。我們輸出了它的值（100）以及型別（'number'）。

4. 數字運算

let result = integerNumber + floatingPointNumber; // 整數和浮點數相加
console.log(result); // 45.14
console.log(typeof result); // 'number'

最後，我們執行了一個數字運算，將整數和浮點數相加，並將結果存儲在 result 變數中。結果 result 包含了計算的結果（45.14），同樣它的型別仍然是 'number'。

在上述示範中，我們展示了 JavaScript 中的數字 (Number) 型別的用法。無論是整數還是浮點數，它們都被視為 Number 型別。你可以進行數學運算，包括整數和浮點數之間的運算。 JavaScript 會自動處理型別轉換，使得整數和浮點數之間的運算成為可能。

大整數 (BigInt)

當使用 Number 型別來表示太大的數字時，會出現數值精度丟失或溢出的情況。以下是一個示範，展示了使用 Number 表示超出範圍的數字時會出現的問題。

let largeNumber = 1234567890123456789012345678901234567890;

console.log(largeNumber);           // 正確顯示數字
console.log(largeNumber + 1);       // 結果不正確，精度丟失
console.log(largeNumber - 1234567890); // 結果不正確，精度丟失
console.log(largeNumber * 2);       // 結果不正確，溢出
console.log(largeNumber / 3);       // 結果不正確，精度丟失

在這個示範中，largeNumber 是一個非常大的整數，超出了 Number 型別的表示範圍，因此在進行數學運算時會出現精度丟失或溢出的問題。

為了解決這些問題，你可以使用 BigInt 型別，如下所示：

let largeBigInt = 1234567890123456789012345678901234567890n;

console.log(largeBigInt);           // 正確顯示大整數
console.log(largeBigInt + 1n);       // 正確計算，不會精度丟失
console.log(largeBigInt - 1234567890n); // 正確計算，不會精度丟失
console.log(largeBigInt * 2n);       // 正確計算，不會溢出
console.log(largeBigInt / 3n);       // 正確計算，不會精度丟失

使用 BigInt 型別可以保持數值的精確度，並且不會出現溢出或精度丟失的問題，特別適用於處理非常大的整數。

綜合比較

• 在 Python 中，整數和浮點數是分開的型別，分別由 int 和 float 表示。
• 在 JavaScript 中，Number 既可以是整數也可以是浮點數，而 BigInt 是一種特殊的型別，用於處理極大的整數。

是非對錯：布林值 (Boolean)

布林值就像是開關，只有「開」（True）和「關」（False）兩種狀態。這在 Python 和 JavaScript 中都一樣。

Python

my_bool = True
print(my_bool)  # True
print(type(my_bool))  # <class 'bool'>

JavaScript

let myBoolean = true;
console.log(myBoolean);  // true
console.log(typeof myBoolean);  // 'boolean'

以下是詳細的操作方式：

Python 的布林值 (bool)

在 Python 中，布林值用 bool 這個資料型別來表示。Python 的布林值有兩個可能的值：True 和 False。以下是範例：

定義布林變數

my_bool = True
print(my_bool)  # True
print(type(my_bool))  # <class 'bool'>

使用布林運算

result = 5 > 3  # 5 大於 3，結果是 True
print(result)  # True

布林運算

and_result = True and False  # and 運算，結果是 False
or_result = True or False    # or 運算，結果是 True
not_result = not True       # not 運算，結果是 False

JavaScript 的布林值 (Boolean)

在 JavaScript 中，布林值用 Boolean 這個資料型別來表示。JavaScript 的布林值同樣有兩個可能的值：true 和 false。以下是範例：

定義布林變數

let myBoolean = true;
console.log(myBoolean);  // true
console.log(typeof myBoolean);  // 'boolean'

使用布林運算

let result = 5 > 3;  // 5 大於 3，結果是 true
console.log(result);  // true

布林運算

let andResult = true && false;  // and 運算，結果是 false
let orResult = true || false;    // or 運算，結果是 true
let notResult = !true;    // not 運算，結果是 false

布林值通常用於控制流程、判斷條件、邏輯運算和其他需要表示真假的情況。無論是在 Python 還是 JavaScript 中，布林值都是程式中非常重要的資料型別之一。

空空如也：None, null, undefined

Python 中的「None」

在 Python 中，None 是一個特殊的型別，用於表示「什麼都沒有」或缺少值的情況。它通常用來初始化變數，或者作為函式的返回值，以表明沒有有效的返回值。

以下是用 Python 程式碼說明這兩個範例的用處：

初始化變數

my_none = None
print(my_none)  # None

在這個範例中，我們將變數 my_none 設置為 None，這表示這個變數目前沒有任何值或資料。這在程式中的一些情況下很有用，例如當你希望在稍後的程式中為變數指派值，但還不知道初始值是什麼時。使用 None 來初始化變數可以讓你明確地表示變數的未定義狀態。

函式的返回值

def find_element(arr, target):
    for element in arr:
        if element == target:
            return element
    return None  # 如果找不到目標元素，返回 None

在這個範例中，我們定義了一個名為 find_element 的函式，該函式接受一個陣列 arr 和一個目標值 target 作為參數。函式的用處是在陣列中尋找目標值，如果找到目標值，則返回該值；如果在整個陣列中找不到目標值，則返回 None。這種設計允許函式明確地指示特殊情況，即目標值不存在於陣列中。在呼叫這個函式後，你可以檢查返回值是否為 None，以確定是否找到了目標元素。

總之，None 在這兩個情況下都用於表示缺少值或未定義的情況，以提供程式碼中的明確性和處理特殊情況的能力。

JavaScript 中的「null」和「undefined」

在 JavaScript 中，有兩個值用來表示「空」的狀態，分別是 null 和 undefined。

null：這裡什麼都沒有

它通常是由程式開發者明確賦值的，用來表示變數目前沒有有效的值。

let myNull = null;
console.log(myNull);  // null

undefined：變數存在，但尚未定義

undefined：表示變數或屬性存在，但尚未賦值，或者尚未被定義。它通常是變數被聲明但未賦值時的默認值。

let myUndefined;
console.log(myUndefined);  // undefined

在上述範例中，我們分別展示了 null 和 undefined 的使用方式。它們用來表示不同的情況，但都代表著某種形式的「空」。在不同的程式語言中，有不同的方式來表達「空」或缺少值的狀態，這些方式在特定情況下很有用，可以幫助程式開發者處理不同的情況。

運算子

Python 和 JavaScript 運算子的通用寫法

基本算術運算子

1. Python:

   a = 5 + 3  # 加法，結果為 8
   b = 5 - 3  # 減法，結果為 2
   c = 5 * 3  # 乘法，結果為 15
   d = 5 / 2  # 除法，結果為 2.5
   e = 5 % 2  # 取餘，結果為 1

   這些基本算術運算子在 Python 中與數學中的使用方式相同。你可以使用加法（+）、減法（-）、乘法（*）、除法（/）和取餘（%）來進行數值計算。

2. JavaScript:

   let a = 5 + 3;  // 加法，結果為 8
   let b = 5 - 3;  // 減法，結果為 2
   let c = 5 * 3;  // 乘法，結果為 15
   let d = 5 / 2;  // 除法，結果為 2.5
   let e = 5 % 2;  // 取餘，結果為 1

   在 JavaScript 中，這些基本算術運算子的使用方式與 Python 相似。你可以使用加法（+）、減法（-）、乘法（*）、除法（/）和取餘（%）來執行數值運算。

比較運算子

1. Python:

   print(5> 3)   # True
   print(5 < 3)   # False
   print(5>= 5)  # True
   print(5 <= 4)  # False

   在 Python 中，比較運算子（大於、小於、大於等於、小於等於）用於比較數值，並返回布林值（True 或 False）。

2. JavaScript:

   console.log(5> 3);   // true
   console.log(5 < 3);   // false
   console.log(5>= 5);  // true
   console.log(5 <= 4);  // false

   在 JavaScript 中，比較運算子的使用方式與 Python 相似。它們也用於比較數值，並返回布林值。

賦值運算子

1. Python:

   x = 10        # 賦值
   x += 5        # x = x + 5
   x -= 3        # x = x - 3
   x *= 2        # x = x * 2
   x /= 4        # x = x / 4

   在 Python 中，賦值運算子（+=、-=、*=、/=）用於更新變數的值。它們可以實現簡潔的變數更新操作。

2. JavaScript:

   let x = 10;   // 賦值
   x += 5;       // x = x + 5
   x -= 3;       // x = x - 3
   x *= 2;       // x = x * 2
   x /= 4;       // x = x / 4

   在 JavaScript 中，賦值運算子的使用方式也與 Python 相似。它們用於更新變數的值。

邏輯運算子

1. Python:

   a = True and False  # False
   b = True or False   # True
   c = not True        # False

   在 Python 中，邏輯運算子（and、or、not）用於執行布林邏輯操作。它們可以用於組合和改變布林值。

2. JavaScript:

   let a = true && false;  // false
   let b = true || false;  // true
   let c = !true;          // false

   在 JavaScript 中，邏輯運算子的使用方式也與 Python 相似。它們用於執行布林邏輯操作。

位元運算子

1. Python:

   a = 5 & 3   # 位元 AND，結果為 1
   b = 5 | 3   # 位元 OR，結果為 7
   c = 5 ^ 3   # 位元 XOR，結果為 6
   d = ~5      # 位元非，結果為 -6
   e = 5 << 1  # 左移，結果為 10
   f = 5 >> 1  # 右移，結果為 2

   在 Python 中，位元運算子（位元 AND、位元 OR、位元 XOR、位元非、左移、右移）用於執行位元級別的操作。

2. JavaScript:

   let a = 5 & 3;   // 位元 AND，結果為 1
   let b = 5 | 3;   // 位元 OR，結果為 7
   let c = 5 ^ 3;   // 位元 XOR，結果為 6
   let d = ~5;      // 位元非，結果為 -6
   let e = 5 << 1;  // 左移，結果為 10
   let f = 5 >> 1;  // 右移，結果為 2

   在 JavaScript 中，位元運算子的使用方式也與 Python 相似。它們用於執行位元級別的操作，例如位元 AND、位元 OR 和位元 XOR。

這些範例展示了 Python 和 JavaScript 在基本運算子的使用上的相似之處，讓你更清楚地了解它們之間的相似性和差異。

運算說明

好的，我將逐步解釋每個二進位運算，並以 Markdown 表格的形式輸出。

1. 位元 AND (&):

• 5 的二進位表示是 0101。
• 3 的二進位表示是 0011。
• 位元 AND 運算後，只有兩個相應的位都是 1 時，結果位才是 1。因此 0101 & 0011 結果是 0001，即 1。

2. 位元 OR (|):

• 5 的二進位表示是 0101。
• 3 的二進位表示是 0011。
• 位元 OR 運算後，如果兩個相應的位中有任何一個是 1，則結果位是 1。因此 0101 | 0011 結果是 0111，即 7。

3. 位元 XOR (^):

• 5 的二進位表示是 0101。
• 3 的二進位表示是 0011。
• 位元 XOR 運算後，只有兩個相應的位不同時，結果位才是 1。因此 0101 ^ 0011 結果是 0110，即 6。

4. 位元 NOT (~):

• 5 的二進位表示是 0101。
• 位元 NOT 運算後，所有位的 0 和 1 互換，並且在最前面加上一個符號位（對於正數是 0，對於負數是 1）。~0101 變成 1010（二進位補碼表示），即 -6。

5. 左移 (<<):

• 5 的二進位表示是 0101。
• 左移一位意味著將所有位向左移動一位，右邊補 0。0101 左移一位變成 1010，即 10。

6. 右移 (>>):

• 5 的二進位表示是 0101。
• 右移一位意味著將所有位向右移動一位，左邊補上原本最左邊的位（在這裡是 0）。0101 右移一位變成 0010，即 2。

以下是對應的表格

運算	表達式	二進位運算	結果
位元 AND	5 & 3	0101 & 0011 = 0001	1
位元 OR	5	3	0101
位元 XOR	5 ^ 3	0101 ^ 0011 = 0110	6
位元 NOT	~5	~0101 = 1010 (二進位補碼)	-6
左移	5 << 1	0101 << 1 = 1010	10
右移	5 >> 1	0101 >> 1 = 0010	2

Python 和 JavaScript 運算子的不同之處

嚴格等於運算子

• JavaScript:

  console.log(1 == "1");   // true - 僅比較值
  console.log(1 === "1");  // false - 比較值和類型

  在 JavaScript 中，== 運算子比較兩個值，而 === 運算子不僅比較值還比較數據類型。因此，1 == "1" 返回 true，因為它們的值相等，但數據類型不同，而 1 === "1" 返回 false，因為它們的數據類型不同。

整數除法和冪運算

• Python:

  a = 10 // 3  # 整數除法，結果為 3
  b = 2  3   # 冪運算，結果為 8

  在 Python 中，// 運算子執行整數除法，返回整數結果。`` 運算子用於計算冪，即指數運算。

• JavaScript:

  let a = Math.floor(10 / 3); // 整數除法的模擬，結果為 3
  let b = 2  3;             // 冪運算，結果為 8

  在 JavaScript 中，沒有專門的整數除法運算子，因此我們使用 Math.floor() 函數來模擬整數除法。`` 運算子用於計算冪，與 Python 中的操作相同。

三元運算子

• Python:

  condition = True
  result = "Yes" if condition else "No"

  在 Python 中，我們可以使用三元運算子 condition ? value_if_true : value_if_false 來根據條件選擇不同的值。

• JavaScript:

  let condition = true;
  let result = condition ? "Yes" : "No";

  在 JavaScript 中，三元運算子的語法與 Python 相同，用於根據條件選擇不同的值。

邏輯運算子的語法

• Python:

  a = True and False  # False
  b = True or False   # True
  c = not True        # False

  在 Python 中，邏輯運算子（and、or、not）用於執行布林邏輯操作，其語法比較直觀。

• JavaScript:

  let a = true && false;  // false
  let b = true || false;  // true
  let c = !true;          // false

  在 JavaScript 中，邏輯運算子的語法也與 Python 相似，用於執行布林邏輯操作。

特殊運算子

• Python (海象運算子):

  if (n := 10) > 5:
      print("Greater than 5")  # n 在這裡被賦值為 10

  在 Python 中，使用海象運算子（:=）可以同時賦值和比較。這是 Python 3.8+ 中的新特性。

• JavaScript (類型運算子, 實例運算子, 空值合併運算子):

  console.log(typeof "Hello");  // "string"
  console.log("Hello" instanceof String);  // false
  let name = null;
  let displayName = name ?? "Anonymous";
  console.log(displayName);  // "Anonymous"

  在 JavaScript 中，我們使用 typeof 運算子來獲得變數或值的數據類型。instanceof 運算子用於檢查對象是否是指定類型的實例。?? 運算子用於提供默認值，如果左邊的值為 null 或 undefined，則使用右邊的值。

位元運算的差異

• JavaScript (無符號右移運算子):

  let a = -8 >>> 1;  // 將 -8 視為無符號整數進行右移，結果為 2147483644

  在 JavaScript 中，存在無符號右移運算子 >>>，它將數字視為無符號整數進行右移。這是 Python 中不具備的位元運算功能。

這些範例突顯了 Python 和 JavaScript 在運算子使用上的一些重要差異，這些差異反映了它們各自的語言特性和設計理念。瞭解這些差異對於有效地使用這兩種語言來進行編程是很重要的。

資料結構

多彩多姿的集合： 列表 (List) 和 陣列 (Array)

在 Python 的世界裡，我們有個叫列表 list 的東西。它就像一個大胃王，什麼都能吞。數字、字串、甚至是小數，都能裝進去。嗯，我們來看看 my_list 是不是真的這麼厲害：

my_list = [1, "hello", 3.14]
print(my_list)  # [1, 'hello', 3.14]
print(type(my_list))  # <class 'list'>

在 JavaScript 的宇宙中，陣列 Array 就是這個角色。它也能存放各種各樣的元素。讓我們看看 myArray 是不是也一樣多才多藝。

let myArray = [1, "hello", 3.14];
console.log(myArray);  // [1, 'hello', 3.14]
console.log(typeof myArray);  // 'object'

Python 中的列表 (List)

列表是一種有序的集合，它可以容納不同類型的元素，包括整數、字串、小數等。以下是列表的主要特點和使用方式。

建立列表

my_list = [1, "hello", 3.14]

在這個範例中，我們建立了一個名為 my_list 的列表，其中包含了整數、字串和浮點數。

存取列表元素

print(my_list[0])  # 存取第一個元素，結果是 1
print(my_list[1])  # 存取第二個元素，結果是 "hello"

你可以使用索引來存取列表中的元素，索引從 0 開始計數。

加入元素

my_list.append(42)  # 在列表末尾加入一個新元素 42

使用 append 方法可以在列表的末尾加入新的元素。

刪除元素

del my_list[1]  # 刪除第二個元素，my_list 變為 [1, 3.14]

你可以使用 del 關鍵字來刪除列表中的元素。

列表長度

length = len(my_list)  # 獲得列表的長度，結果是 2

你可以使用 len 函式獲得列表的長度。

JavaScript 中的陣列 (Array)

陣列也是一種有序的集合，它和 Python 的列表在概念上相似，但在使用上有些許不同。以下是陣列的主要特點和使用方式：

建立陣列

let myArray = [1, "hello", 3.14];

在這個範例中，我們建立了一個名為 myArray 的陣列，其中包含了整數、字串和浮點數。

存取陣列元素

console.log(myArray[0]);  // 存取第一個元素，結果是 1
console.log(myArray[1]);  // 存取第二個元素，結果是 "hello"

你同樣可以使用索引來存取陣列中的元素，索引也是從 0 開始計數。

加入元素

myArray.push(42);  // 在陣列末尾加入一個新元素 42

使用 push 方法可以在陣列的末尾加入新的元素。

刪除元素

myArray.splice(1, 1);  // 刪除第二個元素，myArray 變為 [1, 3.14]

你可以使用 splice 方法來刪除陣列中的元素。

陣列長度

let length = myArray.length;  // 獲得陣列的長度，結果是 2

你可以使用 length 屬性獲得陣列的長度。

列表 (List) 和陣列 (Array) 都是用來存儲一系列元素的資料結構，它們在不同的程式語言中都具有類似的功能，但具體的使用方式和方法可能有所不同。無論你選擇使用哪種語言，都可以靈活地操作這些集合來處理資料。

鍵值對的魔法： 字典 (Dict) 和 物件 (Object)

Python 的 字典 就像一本魔法書，裡面用鍵和值的配對記錄了許多秘密。比如說，愛麗絲的年齡和名字：

my_dict = {"name": "Alice", "age": 30}
print(my_dict)  # {'name': 'Alice', 'age': 30}
print(type(my_dict))  # <class 'dict'>

而在 JavaScript 的世界，物件 是這樣的存在。它也保存著類似的秘密，只不過寫法有點不一樣。

let myObject = {name: "Alice", age: 30};
console.log(myObject);  // {name: 'Alice', age: 30}
console.log(typeof myObject);  // 'object'

Python 中的字典 (Dict)

字典是一種無序的集合，它使用鍵值對的方式來存儲資料，每個鍵都對應一個值。以下是字典的主要特點和使用方式：

建立字典

my_dict = {"name": "Alice", "age": 30}
print(my_dict)  # {'name': 'Alice', 'age': 30}
print(type(my_dict))  # <class 'dict'>

存取字典元素

name_value = my_dict["name"]  # 存取鍵為 "name" 的值
age_value = my_dict["age"]    # 存取鍵為 "age" 的值
print("Name:", name_value)  # Name: Alice
print("Age:", age_value)    # Age: 30

加入新的鍵值對

my_dict["city"] = "New York"  # 加入一個新的鍵值對
print(my_dict)  # {'name': 'Alice', 'age': 30, 'city': 'New York'}

刪除鍵值對

del my_dict["age"]  # 刪除鍵為 "age" 的鍵值對
print(my_dict)  # {'name': 'Alice', 'city': 'New York'}

字典的長度

length = len(my_dict)  # 獲得字典的長度，結果是 2
print(length)

JavaScript 中的物件 (Object)

物件也是一種無序的集合，它使用鍵值對的方式來存儲資料，每個鍵都對應一個值。以下是物件的主要特點和使用方式：

建立物件

let myObject = {name: "Alice", age: 30};
console.log(myObject);  // {name: 'Alice', age: 30}
console.log(typeof myObject);  // 'object'

存取物件元素

方法 1：用括號存取

let nameValue = myObject["name"];  // 存取鍵為 "name" 的值
let ageValue = myObject["age"];    // 存取鍵為 "age" 的值
console.log("Name:", nameValue);  // Name: Alice
console.log("Age:", ageValue);    // Age: 30

方法 2：用屬性存取

let nameValue = myObject.name;  // 存取鍵為 "name" 的值
let ageValue = myObject.age;    // 存取鍵為 "age" 的值
console.log("Name:", nameValue);  // Name: Alice
console.log("Age:", ageValue);    // Age: 30

加入新的鍵值對

方法 1：括號用法

myObject["city"] = "New York";  // 使用 [] 加入一個新的鍵值對
console.log(myObject);  // {name: 'Alice', age: 30, city: 'New York'}

方法 2：物件屬性用法

myObject.city = "New York";  // 加入一個新的鍵值對
console.log(myObject);  // {name: 'Alice', age: 30, city: 'New York'}

刪除鍵值對

方法 1：括號用法

delete myObject["age"];  // 刪除鍵為 "age" 的鍵值對
console.log(myObject);  // {name: 'Alice', city: 'New York'}

方法 2：物件屬性用法

delete myObject.age;  // 刪除鍵為 "age" 的鍵值對
console.log(myObject);  // {name: 'Alice', city: 'New York'}

物件的屬性數量

let numProperties = Object.keys(myObject).length;  // 獲得物件的屬性數量，結果是 2
console.log(numProperties);

在每個範例中，我們都印出了結果，展示了字典 (Dict) 和物件 (Object) 的使用方法和操作的效果。

堅固小組： 元組 (Tuple)

在 Python 裡，tuple 就像是一個不能被改變的小組。一旦建立，就無法改變它的成員。來看看我們的 my_tuple

my_tuple = (1, "hello", 3.14)
print(my_tuple)  # (1, 'hello', 3.14)
print(type(my_tuple))  # <class 'tuple'>

JavaScript 則沒有這麼嚴格的小組，但我們可以用 Array 加上一些魔法（Object.freeze）來模擬這種不變性。

let myTuple = Object.freeze([1, "hello", 3.14]);
console.log(myTuple);  // [1, 'hello', 3.14]
console.log(typeof myTuple);  // 'object'

Python 元組（Tuple）

在 Python 中，元組是一種不可變的資料結構。這意味著一旦建立，就無法更改元組中的元素。這使得元組在某些場景中非常有用，特別是當你需要保證資料不被修改時。例如：

my_tuple = (1, "hello", 3.14)
print(my_tuple)  # (1, 'hello', 3.14)
print(type(my_tuple))  # <class 'tuple'>

# 嘗試修改元組，但會引發錯誤
try:
    my_tuple[0] = 42
except TypeError as e:
    print(f"Error: {e}")

1. 我們首先建立了一個名為 my_tuple 的元組，它包含了整數、字串和浮點數。
2. 然後，我們嘗試修改這個元組的第一個元素，但會引發 TypeError 錯誤，證明無法更改元組的成員。

在 JS 中模擬元組不變性

JavaScript 則沒有這麼嚴格的小組，但我們可以用 Array 加上一些魔法（Object.freeze）來模擬這種不變性。以下是範例，包括一個嘗試修改凍結的結構的例子：

let myTuple = Object.freeze([1, "hello", 3.14]);
console.log(myTuple);  // [1, 'hello', 3.14]
console.log(typeof myTuple);  // 'object'

// 嘗試修改凍結的結構，但不會成功
myTuple[0] = 42;
console.log(myTuple);  // [1, 'hello', 3.14]

1. 我們首先使用 Object.freeze 函數來凍結一個包含整數、字串和浮點數的陣列，以模擬元組的不變性。
2. 然後，我們嘗試修改這個凍結的陣列的第一個元素，但不會成功，並輸出了原始的內容，證明無法更改凍結的結構。

在這個 JavaScript 例子中，即使變數名稱是 myTuple，它實際上仍是一個陣列，只是被凍結以防止修改。這是模擬 Python 元組行為的一種方式，但需要注意的是，這個凍結的陣列在 JavaScript 中仍被視為一個對象，而非一個新的或特殊的資料類型。

獨一無二的 集合 (set)

Python 的 set 就像一個派對，但不允許重複的客人。每個元素都是獨一無二的。

guest_set = {"Alice", "Bob", "Charlie"}
print(guest_set)  # {'Alice', 'Bob', 'Charlie'}

# 嘗試加入重複的客人
guest_set.add("Bob")  # Bob 已經存在於集合中，不會重複加入
print(guest_set)  # {'Alice', 'Bob', 'Charlie'}

在 JavaScript 的派對（Set）也是這樣，不歡迎重複的客人。

let guestSet = new Set(["Alice", "Bob", "Charlie"]);
console.log(guestSet);  // Set(3) {'Alice', 'Bob', 'Charlie'}

// 嘗試加入重複的客人
guestSet.add("Bob");  // Bob 已經存在於集合中，不會重複加入
console.log(guestSet);  // Set(3) {'Alice', 'Bob', 'Charlie'}

大致了解 Set 的用途後，接著我們分別介紹 Python, JS 中 Set 的詳細用法。

Python 的 集合 (Set)

在 Python 中， 集合 (Set) 是一個無序的可變容器，它是由一組獨一無二的元素所組成的。這意味著集合中不允許有重複的元素，每個元素都是唯一的。你可以使用大括號 {} 或 set() 建立一個集合，然後將元素加入到集合中。以下是一些範例：

建立一個集合

my_set = {1, 2, 3}

增加元素到集合

my_set.add(4)

刪除元素

my_set.remove(2)

檢查元素是否存在

print(1 in my_set)  # True

遍歷集合

for item in my_set:
    print(item)

輸出集合及其類型

print(my_set)        # {1, 3, 4}
print(type(my_set))  # <class 'set'>

JavaScript 的 Set

在 JavaScript 中，Set 也是一個無序的集合，它用於存儲唯一的值。你可以使用 new Set() 構造函式建立一個 Set 對象，然後使用 add() 方法加入值。與 Python 不同的是，JavaScript 的 Set 是一個對象，而不是原始的資料類型。以下是一些範例：

建立一個 Set

let mySet = new Set([1, 2, 3]);

增加值到 Set

mySet.add(4);

刪除值

mySet.delete(2);

檢查值是否存在

console.log(mySet.has(1));  // true

遍歷 Set

mySet.forEach(item => {
    console.log(item);
});

輸出 Set 及其類型

console.log(mySet);            // Set(3) {1, 3, 4}
console.log(typeof mySet);      // 'object'

綜合比較

雖然 Python 的 集合 (Set) 和 JavaScript 的 Set 在功能上很相似，但要注意它們之間的一些差異：

1. 類型差異：Python 的 集合 (Set) 的類型是 set，而 JavaScript 的 Set 是一個對象。

2. 語法差異：Python 使用大括號 {} 定義集合，而 JavaScript 使用 new Set() 建立 Set 對象。

3. 遍歷方式：Python 使用 for item in my_set 遍歷集合，而 JavaScript 使用 forEach 方法。

儘管有這些差異，兩者的基本功能都是相同的，都可以用來儲存唯一的值，並進行相關操作。

流程控制 (一) 條件判斷

用餐廳點菜學 if-else

if-else 就像在一家餐廳點菜一樣。如果你有特定的食物喜好，比如大門口的餐廳有你喜歡的食物，你就走進去，否則你去下一家。

Python 中的 if-else

在 Python 中，if 與 else 語句的最後要加上冒號 :，符合條件判斷後的執行程式需要縮排。

food_preference = "披薩"
if food_preference == "壽司":
    print("我要壽司")
else:
    print("我找下一家餐廳")

JavaScript 中的 if-else

在 JavaScript 中，語法多了括號和分號，但不會嚴格限制縮排的空格。空格數量錯誤還是可以執行。

let restaurant = "義大利料理";
if (restaurant === "日本料理") {
    console.log("我想吃壽司。");
} else {
    console.log("讓我們試試下一家餐廳吧。");
}

不同的語法：elif 與 else if

重點比較 elif 在 Python 和 JavaScript 中的用法。

Python 中的 elif

# 假設你在餐廳，要決定今天吃什麼食物
food_preference = "披薩"

# 使用 elif 來進行多個條件的選擇
if food_preference == "壽司":
    print("我要壽司")
elif food_preference == "披薩":
    print("我要披薩")
else:
    print("我找下一家餐廳")

在 Python 中，elif 是一個關鍵字，用於在多個條件之間進行選擇。當第一個 if 條件不滿足時，Python 將檢查 elif 條件，如果其中一個為 True，則執行相對應的程式碼區塊。

JavaScript 中的 else if

// 假設你在餐廳，要決定今天吃什麼食物
let restaurant = "義大利料理";

// 使用 else if 來進行多個條件的選擇
if (restaurant === "日本料理") {
    console.log("我想吃壽司。");
} else if (restaurant === "義大利料理") {
    console.log("我想嘗試義大利料理。");
} else {
    console.log("讓我們試試下一家餐廳吧。");
}

在 JavaScript 中，我們使用 else if 來實現相同的功能。當第一個 if 條件不滿足時，JavaScript 將檢查 else if 條件，如果其中一個為 True，則執行相對應的程式碼區塊。在 JavaScript 中，你也可以連續使用多個 else if 來處理多個條件。

總之，無論是 elif（Python）還是 else if（JavaScript），它們都是用於處理多個條件的語言結構，允許根據不同情況執行不同的程式碼。這使得程式碼更具靈活性，可以應對多種不同的情況。如果有任何其他疑問或需要更多詳細訊息，請隨時提出。

用服飾風格學 switch-case

我們要示範的題目是「在試衣間試穿不同風格的服裝時，可根據喜好選擇服裝風格。」，在有多個選項的情況下，使用 switch-case 比起 if-else 具有更高的可讀性。

在 Python 使用 match-case 或是 if-else

3.10 以前，使用 if-else 來模擬 switch-case

在 Python 3.10 以前的版本沒有 switch-case 語句可以用，只能用 if-else。

outfit_style = "casual"
outfit = ""

if outfit_style == "formal":
    outfit = "西裝筆挺"
elif outfit_style == "casual":
    outfit = "牛仔褲和 T 恤"
elif outfit_style == "athletic":
    outfit = "運動裝"
else:
    outfit = "不知道穿什麼"

print(outfit)

3.10 之後，使用 match-case

在 Python 3.10 及以後的版本中，引入了一個新的 match 語句，它提供了一種更強大且具有結構化的條件匹配方式。以下是對上面範例程式碼的詳細說明：

# 假設你想要根據天氣選擇適當的衣服
weather = "晴朗"

# 使用 match 語句來選擇衣服
outfit = match weather:
    case "雨天":
        "雨衣和雨靴"
    case "晴朗":
        "短袖和短褲"
    case "寒冷":
        "外套和長褲"
    case _:
        "不知道穿什麼"

print(outfit)

在這個範例中，我們根據 weather 變數的值選擇適當的衣服。使用 match 語句，每個 case 都代表了一種天氣情況，並根據情況返回適當的衣服建議。不需要使用 break，因為 match 語句會自動處理分支的結束。

這個範例展示了 match 語句如何使程式碼更加結構化和易讀，並且減少了錯誤的發生。

在 JavaScript 中使用 switch 與 case

在 JavaScript 中則是早在 ECmathcript 第一版就加入了 switch case 的語法。switch-case 的語句也是比較典型的控制流程關鍵字。例如：Java 和 C 都是使用 switch-case 關鍵字。

let outfit_style = "casual";
let outfit;
switch (outfit_style) {
    case "formal":
        outfit = "西裝筆挺";
        break;
    case "casual":
        outfit = "牛仔褲和 T 恤";
        break;
    case "athletic":
        outfit = "運動裝";
        break;
    default:
        outfit = "不知道穿什麼";
}
console.log(outfit);

使用 switch 語句時，如果不加入 break 會發生什麼事情

在 JavaScript 中，switch 語句中的 break 語句是可選的，但它對控制流程具有重要影響。如果省略了 break，則 switch 將繼續執行下一個 case 或 default 分支，直到遇到 break 或 switch 結束為止。

在你上一個範例的程式碼中，每個 case 後面都有 break，這是一種良好的實踐，因為它確保只有一個 case 被執行。

如果省略了這些 break，將發生 “穿透”（fall-through）效應，即使多個 case 條件都被匹配，所有符合條件的 case 以及後續的程式碼都將被執行。

例如，如果省略了 break：

let outfit_style = "casual";
let outfit;
switch (outfit_style) {
    case "formal":
        outfit = "西裝筆挺";
        // 沒有 break，將穿透到下一個 case
    case "casual":
        outfit = "牛仔褲和 T 恤";
        // 再次沒有 break，將穿透到下一個 case
    case "athletic":
        outfit = "運動裝";
        // 再次沒有 break，將穿透到 default
    default:
        outfit = "不知道穿什麼";
}
console.log(outfit); // 最終輸出為 "不知道穿什麼"

在上面的例子中，由於缺少 break 語句，控制流程穿透到了下一個 case，直到 default。預期的答案 casual 應該對應的是「牛仔褲和 T 恤」，卻因為穿透效應，變成「不知道穿什麼」。

因此，為了確保每個 case 只執行一次，通常應在每個 case 的末尾加上 break。這有助於避免預期外的行為和錯誤。

流程控制 (二) 迴圈

For 迴圈：最萬用的迴圈

Python 的 For 迴圈

1. 目的 ：for 迴圈在 Python 中用於遍歷可迭代對象，這些對象可以是列表、元組、字串、字典等。它允許你逐個訪問這些對象的元素或元素的索引。

2. 語法結構 ：For 迴圈的基本結構如下：

   for 迴圈變數 in 可迭代對象:
       # 在這裡執行你的程式碼，這段程式碼會在每次迭代中執行

   • 迴圈變數：這是一個變數名稱，它在每次迭代中被賦值為可迭代對象中的當前元素。你可以自行命名這個變數。
   • 可迭代對象：這是你要遍歷的對象，可以是列表、元組、字串等。
   • 迴圈內的程式碼：這是在每次迭代中執行的程式碼，它必須使用縮排（縮進）表示，並且需要與 for 語句對齊。

3. 範例 ：讓我們使用購物清單的例子來說明：

   shopping_list = ["蘋果", "香蕉", "橙子", "葡萄"]
   for item in shopping_list:
       print("我要買", item)

   在這個例子中，item 是迴圈變數，它依次被賦值為購物清單中的每個項目，然後印出相應的訊息。

4. 遍歷範圍 ：For 迴圈也可以用於遍歷範圍（range），範圍是一個表示數字序列的可迭代對象。這對於執行一定次數的迭代非常有用。

   for i in range(5):
       print("迭代次數：", i)

   這個例子會執行 5 次迭代，分別印出 0 到 4 的數字。

Python 中的 for 迴圈用於遍歷各種可迭代對象，它為每次迭代提供一個變數，並在迴圈內部執行相關的程式碼。這使得處理序列資料變得非常方便。

JavaScript 的 For 迴圈

在 JavaScript 中的 for 迴圈就像一場比賽，你知道比賽有多長，並且你會根據比賽的距離一圈又一圈地跑。

let raceDistance = 10; // 10 圈比賽
for (let lap = 1; lap <= raceDistance; lap++) {
    console.log("我跑了第" + lap + "圈");
}

在 JavaScript 中的 for 迴圈是一個非常有用的工具，可以讓你重複執行指定次數的操作，就像一場比賽一樣。讓我們來更詳細地說明：

1. 初始化（Initialization）：在 for 迴圈的開始，你會設定一個初始值，這個值通常代表迴圈控制變數。在你的範例中，控制變數是 lap，初始值是 1，它代表你的比賽一開始的狀態。

2. 條件（Condition）：接下來，你會設定一個條件，只要這個條件為真，迴圈就會繼續運行。在你的程式碼中，條件是 lap <= raceDistance，這意味著只要 lap 的值小於或等於 raceDistance（比賽的總圈數），迴圈就會繼續執行。

3. 遞增 / 遞減語句（Increment / Decrement Statement）：在每一輪迴圈結束時，你會執行遞增（或遞減）語句，這通常用於改變控制變數的值，以便最終滿足條件不再為真。在你的範例中，你使用 lap++ 來將 lap 的值增加 1，表示你跑了一圈。

4. 迴圈體（LoopBody）：在迴圈的大括號 {} 內，你放置了希望重複執行的程式碼。在這裡，你使用 console.log 來顯示你跑了第幾圈。

所以，在你的 JavaScript 程式碼中，當迴圈開始運行時，控制變數 lap 的值從 1 開始，然後它滿足條件 lap <= raceDistance，因此迴圈繼續執行。在每一圈結束時，lap 的值都會增加 1，直到它不再滿足條件，那麼迴圈就結束了。這就像一場比賽，你知道你需要跑多少圈，然後一圈一圈地跑，直到完成比賽。

使用 For 迴圈遍歷陣列

使用 JavaScript 中的 for 迴圈來遍歷陣列（array）非常常見。以下是一個簡單的範例，展示如何使用 for 迴圈來遍歷陣列中的元素：

// 假設有一個陣列包含一些數字
const numbers = [1, 2, 3, 4, 5];

// 使用 for 迴圈遍歷陣列並輸出每個元素
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}

在這個範例中，我們首先定義了一個陣列 numbers，其中包含了一些數字。然後，我們使用 for 迴圈來遍歷這個陣列。for 迴圈的初始化部分（let i = 0）設定了一個計數器 i，然後設定了條件（i < numbers.length），只要條件成立，迴圈就會繼續執行。在每次迴圈迭代中，我們使用 console.log 來輸出陣列中的元素，並通過 i 來訪問元素的索引。

這樣，for 迴圈會遍歷陣列中的每個元素，並將其輸出到控制台。

While 迴圈：當條件符合，持續運作

Python 中的 while 迴圈

在 Python 中的 while 迴圈就像你等待公車一樣。你不知道公車什麼時候會到來，所以你一直檢查，只要公車到達，你就可以上車。

waiting_for_bus = True
while waiting_for_bus:
    print("等公車...")
    if bus_arrived:
        waiting_for_bus = False
print("上車了！")

• Python 中的 while 迴圈根據指定的條件表達式的真假來執行迴圈。
• 使用 while 關鍵字，並在 while 後指定條件表達式，只要條件為真，就會繼續執行迴圈。
• 迴圈體使用縮排表示，並在條件為假時退出。

JavaScript 中的 while 迴圈

在 JavaScript 中的 while 迴圈就像一個運動員進行訓練。他們一直在做重複的練習，直到達到一定的目標。

let trainingTime = 0;
let trainingGoal = 60; // 訓練 60 分鐘
while (trainingTime < trainingGoal) {
    console.log("練習中...");
    trainingTime += 10; // 每次增加 10 分鐘
}
console.log("訓練完成！");

• JavaScript 中的 while 迴圈也根據指定的條件表達式的真假來執行迴圈。
• 使用 while 關鍵字，並在 while 後指定條件表達式，只要條件為真，就會繼續執行迴圈。
• 迴圈體使用大括號 {} 表示，並在條件為假時退出。

Do While 迴圈：先做再說

Python 沒有 do while

在 Python 中沒有嚴格的 do while 迴圈，但我們可以模擬它，比如吃冰淇淋。你首先吃冰淇淋，然後檢查你是否還有口渴，如果是，就繼續吃冰淇淋。

ice_cream = 3
while ice_cream > 0:
    print("吃冰淇淋...")
    ice_cream -= 1
    if thirsty:
        break
print("吃完了！")

• Python 中沒有嚴格的 do while 迴圈，但可以使用 while True 來實現類似的功能，再加上 break 語句來控制退出條件。
• 使用 while 關鍵字建立一個無限循環，並在適當的時候使用 break 退出。

JavaScript 中的 do while

在 JavaScript 中的 do while 迴圈就像打電話給朋友，不管朋友是否接聽，你都要至少嘗試一次。

let attempts = 0;
do {
    console.log("打電話給朋友...");
    attempts++;
} while (attempts < 3);
console.log("不接聽了！");

• JavaScript 中的 do while 迴圈是一個至少執行一次的迴圈，然後根據指定的條件表達式決定是否繼續執行。
• 使用 do 關鍵字來開始迴圈，並在 while 後指定條件表達式。
• 迴圈體使用大括號 {} 表示，並在條件為假時退出。

這些比喻希望幫助你理解 Python 和 JavaScript 中的迴圈。無論你是在購物、比賽、等公車、訓練、吃冰淇淋還是打電話，迴圈是程式中一個強大且常見的控制結構，可以幫助你重複執行任務。

函式

發送問候：函式

在 Python 中使用函式

在 Python 的世界裡，一個函式 (function) 可以用來發送溫暖的問候。它會告訴你它的型態是個函式。以下是範例：

def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  # Hello, Alice!
print(type(greet))  # <class 'function'>

1. 我們首先定義了一個名為 greet 的函式，它接受一個名字作為參數。
2. 在函式內部，我們使用 f-string 將問候該名字的字串建立起來。
3. 然後，我們呼叫這個函式，將 “Alice” 作為參數傳遞給它，並輸出了函式的結果，也就是 “Hello, Alice!”。
4. 最後，我們輸出了 greet 函式本身的型態，這證明它確實是一個函式。

在 JavaScript 中使用函式

在 JavaScript 的國度中，一個函式 (function) 也能做同樣的事情。它也會自豪地告訴你它是一個函式。以下是範例：

function greet(name) {
    return `Hello, ${name}!`;
}

console.log(greet("Alice"));  // Hello, Alice!
console.log(typeof greet);  // 'function'

1. 我們首先定義了一個名為 greet 的函式，它同樣接受一個名字作為參數。
2. 在函式內部，我們使用模板字串 (template string) 將問候該名字的字串建立起來。
3. 然後，我們呼叫這個函式，將 “Alice” 作為參數傳遞給它，並輸出了函式的結果，也就是 “Hello, Alice!”。
4. 最後，我們輸出了 greet 函式本身的型態，這證明它確實是一個函式。

這兩個範例展示了如何在 Python 和 JavaScript 中使用函式和函式來實現相同的目標，即發送溫暖的問候。儘管語法和語言不同，但概念相似。

變身魔法：Python 列表推導式 vs JS 陣列方法

在 Python 中使用列表推導式

在 Python 中，列表推導式就像是個魔法師，可以把一個普通的數字列表變成它們的平方。以下是範例：

numbers = [1, 2, 3, 4, 5]
squared = [x ** 2 for x in numbers]
print(squared)  # [1, 4, 9, 16, 25]
print(type(squared))  # <class 'list'>

1. 我們首先定一個名為 numbers 的列表，其中包含數字 1 到 5。
2. 然後，我們使用列表推導的方法建立了一個名為 squared 的新列表，該列表包含了 numbers 中每個數字的平方。
3. 最後，我們輸出了 squared 列表的內容以及它的型態。

在 JavaScript 中使用 map 方法

在 JavaScript 中，map 方法也能做到相同的事，只不過它用的咒語聽起來不太一樣。以下是範例：

let numbers = [1, 2, 3, 4, 5];
let squared = numbers.map(x => x ** 2);
console.log(squared);  // [1, 4, 9, 16, 25]
console.log(typeof squared);  // 'object'

1. 我們首先定一個名為 numbers 的陣列，其中包含數字 1 到 5。
2. 然後，我們使用 map 方法，對 numbers 陣列中的每個元素應用一個函式，這個函式將每個元素取平方。
3. 最後，我們輸出了 squared 陣列的內容以及它的型態。

這兩個範例展示了如何在 Python 和 JavaScript 中以不同的方式實現相同的目標，即將一個數字列表轉換為它們的平方值。在 Python 中使用列表推導，而在 JavaScript 中使用 map 方法。

例外處理

Python

現在，讓我們轉向 Python 的例外處理。

你在一家餐廳點了一份特別的料理，但當廚師在烹飪過程中意外燒焦了食物。這就像 Python 中的例外情況。

try:
    # 可能引發例外的程式碼，就像料理過程
    result = 10 / 0  # 這裡的除以零就像食物燒焦
    print(result)  # 這一行實際上不會執行，就像你無法享受燒焦的料理
except ZeroDivisionError as e:
    # 例外處理區塊，就像處理燒焦的料理
    print('發生錯誤：', str(e))  # 這就像告訴廚師食物燒焦了
finally:
    # 最終執行的區塊，不管是否有錯誤都會執行，就像總是要結帳一樣
    print('不管是否有錯誤，這裡都會執行，就像總是要結帳')

在這個情境中，你期望享受美味的料理（try 區塊），但由於烹飪失敗（錯誤），你需要通知廚師（except 區塊）食物燒焦了，然後總是需要結帳（finally 區塊）。

JavaScript (JS)

想像你在一家餐廳點了一份蛋糕，但服務生在端上蛋糕的時候，意外地把蛋糕摔到地上。這就像 JavaScript 中的錯誤。

try {
  // 可能引發例外的程式碼，就像端蛋糕
  let result = 10 / 0; // 這裡的除以零就像摔蛋糕
  console.log(result); // 這一行實際上不會執行，就像你無法享用摔碎的蛋糕
} catch (error) {
  // 例外處理區塊，就像處理摔碎的蛋糕
  console.error('發生錯誤：' + error.message); // 這就像告訴服務生蛋糕摔壞了
} finally {
  // 最終執行的區塊，不管是否有錯誤都會執行，就像總是要結帳一樣
  console.log('不管是否有錯誤，這裡都會執行，就像總是要結帳');
}

在這個情境中，你嘗試享用蛋糕（try 區塊），但由於服務失誤（錯誤），你需要處理這個情況，告訴服務生（catch 區塊）蛋糕摔壞了，然後總是要完成結帳（finally 區塊）。

這兩個情境幫助我們理解 JavaScript 和 Python 中的例外處理，無論是在餐廳中處理料理或點心，還是在程式碼中處理錯誤，都需要適當的處理和最終的清理步驟。

綜合比較

在上面的例子中，我們可以比較 Python 和 JavaScript（JS）在例外處理方面的不同之處：

1. 語法不同 :

• Python: Python 使用 try...except 構造來處理例外情況，並使用 as 來指定錯誤的別名。這種語法相對簡潔。
• JavaScript: JavaScript 使用 try...catch 構造來處理錯誤，並在 catch 區塊中使用 error 變數來訪問錯誤物件的訊息。

2. 錯誤類型不同 :

• Python: 在 Python 中，每個錯誤都有特定的類型。在例子中，我們使用 ZeroDivisionError 來處理除以零的錯誤。
• JavaScript: JavaScript 的錯誤通常是通用的，並不總是有明確的錯誤類型。在例子中，我們只使用了通用的錯誤物件，而沒有指定特定的錯誤類型。

3. 訊息處理不同 :

• Python: 在 Python 中，我們使用 str(e) 來獲取錯誤物件 e 的訊息，並在 except 區塊中處理它。
• JavaScript: 在 JavaScript 中，我們使用 error.message 來獲取錯誤物件 error 的訊息，同樣在 catch 區塊中處理它。

4. 最終執行 :

• Python: Python 和 JavaScript 都支援 finally 區塊，用於確保無論是否有錯誤，某些程式碼都會執行。
• JavaScript: 在這兩種語言中，finally 區塊的功能是相似的，都用於執行清理程式碼。

結論
Python 和 JavaScript 在例外處理方面有一些語法上的不同，例如 try...except（Python）和 try...catch（JavaScript），以及錯誤類型的表示方式。然而，核心概念相似，都是用於處理程式運行時可能引發的錯誤，並提供一種方式來捕捉、處理和最終處理這些錯誤。

專有名詞對照表

專有名詞	Python	JavaScript
資料型別	整數 (int)	整數 (Number)
	浮點數 (float)	浮點數 (Number)
	布林 (bool)	布林 (Boolean)
	字串 (str)	字串 (String)
資料結構	列表 (list)	陣列 (Array)
	字典 (dictionary)	物件 (Object)
	元組 (tuple)
	集合 (set)	集合 (Set)
控制流程	條件語句 (if)	條件語句 (if)
	迴圈 (loop)	迴圈 (loop)
	while 迴圈	while 迴圈
	for 迴圈	for 迴圈
	switch 語句	switch 語句
	迴圈控制 (break, continue)	迴圈控制 (break, continue)
函式相關	參數 (parameter)	參數 (parameter)
	返回值 (return value)	返回值 (return value)
	自訂函數 (user-defined function)	自訂函數 (user-defined function)
	方法 (method)	方法 (method)
例外處理	例外處理 (try, except, finally)	例外處理 (try, catch, finally)
	斷言 (assert)	斷言 (assert)
	例外拋出 (raise)	例外拋出 (throw)
其他名詞	註釋 (comment)	註釋 (comment)
	變數 (variable)	變數 (variable)
	常數 (constant)	常數 (constant)
	運算符 (operator)	運算符 (operator)
		資料類型轉換 (type conversion)
		特殊值 NaN, Infinity