Data types

Author: lenchen1112

1-js/02-first-steps/05-types/1-string-quotes/solution.md

@@ -1,15 +1,14 @@
-
-Backticks embed the expression inside `${...}` into the string.
+反引號把放在 `${...}` 中表達式的結果嵌入字串中。
 
 ```js run
 let name = "Ilya";
 
-// the expression is a number 1
+// 表達式是數值 1
 alert( `hello ${1}` ); // hello 1
 
-// the expression is a string "name"
+// 表達式是字串 "name"
 alert( `hello ${"name"}` ); // hello name
 
-// the expression is a variable, embed it
+// 表達式是個變數，嵌入它
 alert( `hello ${name}` ); // hello Ilya
 ```

1-js/02-first-steps/05-types/1-string-quotes/task.md

@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# String quotes
+# 字串引號
 
-What is the output of the script?
+此腳本會輸出什麼？
 
 ```js
 let name = "Ilya";
@@ -14,4 +14,4 @@ alert( `hello ${1}` ); // ?
 alert( `hello ${"name"}` ); // ?
 
 alert( `hello ${name}` ); // ?
-```
+```

1-js/02-first-steps/05-types/article.md

@@ -1,166 +1,167 @@
-# Data types
+# 資料類型
 
-A variable in JavaScript can contain any data. A variable can at one moment be a string and at another be a number:
+JavaScript 中的變數可包含任意資料，一個變數可以在某時間點是字串然後在另一個時間點是數值：
 
 ```js
-// no error
+// 沒有出錯
 let message = "hello";
 message = 123456;
 ```
 
-Programming languages that allow such things are called "dynamically typed", meaning that there are data types, but variables are not bound to any of them.
+若允許這麼做的程式語言，稱其具有 "動態類型 (dynamically typed)"，意思是變數不會綁定任一種資料類型。
 
-There are seven basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
+JavaScript 中有七種基礎的資料類型，在此我們會稍微介紹下它們，然後在接下來的章節中我們會逐一介紹其細節：
 
-## A number
+## 數值 (A number)
 
 ```js
 let n = 123;
 n = 12.345;
 ```
 
-The *number* type represents both integer and floating point numbers.
+*數值 (number)* 類型用於表示整數 (integer) 與浮點數 (floating point numbers)。
 
-There are many operations for numbers, e.g. multiplication `*`, division `/`, addition `+`, subtraction `-`, and so on.
+數值有許多運算方式，像是：乘法 `*`、除法 `/`、加法 `+`、減法 `-` 等等。
 
-Besides regular numbers, there are so-called "special numeric values" which also belong to this data type: `Infinity`, `-Infinity` and `NaN`.
+除了正常的數值外，還有些稱為 "特殊數值"，也是屬於此種資料類型：`Infinity`、`-Infinity` 和 `NaN`。
 
-- `Infinity` represents the mathematical [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞. It is a special value that's greater than any number.
+- `Infinity` 代表著數學上的 [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞ ，它是個比任何數都大的特殊值。
 
-    We can get it as a result of division by zero:
+    我們可以透過除以零的結果來得到它：
 
     ```js run
     alert( 1 / 0 ); // Infinity
     ```
 
-    Or just reference it directly:
+    或是直接取用它：
 
     ```js run
     alert( Infinity ); // Infinity
     ```
-- `NaN` represents a computational error. It is a result of an incorrect or an undefined mathematical operation, for instance:
+
+- `NaN` 代表著計算上的錯誤，不正確或是未定義的數學運算結果，像是：
 
     ```js run
