parseInt(0.0000005)

答案：5

parseInt(0.5); // -> 0
parseInt(0.05); // -> 0
parseInt(0.005); // -> 0
parseInt(0.0005); // -> 0
parseInt(0.00005); // -> 0
parseInt(0.000005); // -> 0
parseInt(0.0000005); // -> 5

parseInt 函數將其第一個參數轉換為字符串（如果它還不是字符串），然后再轉換為數字。當將 0.0000005 轉換為字符串時，會得到以下結果：

String(0.0000005); // -> "5e-7"

然后 parseInt 函數只取該字符串的第一個字符，即 5，并將其解析為一個數字。

[] == ![]

答案：true。

[] == ![] 之所以返回 true，是因為比較過程中發生了隱式的類型轉換。下面來逐步解析：

• [] 是一個空數組，它是真值。![] 是 false，因為當將空數組強制轉換為布爾值時，它變為 true，然后被否定為 false。因此，比較變成了 [] == false。
• 當比較不同類型時，JavaScript 將嘗試將一個或兩個值強制轉換為相同類型。在這種情況下，它將嘗試將數組強制轉換為原始值。
• 一個空數組，當被強制轉換為原始值時，變成了一個空字符串 ""。因此，表達式 [] == false 實際上變成了 "" == false。
• 現在，JavaScript 嘗試將布爾值 false 轉換為數字，即 0，表達式就變成了 "" == 0。
• 根據 JavaScript 的規則，當比較一個字符串和一個數字時，字符串將被強制轉換為數字。因此，"" 被強制轉換為數字后變成了 0。這時比較的就是 0 == 0，結果是 true。

NaN === NaN

答案：false。

在 JavaScript 中，NaN（Not a Number）是一個特殊的值，表示一個非數字的值。然而，當使用 ===（嚴格相等運算符）來比較 NaN 時，會出現一個特殊的情況：NaN 并不等于 NaN。具體來說，NaN === NaN 的結果是 false，盡管兩者都是 NaN。這是因為在 IEEE 754 浮點數標準中，NaN 被定義為不等于任何其他值，包括它自身。

要檢查一個值是否是 NaN，通常使用 isNaN() 函數，但請注意，isNaN() 對于非數字類型的參數（如字符串或對象）也可能返回 true，因為它會嘗試將這些參數轉換為數字。更嚴格的檢查方法是使用 Number.isNaN()，它只有在參數確實是 NaN 時才返回 true。

NaN === NaN // false  
isNaN(NaN);  // true，但這不是最佳方式  
Number.isNaN(NaN); // true，這是更好的方式

[1, 2] + [3, 4]

答案："1,23,4"。

在 JavaScript 中，當嘗試使用 + 運算符來連接兩個數組，實際上并不會執行數組的拼接或合并。相反，由于 + 運算符在 JavaScript 中既可以用作加法運算符（對于數字），也可以用作字符串連接運算符（對于字符串），因此數組會首先被轉換為字符串，然后再進行連接。

數組到字符串的轉換是通過調用數組的 toString() 方法實現的，這通常會生成一個由數組元素組成的逗號分隔的字符串。因此，[1, 2] 會被轉換為 "1,2"，而 [3, 4] 會被轉換為 "3,4"。然后，這兩個字符串會被 + 運算符連接起來，得到 "1,23,4"。所以，[1, 2] + [3, 4] 的結果是 "1,23,4"。

如果想要合并兩個數組，應該使用數組的 concat() 方法或擴展運算符如下所示：

• 使用 concat() 方法：

const result = [1, 2].concat([3, 4]); // [1, 2, 3, 4]

• 使用擴展運算符：

const result = [...[1, 2], ...[3, 4]]; // [1, 2, 3, 4]

typeof null

答案：object。

在 JavaScript 早期版本中，所有值都存儲在 32 位的單元中，每個單元包含一個小的 類型標簽(1-3 bits) 以及當前要存儲的數據。類型標簽共有五種類型：

000: object   - 數據類型為 對象。
  1: int      - 數據類型為 有符號整數。
010: double   - 數據類型為 雙精度的浮點數。
100: string   - 數據類型為 字符串。
110: boolean  - 數據類型為 布爾值。

null 的值是機器碼 NULL 指針（指針值是000），也就是說null的類型標簽也是 000，和object的類型標簽一樣，所以會被判定為object。

try...finally

答案：2

(() => {
  try {
    return 1;
  } finally {
    return 2;
  }
})();