-    alert( "not a number" / 2 ); // NaN, such division is erroneous
+    alert( "not a number" / 2 ); // NaN，這種除法是錯誤的
     ```
 
-    `NaN` is sticky. Any further operation on `NaN` returns `NaN`:
+    `NaN` 具有黏性。任何對 `NaN` 的進一步運算都會回傳 `NaN`：
 
     ```js run
     alert( "not a number" / 2 + 5 ); // NaN
     ```
 
-    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result.
+    所以如果數學表示式中有個 `NaN`，就會傳播至整個運算結果上。
 
-```smart header="Mathematical operations are safe"
-Doing maths is "safe" in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
+```smart header="數學運算很安全"
+操作數學運算在 JavaScript 是 "安全的"。我們可以做任何事情：除以零、把不是數值的字串當作數值等等。
 
-The script will never stop with a fatal error ("die"). At worst, we'll get `NaN` as the result.
+腳本永遠不會因為數學運算導致致命錯誤 (fatal error) 而停止 ("死亡")，最糟只會得到 `NaN` 這個結果而已。
 ```
 
-Special numeric values formally belong to the "number" type. Of course they are not numbers in the common sense of this word.
+特殊數值是屬於 "數值" 類型的一員，當然它們在世間的常識中並不是數值。
 
-We'll see more about working with numbers in the chapter <info:number>.
+我們會在章節 <info:number> 中看到更多使用數值的方式。
 
-## A string
+## 字串 (A string)
 
-A string in JavaScript must be surrounded by quotes.
+JavaScript 中的字串必須被引號 (quotes) 所環繞。
 
 ```js
 let str = "Hello";
-let str2 = 'Single quotes are ok too';
-let phrase = `can embed ${str}`;
+let str2 = 'Single quotes are ok too (單引號也可以)';
+let phrase = `can embed ${str} (字串可被 \${內嵌} )`;
 ```
 
-In JavaScript, there are 3 types of quotes.
+在 JavaScript 中，有三種引號。
 
-1. Double quotes: `"Hello"`.
-2. Single quotes: `'Hello'`.
-3. Backticks: <code>&#96;Hello&#96;</code>.
+1. 雙引號：`"Hello"`。
+2. 單引號：`'Hello'`。
+3. 反引號：<code>&#96;Hello&#96;</code>。
 
-Double and single quotes are "simple" quotes. There's no difference between them in JavaScript.
+單雙引號都是 "簡易的" 引號，在 JavaScript 中它們沒有差異。
 
-Backticks are "extended functionality" quotes. They allow us to embed variables and expressions into a string by wrapping them in `${…}`, for example:
+反引號是 "功能擴展" 引號，讓我們可以在字串中利用 `${...}` 嵌入變數或是表達式，例如：
 
 ```js run
 let name = "John";
 
-// embed a variable
+// 嵌入變數
 alert( `Hello, *!*${name}*/!*!` ); // Hello, John!
 
-// embed an expression
+// 嵌入表達式 
 alert( `the result is *!*${1 + 2}*/!*` ); // the result is 3
 ```
 
-The expression inside `${…}` is evaluated and the result becomes a part of the string. We can put anything in there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.
+在 `${...}` 中的表達式會被運算，其結果會被作為字串的一部分。我們可以在內放入任何東西：一個名為 `name` 的變數、數學運算式 `1 + 2` 或其他更複雜的東西。
 
-Please note that this can only be done in backticks. Other quotes don't have this embedding functionality!
+請注意這只在反引號中有作用，其他引號不具此種內嵌功能！
 ```js run
-alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)
+alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (雙引號什麼都沒做)
 ```
 
-We'll cover strings more thoroughly in the chapter <info:string>.
+我們會在章節 <info:string> 中介紹更多細節。
 
-```smart header="There is no *character* type."
-In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is `char`.
+```smart header="不存在 *字元 (character)* 類型"
+在一些語言中，單一字元有個特殊的 "字元" 類型，像是在 C 語言或是 Java 中的 `char`。
 
-In JavaScript, there is no such type. There's only one type: `string`. A string may consist of only one character or many of them.
+在 JavaScript 中沒有這種類型，只有一種 `字串` 類型。一串字串可以只有一個或擁有多個字元在內。
 ```
 
-## A boolean (logical type)
+## 布林 (A boolean) (邏輯類型)
 
-The boolean type has only two values: `true` and `false`.
+布林類型只有兩種值：`true` 和 `false`。
 
-This type is commonly used to store yes/no values: `true` means "yes, correct", and `false` means "no, incorrect".
+這種類型通常運於儲存 yes 或 no 的值：`true` 代表 "yes、正確"，而 `false` 代表 "no、不正確"。
 
-For instance:
+例如：
 
 ```js