在JavaScript中，當在一個函數（包括箭頭函數）的try塊和finally塊中都有return語句時，finally塊中的return語句會覆蓋try塊中的return語句。這是因為finally塊總是會被執行，無論try塊中的代碼是否成功執行，或者是否拋出了異常。而且，如果finally塊中有return語句，那么這個return語句將決定整個函數的返回值。

0.14 * 100

答案：14.000000000000002

0.13 * 100   // 13
0.14 * 100   // 14.000000000000002
0.15 * 100   // 15
0.16 * 100   // 16

在JavaScript中，所有的數字都是以 64 位浮點數形式存儲的，即使它們被聲明為整數。由于二進制無法精確表示所有的十進制小數，因此在進行浮點數運算時，可能會出現精度問題。由于在二進制浮點數表示中，0.14 不能精確表示，因此在進行乘法運算時會出現微小的舍入誤差。一個經典的問題就是 0.1 + 0.2 不等于 0.3。這兩個問題出現的原因是一樣的。

0.1 + 0.2 === 0.3  // false
0.1 + 0.5 === 0.6  // true

為了處理這種精度問題，可以使用Number.EPSILON和Math.round、toFixed等方法來比較浮點數或將其格式化為固定小數位數。如果需要精確計算，并且不能容忍這種舍入誤差，可以使用特殊的庫，如decimal.js或bignumber.js，它們提供了高精度的十進制數運算。

1.toString()

答案：報錯

const num = 1; 
num.toString() // 1
1.toString();  // Uncaught SyntaxError: Invalid or unexpected token
1..toString(); // 1

在 JavaScript 中，1.toString() 會導致一個語法錯誤，因為點號（.）在這里被解析為浮點數的一部分，但緊接著并沒有另一個數字來形成有效的浮點數字面量，所以解析器會拋出一個 Uncaught SyntaxError: Invalid or unexpected token 錯誤。

然而，當寫 1..toString() 時，情況就不同了。這里有兩個點號，但第一個點號實際上并不是浮點數的一部分。這是因為 JavaScript 的解析器在遇到連續的點號時會將它們視為一種特殊的語法結構，即第一個點號被視為數字 1 的結尾（盡管在這里它并沒有實際意義，因為 1 已經是完整的數字），而第二個點號則作為訪問對象屬性的操作符。

因此，1..toString() 實際上是這樣被解析的：

• 數字 1 被解析為一個完整的數字字面量。
• 由于緊接著有一個點號，但它并沒有跟隨另一個數字來形成浮點數，所以它被解釋為對象屬性的訪問操作符。
• 因為 1 在 JavaScript 中是一個原始值，它本身并沒有 .toString() 方法，但是在這里，由于點號操作符的存在，JavaScript 會嘗試將 1 轉換為一個 Number 對象（這是一個稱為裝箱或自動封裝的過程）。
• 一旦 1 被轉換為 Number 對象，就可以調用它的 .toString() 方法了。

所以，1..toString() 最終會返回字符串 "1"，盡管這種寫法在實際編程中并不常見，因為它可能會引起混淆。更常見的做法是直接對數字變量使用 .toString() 方法，也就是上面的第一種寫法。

Math.max() < Math.min()

答案：true。

Math.max() < Math.min() // true
Math.max() // -Infinity
Math.min() // Infinity

在標準的 JavaScript 環境中，Math.max() 在沒有參數時應該返回 -Infinity，而 Math.min() 在沒有參數時應該返回 Infinity。但是，由于 Infinity 總是大于 -Infinity，所以 Math.max() < Math.min() 返回 true。

9007199254740992 === 9007199254740993

答案：trueJavaScript 的 Number 類型是基于 IEEE 754 標準 （也稱為 64 位浮點數）實現的，這意味著它有一些限制，特別是關于可以精確表示的數字的范圍和精度。在 IEEE 754 標準中，最大的安全整數（即可以精確表示的最大整數）是 Number.MAX_SAFE_INTEGER，其值為 9007199254740991（2 的 53 次方減 1）。

當嘗試使用大于 Number.MAX_SAFE_INTEGER 的整數時，JavaScript 會嘗試將其存儲為一個近似的浮點數，這可能會導致精度損失。在這個例子中，9007199254740992 和 9007199254740993 都會被轉換為近似的浮點數，但由于精度限制，這兩個數字可能會表示為相同的浮點數值。

因此，如果需要在 JavaScript 中表示大數字時，建議使用字符串來存儲大數，以避免精度丟失。