-let nameFieldChecked = true; // yes, name field is checked
-let ageFieldChecked = false; // no, age field is not checked
+let nameFieldChecked = true; // yes, name 欄位已確認過
+let ageFieldChecked = false; // no, age 欄位尚未確認
 ```
 
-Boolean values also come as a result of comparisons:
+布林值也可作為比較的結果：
 
 ```js run
 let isGreater = 4 > 1;
 
-alert( isGreater ); // true (the comparison result is "yes")
+alert( isGreater ); // true (比較的結果是 "yes")
 ```
 
-We'll cover booleans more deeply in the chapter <info:logical-operators>.
+我們將在章節 <info:logical-operators> 中涵蓋布林類型更深入的內容。
 
-## The "null" value
+## "null" 值
 
-The special `null` value does not belong to any of the types described above.
+這個特殊的 `null` 值不屬於之前提到的任一種類型。
 
-It forms a separate type of its own which contains only the `null` value:
+它自己獨立成一個類型，其中只有 `null` 這個值。
 
 ```js
 let age = null;
 ```
 
-In JavaScript, `null` is not a "reference to a non-existing object" or a "null pointer" like in some other languages.
+在 JavaScript 中， `null` 並不向其他語言一樣是個 "指到不存在的物件的參考" 或是一個 "null 指標"。
 
-It's just a special value which represents "nothing", "empty" or "value unknown".
+它就只是個代表著 "沒東西"、"空白" 或 "未知值" 的特殊值。
 
-The code above states that `age` is unknown or empty for some reason.
+上面那段程式碼中的 `age`，就表示因為某些因素而未知或空白。
 
-## The "undefined" value
+## "undefined" 值
 
-The special value `undefined` also stands apart. It makes a type of its own, just like `null`.
+這個特殊的 `undefined` 值同樣自成一格，自身的值擁有獨立的類型，就像 `null` 一樣。
 
-The meaning of `undefined` is "value is not assigned".
+`undefined` 的意義是 "值尚未指定"。
 
-If a variable is declared, but not assigned, then its value is `undefined`:
+如果一個變數被宣告了但還沒被賦予值，那它的值就是 `undefined`：
 
 ```js run
 let x;
 
-alert(x); // shows "undefined"
+alert(x); // 顯示 "undefined"
 ```
 
-Technically, it is possible to assign `undefined` to any variable:
+技術上來說，可以把 `undefined` 指定給任何變數：
 
 ```js run
 let x = 123;
@@ -170,28 +171,28 @@ x = undefined;
 alert(x); // "undefined"
 ```
 
-...But we don't recommend doing that. Normally, we use `null` to assign an "empty" or "unknown" value to a variable, and we use `undefined` for checks like seeing if a variable has been assigned.
+...但我們不建議這麼做。通常我們使用 `null` 來給一個變數 "空白" 或是 "未知" 的值，然後使用 `undefined` 來查看變數是否有被給過值。
 
-## Objects and Symbols
+## 物件 (Objects) 和符號 (Symbols)
 
-The `object` type is special.
+`object` 這個類型很特殊。
 
-All other types are called "primitive" because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections of data and more complex entities. We'll deal with them later in the chapter <info:object> after we learn more about primitives.
+其它類型都稱為 "原生 (primitive)" 類型，因為它們的值只可包含一種東西 (一個字串或一個數值或一個其它東西)，相對地，物件被用來儲存資料群集和更複雜的東西。再更充分了解原生類型後，我們晚點會在 <info:object> 這個章節中介紹它。
 
-The `symbol` type is used to create unique identifiers for objects. We mention it here for completeness, but we'll study it after objects.
+`symbol` 類型被用在為物件建立一個獨特的識別符，為了完整性我們在此提到它，但會在介紹完物件後再來學習。
 
-## The typeof operator [#type-typeof]
+## typeof 運算子(typeof operator) [#type-typeof]
 
-The `typeof` operator returns the type of the argument. It's useful when we want to process values of different types differently or just want to do a quick check.
+`typeof` 運算子會回傳其引數 (argument) 的類型。這在當我們想要分開處理不同類型的值，或只是想要快速檢查類型時，就會很有用。
 
-It supports two forms of syntax:
+它支援兩種語法格式：
 
-1. As an operator: `typeof x`.
-2. As a function: `typeof(x)`.
+1. 作為運算子：`typeof x`。
+2. 作為函式：`typeof(x)`。
 
-In other words, it works with parentheses or without them. The result is the same.
+換句話說，有沒有括號都可以正常運作，結果也都一樣。
 
-The call to `typeof x` returns a string with the type name:
+呼叫 `typeof x` 會回傳一個該類型名稱的字串：
 
 ```js
 typeof undefined // "undefined"
@@ -217,29 +218,30 @@ typeof alert // "function"  (3)
 */!*
 ```
 
-The last three lines may need additional explanation:
+最後三行可能需要額外解釋：
+
+1. `Math` 是個用來提供數學運算的內建物件，我們會在 <info:number> 這個章節中介紹它，在這裡只是把它視為一個物件的範例。
+2. `typeof null` 的結果是 `object`，這是錯誤的。這是個官方承認在 `typeof` 中的錯誤，保留它只是為了兼容性。`null` 當然不是一個物件，它是個有著自己類型的特殊值。再次強調，這是語言中的一個錯誤。
+3. `typeof alert` 的結果是 `function`，因為 `alert` 是個函式。我們會在接下來的章節中學到函式，並了解 JavaScript 中沒有 "function" 這個特殊的類型。函式屬於物件類型的一種，但 `typeof` 視它們為不同兩者並回傳 `function`。這不那麼正確，但在實作中卻很方便。
 
-1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
-2. The result of `typeof null` is `"object"`. That's wrong. It is an officially recognized error in `typeof`, kept for compatibility. Of course, `null` is not an object. It is a special value with a separate type of its own. So, again, this is an error in the language.
-3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That's not quite correct, but very convenient in practice.
 
+## 總結
 
-## Summary
+在 JavaScript 中有 7 種基礎資料類型：
 
-There are 7 basic data types in JavaScript.
+- `number` 用於任何類型的數值：整數或浮點數。
+- `string` 用於字串。一個字串可以包含一個或多個字元，但不獨立存在單一字元的類型。
+- `boolean` 用於 `true` 或 `false`。
+- `null` 用於未知的值 － 只有一個值 `null` 的獨立類型。
+- `undefined` 用於尚未指定值 － 只有一個值 `undefined` 的獨立類型。
+- `object` 用於更為複雜的資料結構。
+- `symbol` 用於獨特的識別符。
 
-- `number` for numbers of any kind: integer or floating-point.
-- `string` for strings. A string may have one or more characters, there's no separate single-character type.
-- `boolean` for `true`/`false`.
-- `null` for unknown values -- a standalone type that has a single value `null`.
-- `undefined` for unassigned values -- a standalone type that has a single value `undefined`.
-- `object` for more complex data structures.
-- `symbol` for unique identifiers.
+`typeof` 運算子讓我們確認變數中儲存的類型。
 
-The `typeof` operator allows us to see which type is stored in a variable.
+- 兩種格式：`typeof x` 或 `typeof(x)`。
+- 回傳一個類型名稱的字串，像是 `"string"`。
+- 對於 `null` 回傳 `"object"` － 這是語言中的錯誤，它實際上不是個物件。
 
-- Two forms: `typeof x` or `typeof(x)`.
-- Returns a string with the name of the type, like `"string"`.
-- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
+接下來的章節中，我們將更專注於介紹原生類型，一旦對它們更熟悉了，就會開始來介紹物件。
 
-In the next chapters, we'll concentrate on primitive values and once we're familiar with them, we'll move on to objects.