From 43a5cac2eff22c21071800e13bef12af9d3a37d0 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 13:12:08 +0100 Subject: unslug zh-tw: move --- .../control_flow_and_error_handling/index.html | 34 ++ .../index.html | 104 ++++ .../index.html | 21 + .../index.html | 16 + .../guide/details_of_the_object_model/index.html | 28 ++ .../index.html | 46 ++ .../index.html | 57 +++ .../index.html | 42 ++ .../index.html | 58 +++ .../index.html | 14 + .../index.html | 145 ++++++ .../guide/expressions_and_operators/index.html | 16 + .../index.html | 20 + .../index.html | 31 ++ .../index.html | 43 ++ .../index.html | 186 +++++++ .../index.html | 30 ++ .../index.html | 65 +++ .../index.html | 12 + .../web/javascript/guide/functions/index.html | 34 ++ .../index.html | 36 ++ .../index.html | 15 + .../index.html | 26 + .../index.html | 24 + .../index.html | 21 + .../index.html | 17 + .../javascript/guide/grammar_and_types/index.html | 33 ++ .../index.html | 30 ++ .../index.html | 118 +++++ .../index.html | 28 ++ .../index.html | 57 +++ .../conflicting/web/javascript/guide/index.html | 452 +++++++++++++++++ .../guide/regular_expressions/index.html | 59 +++ .../index.html | 44 ++ .../index.html | 37 ++ .../guide/working_with_objects/index.html | 43 ++ .../index.html | 13 + .../global_objects/arraybuffer/index.html | 111 +++++ .../reference/global_objects/date/index.html | 246 +++++++++ .../reference/global_objects/function/index.html | 139 ++++++ .../reference/global_objects/number/index.html | 85 ++++ .../reference/global_objects/object/index.html | 219 ++++++++ .../reference/global_objects/promise/index.html | 65 +++ .../reference/global_objects/string/index.html | 177 +++++++ .../web/javascript/reference/operators/index.html | 309 ++++++++++++ .../index.html | 284 +++++++++++ .../index.html | 555 +++++++++++++++++++++ .../index.html | 244 +++++++++ 48 files changed, 4489 insertions(+) create mode 100644 files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_2691b613803afee4bca87dca2a41b5c5/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_74154e098f4b1e7026df3945ceb0fa4a/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_a2d11ceeaeb3cb8c43292be7771f9b23/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_3193ca1e5a7bdb78e9d9418a947916aa/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_483bbc3a620ead7b721647d1a2cb216f/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_60d6c39d4282c67c117db9fdaf83be08/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_8898a6dd437cc51f48b4e8cade0385ac/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_937645e235e25783cc4e9b0d7a1f6d76/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_b021bd32308e4c421518cdd7104ac7bc/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_05717c12b1ecaebc9d68cf43524d31b1/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_11969cb29fead65c26360f554426c217/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_351a6d9e4d31b32eff9762ef5deead93/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_952d66f1fe521bc0574c89750f5b406e/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e6fc14473511cf01e7062dfb7751f49d/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e70c1f2655520c542321ddbdb2c4f28d/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_eb65eb8f4e6b3c16f08b95149183cfb8/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/functions/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/functions_536f6bf46bbdf38cc1a0b28ca1bc41b9/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/functions_587eb671a310bac0771e73a91b0abe6d/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/functions_925b2d10050621507a9c990cb803dcca/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/functions_b2cd05cbfe188215dc2e3f972d293ed6/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/functions_ceaa4b2a55bb67388c2728af1ff890f5/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/functions_effb9b1bcc102a5f6df7f1785ce89033/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/grammar_and_types/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_5c6f30ff8e011c45a011b9c8f3b5bcea/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_d57082c2207b466127d8dc34a980addf/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_e5a53691c318855e3342ad91feb78f2e/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_ef6fc79abc28f5eadd6c126341df5e49/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/regular_expressions/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/regular_expressions_24eb6498b86da57e7fb5337fd8fa04a6/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/regular_expressions_38b32725e0e3217a5542b1b4ee122407/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide/working_with_objects/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/guide_dc05b578fe0c2f7d9a89ed82daab4e65/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/global_objects/date/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/global_objects/function/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/global_objects/number/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/global_objects/object/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/global_objects/promise/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/global_objects/string/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/operators/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/operators_310dc67549939233c3d18a8fa2cdbb23/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html create mode 100644 files/zh-tw/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html (limited to 'files/zh-tw/conflicting/web/javascript') diff --git a/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html new file mode 100644 index 0000000000..24484bb5b3 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html @@ -0,0 +1,34 @@ +--- +title: 區塊語法 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/區塊語法 +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Block_Statement +--- +

區塊語法

+

區塊語法用於把語句群組化。區塊的範圍是由一對大括號所界定︰

+
{
+   statement_1
+   statement_2
+   .
+   .
+   .
+   statement_n
+}
+
+

範例
區塊語法通常和流程控制語法（例如 if、for、while）一併使用。

+
while (x < 10) {
+   x++;
+}
+
+

此處，{ x++; } 就是區塊語法。

+

重要: JavaScript 並沒有 區塊作用域。區塊裡的變數其作用域相當於函數或 Script，對變數的設定會一直持續到區塊本身之外。換言之，區塊語法並沒有作用域。儘管“單獨”的區塊仍是有效的句法，你也不會想要在 JavaScript 中使用單獨的區塊，因為這樣做並不會產生任何你所期待的機能，譬如說如果你期待類似 C 或 Java 而這樣做的話。例如︰

+
var x = 1;
+{
+   var x = 2;
+}
+alert(x); // 輸出 2
+
+

這樣會輸出 2，因為在區塊之內的 var x 語法，其作用域如同沒有區塊的 var x 語法。而在 C 或 Java 中，同樣的代碼將會輸出 1。

+

{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的運用:正規表達式的範例", "Core_JavaScript_1.5_教學:條件語法") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Block_Statement", "fr": "fr/Guide_JavaScript_1.5/D\u00e9claration_de_blocs", "ja": "ja/Core_JavaScript_1.5_Guide/Block_Statement", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Blok_instrukcji" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_2691b613803afee4bca87dca2a41b5c5/index.html b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_2691b613803afee4bca87dca2a41b5c5/index.html new file mode 100644 index 0000000000..c9f263afe1 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_2691b613803afee4bca87dca2a41b5c5/index.html @@ -0,0 +1,104 @@ +--- +title: 條件語法 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/條件語法 +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Conditional_Statements +--- +

條件語法

+

條件語法是在當指定的條件為 true 時，就執行一整組指令。JavaScript 支援兩種條件語法︰if...else 和 switch。

+

if...else 語法

+

如果邏輯條件為 true 時，就執行 if 語法裡的語句。如果條件為 false 的話，可以使用選用性的 else 子句來執行語句。if 語法如下︰

+
if (condition)
+   statement_1
+[else
+   statement_2]
+
+

condition 可以是任何可求值為 true 或 false 的表達式。如果 condition 的求值為 true，就會執行 statement_1，否則執行 statement_2。statement_1 和 statement_2 可以是任何的語句，包括嵌套的 if 語法。

+

你也可以使用 else if 來組合語句，並依序測試各個條件，如下︰

+
if (condition)
+   statement_1
+[else if (condition_2)
+   statement_2]
+...
+[else if (condition_n_1)
+   statement_n_1]
+[else
+   statement_n]
+
+

要執行多個語句，就使用區塊語法（{ ... }）把語句群組化。一般來說，固定使用區塊語法是非常好的作法，尤其是當代碼內部還有嵌套的 if 語法時︰

+
if (condition) {
+   statements_1
+} else {
+   statements_2
+}
+
+

不要在條件表達式裡使用簡單的代入動作會比較明智，因為在快速瀏覽代碼時，代入和相等很容易彼此混淆。例如，不要使用如下代碼︰

+
if (x = y) {
+   /* 做一些事 */
+}
+
+

如果你需要在條件表達式中使用代入的話，常見的作法是在代入語句加上額外的括弧。例如︰

+
if ((x = y)) {
+   /* 做一些事 */
+}
+
+

不要把 Boolean 物件的 true、false 值和原始的布林值 true、false 相混淆。任何值只要不是 undefined、null、0、NaN、空字串 ("")、物件，即使是含有 false 值的 Boolean 物件，傳給條件語法的求值結果也會是 true。例如︰

+
var b = new Boolean(false);
+if (b) // 這個條件的求值結果為 true
+
+

範例
+在以下的範例中，如果在 Text 物件裡的字元數目為 3，函數 checkData 就返回 true。否則，他會顯示警報並返回 false。

+
function checkData() {
+   if (document.form1.threeChar.value.length == 3) {
+      return true;
+   } else {
+      alert("Enter exactly three characters. " +
+         document.form1.threeChar.value + " is not valid.");
+      return false;
+   }
+}
+

switch 語法

+

switch 語法可讓程式對表達式求值，並試著以表達式的值來一一比對 case 標籤。如果發現比對符合，程式就會執行與之關聯的語句。switch 語法如下︰

+
switch (expression) {
+   case label_1:
+      statements_1
+      [break;]
+   case label_2:
+      statements_2
+      [break;]
+   ...
+   default:
+      statements_def
+      [break;]
+}
+
+

程式首先從附有標籤的 case 子句找出能夠符合表達式的值的標籤，然後把控制權轉移到那個子句，並執行與之相關的語句。如果找不到相符的標籤，程式就會尋找選用性的 default 子句，如果找到的話，就把控制權轉移到那個子句，並執行與之相關的語句。如果找不到 default 子句，程式就會繼續執行 switch 語法後面的語句。根據慣例，default 語句一定是最後一個子句，但是並非只能這樣使用。

+

可用在每一個 case 子句的選用性 break 語法，可確實從 switch 裡已執行完且後面還有其他語句的符合語句中跳出。如果省略 break，程式就會繼續執行 switch 語法裡的下一個語法。

+

範例
+在以下範例中，如果 fruittype 求值為 "Bananas"，程式就會比對出 case "Bananas" 的值，並執行相聯的語句。如果遇到 break，程式就會終止 switch 並執行 switch 後面的語句。如果省略了 break，case "Cherries" 裡的語句也會被執行。

+
switch (fruittype) {
+   case "Oranges":
+      document.write("Oranges are $0.59 a pound.<br>");
+      break;
+   case "Apples":
+      document.write("Apples are $0.32 a pound.<br>");
+      break;
+   case "Bananas":
+      document.write("Bananas are $0.48 a pound.<br>");
+      break;
+   case "Cherries":
+      document.write("Cherries are $3.00 a pound.<br>");
+      break;
+   case "Mangoes":
+   case "Papayas":
+      document.write("Mangoes and papayas are $2.79 a pound.<br>");
+      break;
+   default:
+      document.write("Sorry, we are out of " + fruittype + ".<br>");
+}
+document.write("Is there anything else you'd like?<br>");
+
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:區塊語法", "Core_JavaScript_1.5_教學:循環語法") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Conditional_Statements", "fr": "fr/Guide_JavaScript_1.5/Instructions_conditionnelles", "ja": "ja/Core_JavaScript_1.5_Guide/Conditional_Statements", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Instrukcje_warunkowe" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_74154e098f4b1e7026df3945ceb0fa4a/index.html b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_74154e098f4b1e7026df3945ceb0fa4a/index.html new file mode 100644 index 0000000000..1e922b72f2 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_74154e098f4b1e7026df3945ceb0fa4a/index.html @@ -0,0 +1,21 @@ +--- +title: 註解 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/註解 +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Comments +--- +

註解

+

註解是作者用來解釋 Script 在做什麼的標記符號。註解會被解譯器忽略。JavaScript 支援 Java 和 C++ 形式的註解︰

+ +

範例
+以下範例示範這兩種註解︰

+
// 這是單行註解。
+
+/* 這是多行註解。不管是什麼長度都可以，你也
+可以在任何你喜歡的地方使用。 */
+
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:物件的操作語法", "Core_JavaScript_1.5_教學:例外處理語法") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Comments", "es": "es/Gu\u00eda_JavaScript_1.5/Sentencias_para_comentarios", "fr": "fr/Guide_JavaScript_1.5/Commentaires", "ja": "ja/Core_JavaScript_1.5_Guide/Comments", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Instrukcje_komentarzy" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_a2d11ceeaeb3cb8c43292be7771f9b23/index.html b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_a2d11ceeaeb3cb8c43292be7771f9b23/index.html new file mode 100644 index 0000000000..af67cbfa03 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_a2d11ceeaeb3cb8c43292be7771f9b23/index.html @@ -0,0 +1,16 @@ +--- +title: 循環語法 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法 +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Loop_Statements +--- +

循環語法

+

循環（或稱迴圈）是一組反覆執行的指令，直到滿足指定的條件為止。JavaScript 支援 for、do while、while 循環語法，除了 label 以外（label 本身不是循環語法，但經常和循環語法一起使用）。此外，你也可以在循環語法內部使用 break 和 continue 語法。

+

還有另一種語法 for...in 反覆執行語句，但是只用於物件的操作。參閱 物件的操作語法。

+

循環語法如下︰

+ +
+

{{ PreviousNext("Core_JavaScript_1.5_教學:條件語法", "Core_JavaScript_1.5_教學:循環語法:for_語法") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Loop_Statements", "es": "es/Gu\u00eda_JavaScript_1.5/Sentencias_de_bucle", "fr": "fr/Guide_JavaScript_1.5/Boucles", "ja": "ja/Core_JavaScript_1.5_Guide/Loop_Statements", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Instrukcje_p\u0119tli" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model/index.html b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model/index.html new file mode 100644 index 0000000000..45678e3bdb --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model/index.html @@ -0,0 +1,28 @@ +--- +title: 以類別為基礎的語言 vs. 以原型為基礎的語言 +slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/以類別為基礎的語言_vs._以原型為基礎的語言 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Class-Based_vs._Prototype-Based_Languages +--- +

以類別為基礎的語言 vs. 以原型為基礎的語言

+

以類別為基礎的語言，如 Java 和 C++，是以兩種不同實體的概念為根基︰類別（Class）和實體（Instance）。

+ +

以原型為基礎的語言，如 JavaScript，並沒有這些分別︰他簡單到只有物件。以原型為基礎的語言具有原型物件的概念。物件被當作模板來使用，從中取得最初的屬性以提供給新物件。不論是在你建立物件或執行時期的時候，任何物件都可以指定他自己的屬性。此外，任何物件都可以作為其他物件的原型而連繫起來，讓第二個物件共用第一個物件的屬性。

+

類別的定義

+

在以類別為基礎的語言中，你會在獨立的類別定義中定義類別。在這些定義中，你可以指定稱為建構子的特殊方法，用來建立類別的實體。建構子方法可以為實體的屬性指定初始值，並進行在建立時期的其他適當處理。你會使用 new 運算子配合建構子方法來建立類別的實體。

+

JavaScript 遵從類似的模型，但是建構子和其他類別的定義並沒有分別。取而代之，你會定義建構子函數來建立帶有特定初始值的一組屬性和值的物件。任何的 JavaScript 函數都可以用作建構子。你會使用 new 運算子配合建構子函數來建立新的物件。

+

子類別和繼承

+

在以類別為基礎的語言中，你會建立出類別定義整體的類別階層。在類別的定義中，你可以把新的類別指定為另一個既存類別的子類別。這個子類別會繼承親類別所有的屬性，也可以另外加入新的屬性或修改繼承下來的。例如，假定 Employee 類別只含有 name 和 dept 屬性，而 Manager 是 Employee 的子類別，且加入了 reports 屬性。在這個情況下，Manager 類別的實體將具有全部的三個屬性︰name、dept、reports。

+

JavaScript 可讓你把任意的建構子函數和原型物件連結在一起，以此實現繼承。因此，你可以準確的建立出 Employee 和 Manager 的範例，但是你會使用有點不一樣的術語。首先，你會定義 Employee 的建構子函數，指定 name 和 dept 屬性。接著，你會定義 Manager 的建構子函數，指定 reports 屬性。最後，你會把新的 Employee 物件作為原型代入給 Manager 的建構子函數。然後，當你建立新的 Manager 的時候，他就會從 Employee 物件繼承 name 和 dept 屬性。

+

屬性的加入和移除

+

在以類別為基礎的語言中，你通常會在編譯時期建立類別，然後你會在編譯時期或執行時期實體化類別的實體。在你定義了類別以後，你就不能改變類別的屬性的類型或數目。然而在JavaScript 中，你可以在執行時期加入或移除任何物件的屬性。如果你把屬性加入到用作為一整群物件的原型的物件裡，使用同一個原型的物件也會得到新的屬性。

+

不同點的摘要

+

下表給出了這些不同點的簡短摘要。本章的剩餘部分描述了使用 JavaScript 的建構子和原型來建立物件的階層，並和 Java 的做法來做比較。

+ +
以類別為基礎 (Java) 以原型為基礎 (JavaScript)
類別和實體這兩者有分別。 所有的物件都是實體。
使用類別定義來定義類別；使用建構子方法來把類別實體化。 使用建構子函數來定義並建立一整群物件。
使用 new 運算子來建立單一的物件。 相同。
使用類別定義來建構物件的階層，用以定義既存類別的子類。 藉由代入，把作為原型的物件和建構子函數連結起來，來建構出物件的階層。
藉由遵從類別鏈來繼承屬性。 藉由遵從原型鏈來繼承屬性。
類別定義指定了類別的所有實體的所有屬性。不能在執行時期動態的加入屬性。 建構子函數或原型指定並初始化了一系列屬性。可以給單獨的物件或一整組物件來動態的加入或移除屬性。
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:迭代器和產生器", "Core_JavaScript_1.5_教學:職員的例子") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Class-Based_vs._Prototype-Based_Languages", "es": "es/Gu\u00eda_JavaScript_1.5/Lenguajes_basados_en_clases_frente_a_basados_en_prototipos", "fr": "fr/Guide_JavaScript_1.5/Langages_bas\u00e9s_sur_les_classes_et_langages_bas\u00e9s_sur_les_prototypes", "ja": "ja/Core_JavaScript_1.5_Guide/Class-Based_vs._Prototype-Based_Languages", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/J\u0119zyki_oparte_na_klasach_vs._oparte_na_prototypach", "zh-cn": "cn/Core_JavaScript_1.5_Guide/Class-Based_vs._Prototype-Based_Languages" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_3193ca1e5a7bdb78e9d9418a947916aa/index.html b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_3193ca1e5a7bdb78e9d9418a947916aa/index.html new file mode 100644 index 0000000000..451fa3036e --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_3193ca1e5a7bdb78e9d9418a947916aa/index.html @@ -0,0 +1,46 @@ +--- +title: 實體關係的確定 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/實體關係的確定 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Determining_Instance_Relationships +--- +

實體關係的確定

+

Javascript 搜尋屬性時，會先從物件內部所擁有的屬性開始，如果找不到屬性的名稱，就會從特殊的物件屬性 __proto__ 內部搜尋。不斷反覆執行；這個過程就稱為〝在原型鏈中搜尋〞。

+

當物件建構完成時，就會設定這個特殊的屬性 __proto__；他會被設成建構子的 prototype 屬性的值。因此，表達式 new Foo() 會以 __proto__ == Foo.prototype 來建立物件。因此，變更 Foo.prototype 的屬性，就會改變所有由 new Foo() 所建立的物件的屬性的搜尋。

+

每一個物件都有 __proto__ 物件屬性（除了 Object 以外）；每一個函數都有 prototype 物件屬性。所以物件可藉由“原型的繼承”與其他物件建立起關係。你可以藉由物件的 __proto__ 與函數的 prototype 物件的比較來對繼承進行測試。JavaScript 也提供了便捷方式︰instanceof 運算子會對照函數以檢測物件，如果這個物件繼承自函數的原型，就返回 true。例如，

+
var f = new Foo();
+var isTrue = (f instanceof Foo);
+

舉個更詳細的例子，假設你有顯示在 屬性的繼承 中的同一組定義。並建立 Engineer 物件如下︰

+
chris = new Engineer("Pigman, Chris", ["jsd"], "fiji");
+
+

對於這個物件，以下語句全部為 true︰

+
chris.__proto__ == Engineer.prototype;
+chris.__proto__.__proto__ == WorkerBee.prototype;
+chris.__proto__.__proto__.__proto__ == Employee.prototype;
+chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype;
+chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null;
+
+

有鑑於此，你可以編寫 instanceOf 函數如下︰

+
function instanceOf(object, constructor) {
+   while (object != null) {
+      if (object == constructor.prototype)
+         return true;
+      object = object.__proto__;
+   }
+   return false;
+}
+
+

根據這個定義，以下語句全部為 true︰

+
instanceOf (chris, Engineer)
+instanceOf (chris, WorkerBee)
+instanceOf (chris, Employee)
+instanceOf (chris, Object)
+
+

但下面的表達式是 false︰

+
instanceOf (chris, SalesPerson)
+
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承:局域值和繼承值", "Core_JavaScript_1.5_教學:再談屬性的繼承:建構子中的全域資訊") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Determining_Instance_Relationships", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades/Determinando_relaciones_de_instancia", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Determining_Instance_Relationships", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Powr\u00f3t_dziedziczenia_w\u0142asno\u015bci/Okre\u015blanie_wzajemnych_relacji_obiektu" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_483bbc3a620ead7b721647d1a2cb216f/index.html b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_483bbc3a620ead7b721647d1a2cb216f/index.html new file mode 100644 index 0000000000..e042494b71 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_483bbc3a620ead7b721647d1a2cb216f/index.html @@ -0,0 +1,57 @@ +--- +title: 局域值和繼承值 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/局域值和繼承值 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Local_versus_Inherited_Values +--- +

局域值和繼承值

+

當你存取物件屬性的時候，JavaScript 會進行這些步驟，如同本章前面所提到過的︰

+
  1. 檢查局域值是否存在。如果存在，就返回局域值。
  2. 如果局域值不存在，就檢查原型鏈（使用 __proto__ 屬性）。
  3. 如果在原型鏈上的物件具有所求的指定屬性，就返回這個屬性的值。
  4. 如果找不到這樣的屬性，這個物件就不具有這個屬性。
    5. +
+

這些步驟之後的結果，取決於你如何循著這個方式來定義。一開始的例子有這些定義︰

+
function Employee () {
+this.name = "";
+this.dept = "general";
+}
+
+function WorkerBee () {
+this.projects = [];
+}
+WorkerBee.prototype = new Employee;
+
+

藉由這些定義，假定你以如下語句建立 amy 作為 WorkerBee 的實體︰

+
amy = new WorkerBee;
+
+

amy 物件具有一個局域的屬性，projects。name 和 dept 屬性的值並不是 amy 的局域值，所以是從 amy 物件的 __proto__ 屬性得來的。因此，amy 具有這些屬性值︰

+
amy.name == "";
+amy.dept == "general";
+amy.projects == [];
+
+

現在假定你在與 Employee 連結的原型改變 name 屬性的值︰

+
Employee.prototype.name = "Unknown"
+
+

乍看之下，你可能會預期新的值會被向下傳播給 Employee 所有的實體。然而，事情並不如此。

+

當你建立 Employee 物件的任何實體，這些實體會取得 name 屬性的局域值（空字串的那個）。這意味著當你使用新建立的 Employee 物件來設定 WorkerBee 原型的時候，WorkerBee.prototype 就具有 name 屬性的局域值。因此，當 JavaScript 找到 amy 物件（WorkerBee 的實體）的 name 屬性的時候，JavaScript 在 WorkerBee.prototype 找到了這些屬性的局域值。也因此並不會進一步在鏈的上一層 Employee.prototype 裡尋找。

+

如果你想要在執行時期改變物件屬性的值，而且希望新的值能被這個物件的所有子孫所繼承，你就不能在物件的建構子函數中定義這個屬性。相對的，你要把這個屬性加入到與建構子相連結的原型。例如，假定你修改前面的代碼如下︰

+
function Employee () {
+   this.dept = "general";
+}
+Employee.prototype.name = "";
+
+function WorkerBee () {
+this.projects = [];
+}
+WorkerBee.prototype = new Employee;
+
+amy = new WorkerBee;
+
+Employee.prototype.name = "Unknown";
+
+

在這個情況下，amy 的 name 屬性就會變成 "Unknown"。

+

如同這些範例所示，如果你希望物件的屬性有預設值，而且還希望能夠在執行時期修改這些預設值，你就應該在建構子的原型中設定這些屬性，而不是在建構子函數本身。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承", "Core_JavaScript_1.5_教學:再談屬性的繼承:實體關係的確定") }}

+
+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Local_versus_Inherited_Values", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades/Valores_locales_frente_a_los_heredados", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Local_versus_Inherited_Values", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Powr\u00f3t_dziedziczenia_w\u0142asno\u015bci/Warto\u015bci_lokalne_vs._dziedziczone" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_60d6c39d4282c67c117db9fdaf83be08/index.html b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_60d6c39d4282c67c117db9fdaf83be08/index.html new file mode 100644 index 0000000000..b787de8dd0 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_60d6c39d4282c67c117db9fdaf83be08/index.html @@ -0,0 +1,42 @@ +--- +title: 沒有多重繼承 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/沒有多重繼承 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/No_Multiple_Inheritance +--- +

沒有多重繼承

+

部分物件導向語言允許多重繼承。也就是說，物件可以從互不相關的親物件繼承屬性和值。不過 JavaScript 並不支援多重繼承。

+

屬性值的繼承發生在執行時期，由 JavaScript 搜尋物件的原型鏈以找出繼承值。由於物件只有單一的已連結原型，因此 JavaScript 並不能從多於一個以上的原型鏈中動態的繼承。

+

在 JavaScript 中，建構子函數的內部可以有很多個其他的建構子函數的呼叫。如此可提供多重繼承的假象。例如，思考下面的語句︰

+
function Hobbyist (hobby) {
+   this.hobby = hobby || "scuba";
+}
+
+function Engineer (name, projs, mach, hobby) {
+   this.base1 = WorkerBee;
+   this.base1(name, "engineering", projs);
+   this.base2 = Hobbyist;
+   this.base2(hobby);
+   this.machine = mach || "";
+}
+Engineer.prototype = new WorkerBee;
+
+dennis = new Engineer("Doe, Dennis", ["collabra"], "hugo")
+
+

接著假定 WorkerBee 的定義使用的是本章先前的內容。在這個情況下，dennis 物件就有了這些屬性︰

+
dennis.name == "Doe, Dennis"
+dennis.dept == "engineering"
+dennis.projects == ["collabra"]
+dennis.machine == "hugo"
+dennis.hobby == "scuba"
+
+

所以 dennis 從 Hobbyist 建構子中得到了 hobby 的屬性。然而，假定你稍後把新的屬性加入到 Hobbyist 建構子的原型︰

+
Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"]
+
+

dennis 物件並未繼承到這個新的屬性。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承:建構子中的全域資訊", "Core_JavaScript_1.5_教學:LiveConnect_概要") }}

+
+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/No_Multiple_Inheritance", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades/Herencia_no_m\u00faltiple", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/No_Multiple_Inheritance", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Powr\u00f3t_dziedziczenia_w\u0142asno\u015bci/Brak_wielokrotnego_dziedziczenia" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_8898a6dd437cc51f48b4e8cade0385ac/index.html b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_8898a6dd437cc51f48b4e8cade0385ac/index.html new file mode 100644 index 0000000000..cece6b5a66 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_8898a6dd437cc51f48b4e8cade0385ac/index.html @@ -0,0 +1,58 @@ +--- +title: 建構子中的全域資訊 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/建構子中的全域資訊 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Global_Information_in_Constructors +--- +

建構子中的全域資訊

+

當你建立建構子的時候，如果你在建構子中設定全域資訊，需要很小心。例如，假定你想要自動的給每一個新的職員指定一個專有的 ID。你可以給 Employee 使用下面的定義︰

+
var idCounter = 1;
+
+function Employee (name, dept) {
+   this.name = name || "";
+   this.dept = dept || "general";
+   this.id = idCounter++;
+}
+
+

根據這個定義，當你建立新的 Employee 的時候，建構子會依序把下一個 ID 指定給他，然後增加全域 ID 的計數器。因此，如果你的下一條語句如下，victoria.id 為 1，且 harry.id 為 2︰

+
victoria = new Employee("Pigbert, Victoria", "pubs")
+harry = new Employee("Tschopik, Harry", "sales")
+
+

乍看之下很好。然而，idCounter 會在每一次建立 Employee 物件的時候遞增，而不問用途。如果你建立顯示在本章中的整個 Employee 階層結構，Employee 建構子會在你每一次設定原型的時候被呼叫。假設你有下面的代碼︰

+
var idCounter = 1;
+
+function Employee (name, dept) {
+   this.name = name || "";
+   this.dept = dept || "general";
+   this.id = idCounter++;
+}
+
+function Manager (name, dept, reports) {...}
+Manager.prototype = new Employee;
+
+function WorkerBee (name, dept, projs) {...}
+WorkerBee.prototype = new Employee;
+
+function Engineer (name, projs, mach) {...}
+Engineer.prototype = new WorkerBee;
+
+function SalesPerson (name, projs, quota) {...}
+SalesPerson.prototype = new WorkerBee;
+
+mac = new Engineer("Wood, Mac");
+
+

在此略過 base 屬性的定義，並呼叫原型鏈中在他們之上的建構子。在這個情況下，等到 mac 物件被建立的時候，mac.id 是 5。

+

根據應用程式而定，計數器遞增了額外的次數，這也許重要，也許不重要。如果你很在意計數器額外的數值，有一個可能的解決方案是改用下面的建構子來代替︰

+
function Employee (name, dept) {
+   this.name = name || "";
+   this.dept = dept || "general";
+   if (name)
+      this.id = idCounter++;
+}
+
+

當你建立用作為原型的 Employee 實體時候，你並不需要提供參數給建構子。使用這個定義的建構子，當你並未提供參數時，建構子並不會把值代入給 id，也不會更新計數器。因此，若要 Employee 取得指定的 id，你就必須為職員指定名稱。在這個範例中，mac.id 將會是 1。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承:實體關係的確定", "Core_JavaScript_1.5_教學:再談屬性的繼承:沒有多重繼承") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Global_Information_in_Constructors", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades/Informaci\u00f3n_global_en_los_constructores", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited/Global_Information_in_Constructors", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Powr\u00f3t_dziedziczenia_w\u0142asno\u015bci/Globalne_informacje_w_konstruktorach" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_937645e235e25783cc4e9b0d7a1f6d76/index.html b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_937645e235e25783cc4e9b0d7a1f6d76/index.html new file mode 100644 index 0000000000..3bba16f786 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_937645e235e25783cc4e9b0d7a1f6d76/index.html @@ -0,0 +1,14 @@ +--- +title: 再談屬性的繼承 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited +--- +

再談屬性的繼承

+

前面的章節說明了 JavaScript 建構子和原型如何提供階層組織和實體。本節將會討論一些稍早的討論中所看不到的細微差別。

+ +
+

{{ PreviousNext("Core_JavaScript_1.5_教學:職員的例子:更靈活的建構子", "Core_JavaScript_1.5_教學:再談屬性的繼承:局域值和繼承值") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited", "es": "es/Gu\u00eda_JavaScript_1.5/M\u00e1s_sobre_la_herencia_de_propiedades", "ja": "ja/Core_JavaScript_1.5_Guide/Property_Inheritance_Revisited", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Powr\u00f3t_dziedziczenia_w\u0142asno\u015bci" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_b021bd32308e4c421518cdd7104ac7bc/index.html b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_b021bd32308e4c421518cdd7104ac7bc/index.html new file mode 100644 index 0000000000..5f071f0b00 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_b021bd32308e4c421518cdd7104ac7bc/index.html @@ -0,0 +1,145 @@ +--- +title: 更靈活的建構子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子/更靈活的建構子 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/The_Employee_Example/More_Flexible_Constructors +--- +

更靈活的建構子

+

目前為止所介紹的建構子函數並不能讓你在建立實體的時候指定屬性值。如同 Java 一般，你可以提供參數給建構子來為實體初始化屬性值。下圖顯示了做到這點的其中一個方式。

+

Image:hier05.gif
+圖 8.5: 在建構子中指定屬性，之一

+

下表顯示出 Java 和 JavaScript 對這些物件的定義。

+ +
JavaScript Java 
+function Employee (name, dept) {
+  this.name = name || "";
+  this.dept = dept || "general";
+}
+
 
+public class Employee {
+   public String name;
+   public String dept;
+   public Employee () {
+      this("", "general");
+   }
+   public Employee (String name) {
+      this(name, "general");
+   }
+   public Employee (String name, String dept) {
+      this.name = name;
+      this.dept = dept;
+   }
+}
+
 
+function WorkerBee (projs) {
+  this.projects = projs || [];
+}
+WorkerBee.prototype = new Employee;
+
 
+import java.util.List;
+import java.util.ArrayList;
+
+public class WorkerBee extends Employee {
+   public List<String> projects;
+   public WorkerBee () {
+      this(new ArrayList<String>());
+   }
+   public WorkerBee (List<String> projs) {
+      projects = projs;
+   }
+}
+
+
 
+
+function Engineer (mach) {
+   this.dept = "engineering";
+   this.machine = mach || "";
+}
+Engineer.prototype = new WorkerBee;
+
 
+public class Engineer extends WorkerBee {
+   public String machine;
+   public Engineer () {
+      dept = "engineering";
+      machine = "";
+   }
+   public Engineer (String mach) {
+      dept = "engineering";
+      machine = mach;
+   }
+}
+
+


+JavaScript 的這些定義使用了特殊的用語來設定預設值︰

+
this.name = name || "";
+
+

JavaScript 的邏輯 OR 運算子 (||) 會對他的第一參數求值。如果參數轉換為 true，運算子就返回這個參數。否則，運算子返回第二個參數的值。因此，這一行測試代碼可以看成，如果 name 具有對 name 屬性而言有用的值。如果是的話，他就把 this.name 設定成這個值。否則，他就把 this.name 設定成空字串。為簡單起見，本章使用這個用語；然而，第一眼看到這種用法的時候會使人迷惑不解。請注意︰這個用法在數字或布林參數中，可能不會如預期般運作，例如 0（零）和 false 會導致預設值被選取；在這種情況下，你將會需要使用下面更為冗長的用語，他會使所有的資料類型都發生預期般的行為︰

+
this.authorized = typeof(authorized) !== 'undefined' ? authorized : true;
+
+

當你使用這個定義來建立物件的實體的時候，你可以為在局域中定義的屬性來指定值。如同圖 8.5 所示，你可以使用如下語句來建立新的 Engineer︰

+
jane = new Engineer("belau");
+
+

 Jane 的屬性現在是︰

+
jane.name == "";
+jane.dept == "engineering";
+jane.projects == [];
+jane.machine == "belau"
+
+

注意這些定義，你不能為像 name 這種繼承下來的屬性指定初始值。如果你想要在 JavaScript 中，給繼承下來的屬性指定初始值，你就需要加入更多的代碼到建構子函數中。

+

截至目前為止，建構子函數建立了通用的物件，然後為新物件指定局域的屬性和值。你的建構子也可以直接呼叫建構子函數，來為原型鏈中較高層的物件加入更多的屬性。下圖顯示了這些定義。

+

Image:hier06.gif
+圖 8.6 在建構子中指定屬性，之二

+

讓我們來更仔細的觀察其中一個定義。這是 Engineer 建構子的新定義︰

+
function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+
+

假設你如下建立新的 Engineer 物件︰

+
jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
+
+

JavaScript 遵循以下步驟︰

+
  1. new 運算子建立通用物件，並且把他的 __proto__ 屬性設定為 Engineer.prototype。
  2. new 運算子把新物件傳遞給 Engineer 建構子當作 this 關鍵字的值。
  3. 建構子為這個物件建立稱為 base 的新屬性，並且把 WorkerBee 建構子的值代入給 base 屬性。這會使 WorkerBee 建構子成為 Engineer 物件的一個方法。base 屬性的名稱並無特別之處。你可以使用任意的有效的屬性名稱；base 這個名稱只是簡單的為了他的用途而取的。
  4. 建構子呼叫 base 方法，把傳入給建構子的其中兩個參數（"Doe, Jane" 以及 {{ mediawiki.external('\"navigator\", \"javascript\"') }}）以及字串 "engineering" 當作自己的參數傳入。在建構子中明確的使用 "engineering"，表明了所有 Engineer 物件所繼承下來的 dept 屬性都有相同的值，而且這個值會覆蓋繼承自 Employee 的值。
  5. 因為 base 是 Engineer 的方法，base 呼叫端的內部是 JavaScript 在步驟 1 時和新建立的物件綁在一起的 this 關鍵字。因此，WorkerBee 函數依序把 "Doe, Jane" 以及 {{ mediawiki.external('\"navigator\", \"javascript\"') }} 參數傳遞給 Employee 建構子函數。從 Employee 建構子函數返回以後，WorkerBee 函數使用剩下的參數來設定 projects 屬性。
  6. 從 base 方法返回以後，Engineer 建構子把物件的 machine 屬性初始化成 "belau"。
  7. 從建構子返回以後，JavaScript 就把新物件代入給 jane 變數。
    8. +
+

你可能在想，要從 Engineer 建構子的內部呼叫 WorkerBee 的建構子，明明你已經為 Engineer 物件設置適當的繼承了。實際情形並非如此。呼叫 WorkerBee 建構子可以確保，與已指定屬性的 Engineer 物件一起開始的所有建構子函數都會被呼叫。然而，如果你稍後把屬性加入到 Employee 或者 WorkerBee 屬性，這些屬性並不會被 Engineer 物件所繼承。例如，假設你使用如下語句︰

+
function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
+Employee.prototype.specialty = "none";
+
+

jane 物件並未繼承 specialty 屬性。你仍然需要明確的設置原型，以確保動態繼承。假設你改用這些語句︰

+
function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+Engineer.prototype = new WorkerBee;
+jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau");
+Employee.prototype.specialty = "none";
+
+

現在 jane 物件的 specialty 屬性的值是 "none"。

+
+

另一種繼承的方式是使用 .call/.apply 方法。以下兩者是等價的︰

+ +
+function Engineer (name, projs, mach) {
+  this.base = WorkerBee;
+  this.base(name, "engineering", projs);
+  this.machine = mach || "";
+}
+
 
+function Engineer (name, projs, mach) {
+  WorkerBee.call(this, name, "engineering", projs);
+  this.machine = mach || "";
+}
+
+

使用 Javascript 的 .call 方法可以產生較為簡潔的實作，因為不再需要 ".base"。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:職員的例子:物件的屬性:屬性的加入", "Core_JavaScript_1.5_教學:再談屬性的繼承") }}

+
+

{{ languages( {"en": "en/Core_JavaScript_1.5_Guide/The_Employee_Example/More_Flexible_Constructors", "es": "es/Gu\u00eda_JavaScript_1.5/El_ejemplo_Employee/Constructores_m\u00e1s_flexibles", "ja": "ja/Core_JavaScript_1.5_Guide/The_Employee_Example/More_Flexible_Constructors", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Praca_z_przyk\u0142adem/Wi\u0119cej_elastycznych_konstruktor\u00f3w" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators/index.html new file mode 100644 index 0000000000..0d694e88f8 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators/index.html @@ -0,0 +1,16 @@ +--- +title: 表達式 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/表達式 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Expressions +--- +

 

+

表達式

+

表達式即任何有效的一組字面表達、變數、運算子、可求值的單一的值，值可以使用數字、字串、或邏輯值。

+

大致上來說，表達式可分為兩種︰把值代入給變數，和單純的持有值。例如，表達式 x = 7 是把值 7 代入給 x 的表達式。表達式本身的求值結果是 7。這些表達式使用代入運算子。換句話說，表達式 3 + 4 單純的求值結果為 7，且沒有代入動作。這些表達式使用的運算子又可以簡單的稱為運算子。

+

JavaScript 有以下幾種表達式︰

+ +

{{ PreviousNext("Core_JavaScript_1.5_教學:Unicode", "Core_JavaScript_1.5_教學:運算子") }}

+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Expressions", "fr": "fr/Guide_JavaScript_1.5/Expressions", "ja": "ja/Core_JavaScript_1.5_Guide/Expressions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Wyra\u017cenia" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_05717c12b1ecaebc9d68cf43524d31b1/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_05717c12b1ecaebc9d68cf43524d31b1/index.html new file mode 100644 index 0000000000..e00a0e612b --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_05717c12b1ecaebc9d68cf43524d31b1/index.html @@ -0,0 +1,20 @@ +--- +title: 算術運算子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/算術運算子 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Arithmetic_Operators +--- +

 

+

算術運算子

+

算術運算子把數值（字面表達或變數其中一種）作為運算元，並返回 1 個數值。標準的算術運算子有加法 (+)、減法 (-)、乘法 (*)、除法 (/)。這些運算子在大部分的程式語言中，都以原來的方式運作。當使用於浮點數時（須特別注意，除以零會產生 NaN）︰

+
1 / 2      // 在 JavaScript 中返回 0.5
+1 / 2      // 在 Java 中返回 0（這兩個數並未明確表示為浮點數）
+
+1.0 / 2.0  // 在 JavaScript 和 Java 中都返回 0.5
+
+

此外，JavaScript 提供了列於下表的算術運算子。

+ +
運算子 說明 範例
%（模數） 二元運算子。返回兩數相除之後的整數餘數。 12 % 5 返回 2。
++（遞增） 一元運算子。運算元加 1。如果用作為前綴運算子 (++x)，返回運算元加 1 之後的值；如果用作為後綴運算子 (x++)，返回運算元加 1 之前的值。 如果 x 是 3，然後 ++x 把 x 設為 4 並返回 4，反之 x++ 返回 3，然後把 x 設為 4。
--（遞減） 一元運算子。運算元減 1。返回的值和遞增運算子類似。 如果 x 是 3，然後 --x 把 x 設為 2 並返回 2，反之 x-- 返回 3，然後把 x 設為 2。
-（正負反轉） 一元運算子。返回將運算子的正負號反轉的值。 如果 x 是 3，然後 -x 返回 -3。
+

表 3.4: 算術運算子

+

{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:比較運算子", "Core_JavaScript_1.5_教學:運算子:位元運算子") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_aritm\u00e9ticos", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_arithm\u00e9tiques", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Arithmetic_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operatory_arytmetyczne" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_11969cb29fead65c26360f554426c217/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_11969cb29fead65c26360f554426c217/index.html new file mode 100644 index 0000000000..6109b2d6e3 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_11969cb29fead65c26360f554426c217/index.html @@ -0,0 +1,31 @@ +--- +title: 位元運算子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/位元運算子 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Bitwise_Operators +--- +

 

+

 

+

位元運算子

+

位元運算子把他們的運算元視為一組 32 位元的集合（零或一），而非十進制、十六進制、八進制。例如，十進制數 9 的二進制表示法為 1001。位元運算子對這些二進制表示法進行運算，並返回標準的 JavaScript 數值。

+

下表解說 JavaScript 的位元運算子。

+ +
運算子 用法 說明
位元 AND a & b 每一個對應至同一位元位置的兩個運算元兩者為 1 時，返回 1。
位元 OR a | b 每一個對應至同一位元位置的兩個運算元兩者或其中一者為 1 時，返回 1。
位元 XOR a ^ b 每一個對應至同一位元位置的兩個運算元其中一者而非兩者為 1 時，返回 1。
位元 NOT ~ a 反轉運算元的位元。
左移 a << b 往左移動 a 的二進制表示法 b 位元，從右邊補 0。
維持符號右移 a >> b 往右移動 a 的二進制表示法 b 位元，丟棄移出的位元。
填 0 右移 a >>> b 往右移動 a 的二進制表示法 b 位元，丟棄移出的位元，並從左邊補 0。
+

表 3.5: 位元運算子

+

位元邏輯運算子

+

大致上，位元邏輯運算子的運作如下︰

+ +

舉個例子，9 的二進制表示法是 1001，15 的二進制表示法是 1111。因此，當位元的運算子套用到這些值上時，結果如下︰

+ +

位元位移運算子

+

位元位移運算子有兩個運算元︰第一個是被移動的數值，第二個指定第一個運算元要移動的位元位置的數目。位移運算元的方向是以使用的運算元來控制。

+

位移運算子轉換這些運算元為 32 位元整數，並返回與左邊運算元同類型的結果。

+

位移運算子列於下表。

+ +
運算子 說明 範例
<<（左移） 這個運算子把第一個運算元向左移動指定的位元數。丟棄向左移出的多餘位元。從右邊填補 0 的位元。 9<<2 的結果是 36，因為 1001 向左移動 2 位元而變成 100100，此即 36。
>>（維持符號右移） 這個運算子把第一個運算元向右移動指定的位元數。丟棄向右移出的多餘位元。從左邊填補在最左邊複製的位元。 9>>2 的結果是 2，因為 1001 向右移動 2 位元而變成 10，此即 2。同樣的，-9>>2 的結果是 -3，因為保留了正負號。
>>>（填 0 右移） 這個運算子把第一個運算元向右移動指定的位元數。丟棄向右移出的多餘位元。從右邊填補 0 的位元。 19>>>2 的結果是 4，因為 10011 向右移動 2 位元而變成 100，此即 4。對於非負數而言，補 0 右移和維持符號右移的結果相同。
+

表 3.6: 位元位移運算子

+

{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:算術運算子", "Core_JavaScript_1.5_教學:運算子:邏輯運算子") }}

+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Bitwise_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_sobre_bits", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_bit-\u00e0-bit", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Bitwise_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Bitwise_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operatory_bitowe" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_351a6d9e4d31b32eff9762ef5deead93/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_351a6d9e4d31b32eff9762ef5deead93/index.html new file mode 100644 index 0000000000..7ba467a3cf --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_351a6d9e4d31b32eff9762ef5deead93/index.html @@ -0,0 +1,43 @@ +--- +title: 邏輯運算子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/邏輯運算子 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Logical_Operators +--- +

 

+

邏輯運算子

+

邏輯運算子通常和布林（邏輯）值一起使用，並返回布林值。然而，&& 和 || 運算子實際上返回的是指定的運算元的其中一個的值，所以如果這些運算子與非布林值一起使用，有可能返回非布林值。邏輯運算子的說明如下表。

+ +
運算子 用法 說明
&& expr1 && expr2 （邏輯 AND）如果 expr1 可以轉換為 false，就返回 expr1。否則返回 expr2。所以，當使用於布林值時，如果兩個運算元都為 true，&& 返回 true。否則返回 false。
|| expr1 || expr2 （邏輯 OR）如果 expr1 可以轉換為 true，就返回 expr1。否則返回 expr2。所以，當使用於布林值時，如果其中一個運算元為 true，|| 返回 true，如果兩個運算元都為 false，就返回 false。
! !expr （邏輯 NOT）如果運算元可以轉換為 true，就返回 false。否則返回 true。
+

表 3.7: 邏輯運算子

+

可以轉換成 false 的表達式的例子有︰對 null、0、空字串 ("") 或 undefined 求值。

+

以下代碼為 &&（邏輯 AND）運算子的範例。

+
a1=true && true       // t && t 返回 true
+a2=true && false      // t && f 返回 false
+a3=false && true      // f && t 返回 false
+a4=false && (3 == 4)  // f && f 返回 false
+a5="Cat" && "Dog"     // t && t 返回 Dog
+a6=false && "Cat"     // f && t 返回 false
+a7="Cat" && false     // t && f 返回 false
+
+

以下代碼為 ||（邏輯 OR）運算子的範例。

+
o1=true || true       // t || t 返回 true
+o2=false || true      // f || t 返回 true
+o3=true || false      // t || f 返回 true
+o4=false || (3 == 4)  // f || f 返回 false
+o5="Cat" || "Dog"     // t || t 返回 Cat
+o6=false || "Cat"     // f || t 返回 Cat
+o7="Cat" || false     // t || f 返回 Cat
+
+

以下代碼為 !（邏輯 NOT）運算子的範例。

+
n1=!true              // !t 返回 false
+n2=!false             // !f 返回 true
+n3=!"Cat"             // !t 返回 false
+
+

求值的最短路徑

+

由於邏輯表達式是由左往右求值，他們使用以下規則來測試，儘可能以“最短路徑”求值︰

+ +

這些邏輯規則保證求出的值永遠正確。注意，上述表達式中的 anything 部分並未求值，因此所有未求值的部分都不會產生作用。

+

{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:位元運算子", "Core_JavaScript_1.5_教學:運算子:字串運算子") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Logical_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_l\u00f3gicos", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_logiques", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Logical_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Logical_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operatory_logiczne" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_952d66f1fe521bc0574c89750f5b406e/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_952d66f1fe521bc0574c89750f5b406e/index.html new file mode 100644 index 0000000000..a37ea47e50 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_952d66f1fe521bc0574c89750f5b406e/index.html @@ -0,0 +1,186 @@ +--- +title: 特殊運算子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/特殊運算子 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Special_Operators +--- +

 

+

特殊運算子

+

JavaScript 提供下列的特殊運算子︰

+ +

條件運算子

+

條件運算子是 JavaScript 唯一使用三個運算元的運算子。運算子根據條件得到兩個值的其中一個。語法為︰

+
condition ? val1 : val2
+
+

如果 condition 為 true，運算子得到 val1 的值。否則得到 val2 的值。你可以在條件運算子上使用標準運算子。

+

例如，

+
status = (age >= 18) ? "adult" : "minor"
+
+

這個語句把“adult”的值代入給變數 status，只要 age 是 18 以上。否則，把“minor”的值代入給 status。

+

逗號運算子

+

逗號運算子 (,) 簡單的對他的兩個運算元求值，並返回第二個運算元的值。這個運算子主要用在 for 迴圈內部，使多個變數可在每一次的循環中更新。

+

例如，如果 a 是各邊含有 10 個元素的二維陣列，以下代碼使用逗號運算子同時遞增兩個變數。這個代碼在陣列裡輸出斜三角元素︰

+
for (var i=0, j=9; i <= 9; i++, j--)
+   document.writeln("a["+i+"]["+j+"]= " + a[i][j])
+
+

delete

+

delete 運算子可刪除物件、物件的屬性、陣列中指定索引的元素。語法為︰

+
delete objectName
+delete objectName.property
+delete objectName[index]
+delete property // 只在 with 語法之內有效
+
+

此處的 objectName 是指物件的名稱，property 是指現存的屬性，index 是指陣列中以整數表示的元素位置。

+

第四種於物件中刪除屬性的形式，只在 with 語法之內有效。

+

你可以使用 delete 運算子刪除以隱式宣告、沒有使用 var 語法的變數。

+

如果 delete 運算子成功的話，他會把屬性或元素設定為 undefined。如果操作是可行的話，delete 運算子返回 true；如果操作不可行，就返回 false。

+
x=42
+var y= 43
+myobj=new Number()
+myobj.h=4      // 建立屬性 h
+delete x       // 返回 true（如果以隱式宣告，就可以刪除）
+delete y       // 返回 false（如果以 var 宣告，就不能刪除）
+delete Math.PI // 返回 false（預先定義的屬性不能刪除）
+delete myobj.h // 返回 true（使用者定義的屬性可以刪除）
+delete myobj   // 返回 true（如果以隱式宣告，就可以刪除）
+

刪除陣列裡的元素
+當你刪除陣列元素時，陣列的長度並不受影響。舉例來說，如果你刪除 a{{ mediawiki.external(3) }}，a{{ mediawiki.external(4) }} 仍然是 {{ mediawiki.external(4) }}，a{{ mediawiki.external(3) }} 則是 undefined。

+

當 delete 運算子移除陣列的元素時，這個元素便不復存在於陣列之中。在以下範例中，使用 delete 移除 trees{{ mediawiki.external(3) }}。

+
trees=new Array("redwood","bay","cedar","oak","maple")
+delete trees[3]
+if (3 in trees) {
+   // 此處不會被執行
+}
+
+

如果你希望陣列元素存在、且元素的值是未定義，就使用 undefined 關鍵字取代 delete 運算子。在以下範例中，trees{{ mediawiki.external(3) }} 的值被代入為 undefined，而陣列元素仍然存在︰

+
trees=new Array("redwood","bay","cedar","oak","maple")
+trees[3]=undefined
+if (3 in trees) {
+   // 此處會被執行
+}
+

in

+

如果指定的屬性存在於指定的物件中，in 運算子返回 true。語法為︰

+
propNameOrNumber in objectName
+
+

此處 propNameOrNumber 是指表示為屬性名的字串、或表示為陣列索引的數值的表達式，objectName 是指物件的名稱。

+

以下範例示範 in 運算子的使用方法。

+
// 陣列
+trees=new Array("redwood","bay","cedar","oak","maple")
+0 in trees        // 返回 true
+3 in trees        // 返回 true
+6 in trees        // 返回 false
+"bay" in trees    // 返回 false（你必須指定索引編號，而不是索引上的值）
+"length" in trees // 返回 true（length 是 Array 的屬性）
+
+// 預先定義的物件
+"PI" in Math          // 返回 true
+myString=new String("coral")
+"length" in myString  // 返回 true
+
+// 自訂的物件
+mycar = {make:"Honda",model:"Accord",year:1998}
+"make" in mycar  // 返回 true
+"model" in mycar // 返回 true
+

instanceof

+

如果指定的物件屬於指定的物件的類型，instanceof 運算子返回 true。語法為︰

+
objectName instanceof objectType
+
+

此處 objectName 是指用來和 objectType 作比較的物件的名稱，objectType 是指物件的類型，如 Date 或 Array。

+

當你需要確認執行中物件的類型時，就使用 instanceof。舉個例子，當接受到例外時，你可以根據被拋出的例外來決定要執行哪一條例外處理。

+

例如，以下代碼使用 instanceof 確認 theDay 是否屬於 Date 物件。由於 theDay 屬於 Date 物件，所以會執行 if 語法裡的語句。

+
theDay=new Date(1995, 12, 17)
+if (theDay instanceof Date) {
+   // 被執行的語句
+}
+

new

+

你可以使用 new 運算子來建立使用者定義的物件類型的實體，或建立預先定義的物件類型 Array、Boolean、Date、Function、Image、Number、Object、Option、RegExp、String 其中之一。在伺服器上，你也可以用於 DbPool、Lock、File、SendMail。new 的使用方法如下︰

+
objectName = new objectType ( param1 [,param2] ...[,paramN] )
+
+

你也可以使用物件的初始化子來建立物件，如同 物件初始化子的使用 所述。

+

參閱 Core JavaScript 參考中的 new 運算子 頁面，以取得更多資訊。

this

+

使用 this 關鍵字可參考目前所使用的物件。一般而言，this 是在方法裡、並參考了呼叫這個方法的物件。this 的使用方法如下︰

+
this[propertyName]
+
+

範例 1
+假設有一個稱為 validate 的函數可驗證某一物件的 value 屬性，並以物件和上限、下限值作為參數︰

+
function validate(obj, lowval, hival) {
+   if ((obj.value < lowval) || (obj.value > hival))
+      alert("Invalid Value!")
+}
+
+

你可以在每一個表單元素的 onChange 事件處理器中呼叫 validate，並使用 this 傳送表單元素，如下範例︰

+
<B>Enter a number between 18 and 99:</B>
+<INPUT TYPE = "text" NAME = "age" SIZE = 3
+   onChange="validate(this, 18, 99)">
+
+

範例 2
+結合 form 屬性時，this 也可以參考目前所使用的物件的親表單。在以下範例中，表單 myForm 內含一個 Text 物件和按鈕。當使用者點擊按鈕，Text 物件的值便設定為表單的名稱。按鈕的 onClick 事件處理器使用 this.form 來參考親表單 myForm。

+
<FORM NAME="myForm">
+Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga">
+<P>
+<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
+   onClick="this.form.text1.value=this.form.name">
+</FORM>
+
+

typeof

+

typeof 運算子可按下列兩種方式來使用︰

+
1. typeof operand
+2. typeof (operand)
+
+

typeof 運算子可返回字串，這些字串指出未求值的運算元的類型。operand 是指字串、變數、關鍵字、物件，其類型可被 typeof 返回。括弧並非必要的。

+

假設你定義了以下變數︰

+
var myFun = new Function("5+2")
+var shape="round"
+var size=1
+var today=new Date()
+
+

typeof 運算子對以下變數返回以下結果︰

+
typeof myFun 返回的是 function
+typeof shape 返回的是 string
+typeof size 返回的是 number
+typeof today 返回的是 object
+typeof dontExist 返回的是 undefined
+
+

對於 true 和 null 關鍵字而言，typeof 運算子返回以下結果︰

+
typeof true 返回的是 boolean
+typeof null 返回的是 object
+
+

對於數字或字串而言，typeof 運算子返回以下結果︰

+
typeof 62 返回的是 number
+typeof 'Hello world' 返回的是 string
+
+

對於屬性值而言，typeof 運算子返回屬性裡的值的類型︰

+
typeof document.lastModified 返回的是 string
+typeof window.length 返回的是 number
+typeof Math.LN2 返回的是 number
+
+

對於方法和函數而言，typeof 運算子返回以下結果︰

+
typeof blur 返回的是 function
+typeof eval 返回的是 function
+typeof parseInt 返回的是 function
+typeof shape.split 返回的是 function
+
+

對於預先定義的物件而言，typeof 運算子返回以下結果︰

+
typeof Date 返回的是 function
+typeof Function 返回的是 function
+typeof Math 返回的是 function
+typeof Option 返回的是 function
+typeof String 返回的是 function
+
+

void

+

void 運算子可按下列兩種方式來使用︰

+
1. void (expression)
+2. void expression
+
+

void 運算子表示表達式求值之後不必把值返回。expression 是指可供求值的 JavaScript 表達式。表達式兩邊的圓括號並不是必要的，但圓括號的使用對閱讀有利。

+

你可以把 void 運算子使用於當作超連結的表達式。表達式會被求值，但不會被載入而取代目前的文件。

+

以下代碼建立了什麼也不做的超連結。當使用者點擊連結時，void(0) 的求值為 undefined，這在 JavaScript 中並沒有作用。

+
<A HREF="javascript:void(0)">Click here to do nothing</A>
+
+

以下代碼建立了超連結，當使用者點擊時，就傳送表單。

+
<A HREF="javascript:void(document.form.submit())">
+Click here to submit</A>
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:字串運算子", "Core_JavaScript_1.5_教學:正規表達式的建立") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_especiales", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_sp\u00e9ciaux", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/Special_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operatory_specjalne" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e6fc14473511cf01e7062dfb7751f49d/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e6fc14473511cf01e7062dfb7751f49d/index.html new file mode 100644 index 0000000000..5c6eb2fb16 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e6fc14473511cf01e7062dfb7751f49d/index.html @@ -0,0 +1,30 @@ +--- +title: 運算子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators +--- +

 

+

運算子

+

JavaScript 有以下幾種運算子。本節說明運算子，且包含有關運算子優先順序的資訊。

+ +

JavaScript 有一元和二元兩種運算子，以及特殊的三元運算子，也就是條件運算子。二元運算子需要兩個運算元，一個在運算子之前，一個在運算子之後︰

+
operand1 operator operand2
+
+

例如，3+4 或 x*y。

+

一元運算子需要一個運算元，可以運算子之前或之後︰

+
operator operand
+
+

或

+
operand operator
+
+

例如，x++ 或 ++x。

+

運算子的優先順序

+

按照相關的討論，本表採用由高到低的優先順序。

+ +
運算子類型 單獨的運算子
成員 .  []
呼叫 / 建立實體 ()  new
反轉 / 遞增 !  ~  -  +  ++  --  typeof  void  delete
乘法 / 除法 *  /  %
加法 / 減法 +  -
位元位移 <<  >>  >>>
關係 <  <=  >  >=  in  instanceof
等價 ==  !=  ===  !==
位元 AND &
位元 XOR ^
位元 OR |
邏輯 AND &&
邏輯 OR ||
條件 ?:
代入 =  +=  -=  *=  /=  %=  <<=  >>=  >>>=  &=  ^=  |=
逗號 ,
+

表 3.1: 運算子的優先順序

+

有關本表的詳細版本，且附有關於運算子的完整細節，請參閱 參考的章節。

+

{{ PreviousNext("Core_JavaScript_1.5_教學:表達式", "Core_JavaScript_1.5_教學:運算子:代入運算子") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs", "ja": "ja/Core_JavaScript_1.5_Guide/Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e70c1f2655520c542321ddbdb2c4f28d/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e70c1f2655520c542321ddbdb2c4f28d/index.html new file mode 100644 index 0000000000..31b103c23f --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e70c1f2655520c542321ddbdb2c4f28d/index.html @@ -0,0 +1,65 @@ +--- +title: 代入運算子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/代入運算子 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Comparison_Operators +--- +

 

+

代入運算子

+

代入運算子根據右邊運算元的值，把值代入給左邊運算元的值。最基本的代入運算子是等號 (=)，他會把右邊運算元的值代入給左邊運算元的值。也就是說，x = y 就是把 y 的值代入給 x。

+

其餘的代入運算子只是標準運算子的簡記法，如下表所示。

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
運算子的簡記法意義
x += yx = x + y
x -= yx = x - y
x *= yx = x * y
x /= yx = x / y
x %= yx = x % y
x <<= yx = x << y
x >>= yx = x >> y
x >>>= yx = x >>> y
x &= yx = x & y
x ^= yx = x ^ y
x |= yx = x | y
+

表 3.2: 代入運算子

+

{{ PreviousNext("Core_JavaScript_1.5_教學:運算子", "Core_JavaScript_1.5_教學:運算子:比較運算子") }}

+

 

diff --git a/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_eb65eb8f4e6b3c16f08b95149183cfb8/index.html b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_eb65eb8f4e6b3c16f08b95149183cfb8/index.html new file mode 100644 index 0000000000..0589aefd73 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_eb65eb8f4e6b3c16f08b95149183cfb8/index.html @@ -0,0 +1,12 @@ +--- +title: 字串運算子 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/字串運算子 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/String_Operators +--- +

 

+

字串運算子

+

除了比較運算子可以用於字串值以外，連結運算子 (+) 把兩個字串值串連在一起，返回另一個以兩個運算元字串連結的字串。例如，"my " + "string" 返回 "my string" 字串。

+

代入運算子 += 的簡記法也可用於連結字串。例如，如果變數 mystring 內有 "alpha" 值，mystring += "bet" 表達式的求值為“alphabet”，並把這個值代入到 mystring。

+

{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:邏輯運算子", "Core_JavaScript_1.5_教學:運算子:特殊運算子") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/String_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_de_cadenas_de_caracteres_(string)", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_li\u00e9s_aux_cha\u00eenes", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/String_Operators", "ko": "ko/Core_JavaScript_1.5_Guide/Operators/String_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operacje_na_\u0142a\u0144cuchach" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/functions/index.html b/files/zh-tw/conflicting/web/javascript/guide/functions/index.html new file mode 100644 index 0000000000..8999a04084 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions/index.html @@ -0,0 +1,34 @@ +--- +title: 函數的呼叫 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/函數的呼叫 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Calling_Functions +--- +

 

+
+

函數的呼叫

+

定義函數並不會執行函數。函數的定義只是簡單的給函數命名，並指定當函數被呼叫的時候要做些什麼。函數的呼叫會以指定的參數真正的執行指定的動作。例如，如果你定義了函數 square，你可以如下呼叫。

+
square(5)
+
+

上面的語句以 5 為參數呼叫函數。函數執行他的語句，並返回 25 的值。

+

函數的參數並不限於字串和數字。你也可以傳遞一整個物件給函數。show_props 函數（定義在 物件和屬性）即是接收一個物件作為參數的函數的範例。

+

函數甚至可以遞歸循環，也就是他可以呼叫他自己。例如，這裡有個計算階乘的函數︰

+
function factorial(n) {
+   if ((n == 0) || (n == 1))
+      return 1;
+   else {
+      var result = (n * factorial(n-1) );
+      return result;
+   }
+}
+
+

你可以計算一到五的階乘如下︰

+
a=factorial(1); // 返回 1
+b=factorial(2); // 返回 2
+c=factorial(3); // 返回 6
+d=factorial(4); // 返回 24
+e=factorial(5); // 返回 120
+
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:函數的定義", "Core_JavaScript_1.5_教學:arguments_物件的使用") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Calling_Functions", "fr": "fr/Guide_JavaScript_1.5/Appel_de_fonctions", "ja": "ja/Core_JavaScript_1.5_Guide/Calling_Functions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Wywo\u0142anie_funkcji" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/functions_536f6bf46bbdf38cc1a0b28ca1bc41b9/index.html b/files/zh-tw/conflicting/web/javascript/guide/functions_536f6bf46bbdf38cc1a0b28ca1bc41b9/index.html new file mode 100644 index 0000000000..0b44186a97 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_536f6bf46bbdf38cc1a0b28ca1bc41b9/index.html @@ -0,0 +1,36 @@ +--- +title: Number 和 String 函數 +slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/Number_和_String_函數 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/parseInt_and_parseFloat_Functions +--- +

Number 和 String 函數

+
+

Number 和 String 函數讓你把物件轉換為數字或字串。這些函數的語句是︰

+
var objRef=Number(objRef);
+var objRef=String(objRef);
+
+

此處的 objRef 就是物件的參考。

+

以下的範例把 Date 物件轉換為可讀的字串。

+
var D = new Date (430054663215);
+// 返回以下字串
+// "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983"
+var x = String(D);
+
+
+

 

+

以下範例把 String 物件轉換為 Number 物件。

+
var str="12";
+var num=Number(str);
+
+

你可以使用 DOM 的方法 write() 和 JavaScript 的 typeof 運算子來檢驗。

+
var str="12";
+document.write(typeof str);
+document.write("<br/>");
+var num=Number(str);
+document.write(typeof num);
+
+

 {{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:parseInt_和_parseFloat_函數", "Core_JavaScript_1.5_教學:預先定義的函數:escape_和_unescape_函數") }}

+

{{ languages( {"en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/Number_and_String_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_Number_y_String", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_Number_et_String", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/Number_and_String_Functions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_Number_i_String" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/functions_587eb671a310bac0771e73a91b0abe6d/index.html b/files/zh-tw/conflicting/web/javascript/guide/functions_587eb671a310bac0771e73a91b0abe6d/index.html new file mode 100644 index 0000000000..b44b292eb8 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_587eb671a310bac0771e73a91b0abe6d/index.html @@ -0,0 +1,15 @@ +--- +title: 預先定義的函數 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions +--- +

 

+
+

預先定義的函數

+

JavaScript 有一些最頂層的已預先定義的函數︰

+ +
+

{{ PreviousNext("Core_JavaScript_1.5_教學:arguments_物件的使用", "Core_JavaScript_1.5_教學:預先定義的函數:eval_函數") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Funkcje_predefiniowane" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/functions_925b2d10050621507a9c990cb803dcca/index.html b/files/zh-tw/conflicting/web/javascript/guide/functions_925b2d10050621507a9c990cb803dcca/index.html new file mode 100644 index 0000000000..d2ea7c4a46 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_925b2d10050621507a9c990cb803dcca/index.html @@ -0,0 +1,26 @@ +--- +title: isNaN 函數 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/isNaN_函數 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isNaN_Function +--- +

 

+
+

isNaN 函數

+

isNaN 函數對參數求值，來判斷是不是〝NaN〞（不是數字，not a number）。isNaN 的語句如下︰

+
isNaN(testValue)
+
+

此處的 testValue 就是你想要求值的值。

+

parseFloat 和 parseInt 函數會在求出來的值不是數字的時候返回〝NaN〞。如果傳入的是〝NaN〞，isNaN 返回 true，否則為 false。

+

以下的代碼會對 floatValue 求值，來判斷這是不是數字，然後呼叫相應的程序︰

+
floatValue=parseFloat(toFloat)
+
+if (isNaN(floatValue)) {
+   notFloat()
+} else {
+   isFloat()
+}
+
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:isFinite_函數", "Core_JavaScript_1.5_教學:預先定義的函數:parseInt_和_parseFloat_函數") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/isNaN_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_isNaN", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/isNaN_Function", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isNaN" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/functions_b2cd05cbfe188215dc2e3f972d293ed6/index.html b/files/zh-tw/conflicting/web/javascript/guide/functions_b2cd05cbfe188215dc2e3f972d293ed6/index.html new file mode 100644 index 0000000000..db213a465e --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_b2cd05cbfe188215dc2e3f972d293ed6/index.html @@ -0,0 +1,24 @@ +--- +title: isFinite 函數 +slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/isFinite_函數 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isFinite_Function +--- +

 

+
+

isFinite 函數

+

isFinite 函數會對參數求值，來判斷是否是有限的數字。isFinite 的語法如下︰

+
isFinite(number)
+
+

此處的 number 就是要求值的數字。

+

如果參數是 NaN、正無限大、負無限大，這個方法就會返回 false，否則就會返回 true。

+

以下的代碼會檢查客戶端的輸入，來判斷是否是有限的數字。

+
if(isFinite(ClientInput))
+{
+   /* 適當的處理 */
+}
+
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:eval_函數", "Core_JavaScript_1.5_教學:預先定義的函數:isNaN_函數") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/isFinite_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_isFinite", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/isFinite_Function", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_isFinite" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/functions_ceaa4b2a55bb67388c2728af1ff890f5/index.html b/files/zh-tw/conflicting/web/javascript/guide/functions_ceaa4b2a55bb67388c2728af1ff890f5/index.html new file mode 100644 index 0000000000..0533e2d1a4 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_ceaa4b2a55bb67388c2728af1ff890f5/index.html @@ -0,0 +1,21 @@ +--- +title: escape 和 unescape 函數 +slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/escape_和_unescape_函數 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/escape_and_unescape_Functions +--- +

 

+
+

escape 和 unescape 函數

+

escape 和 unescape 函數可讓你把字串編碼或解碼。escape 函數會返回以 ISO Latin 字元集來表示參數的十六進制編碼。unescape 函數會對指定的十六進制編碼值返回 ASCII 字串。

+

這些函數的語句是︰

+
escape(string)
+unescape(string)
+
+

這些函數主要是在伺服端的 JavaScript 用來編碼或解碼 URL 裡的名稱和值的配對。

+

escape 和 unescape 函數在非 ASCII 字元下無法正確運作，也已被廢棄。在 JavaScript 1.5 及其後版本中，可以改用 encodeURI、decodeURI、encodeURIComponent、decodeURIComponent。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:Number_和_String_函數", "Core_JavaScript_1.5_教學:閉鎖的運用") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/escape_and_unescape_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_escape_y_unescape", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_escape_et_unescape", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/escape_and_unescape_Functions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_escape_i_unescape" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/functions_effb9b1bcc102a5f6df7f1785ce89033/index.html b/files/zh-tw/conflicting/web/javascript/guide/functions_effb9b1bcc102a5f6df7f1785ce89033/index.html new file mode 100644 index 0000000000..fb257f891c --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_effb9b1bcc102a5f6df7f1785ce89033/index.html @@ -0,0 +1,17 @@ +--- +title: eval 函數 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/eval_函數 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/eval_Function +--- +

 

+
+

eval 函數

+

eval 函數無須參考實際的物件，就可以對 JavaScript 代碼的字串直接求值。eval 語法如下︰

+
eval(expr)
+
+

此處 expr 就是要被求值的字串。

+

如果字串表示成表達式，eval 就會對表達式求值。如果參數（expr）表示成一個以上的 JavaScript 語句，eval 就會對語句求值。eval 代碼的作用域等同於呼叫端代碼的作用域。不要用 eval 來對算術表達式求值，JavaScript 會自動的對算術表達式來求值。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數", "Core_JavaScript_1.5_教學:預先定義的函數:isFinite_函數") }}

+

{{ languages( {"en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/eval_Function", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/La_fonction_eval", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/eval_Function", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcja_eval" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types/index.html b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types/index.html new file mode 100644 index 0000000000..407d484a34 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types/index.html @@ -0,0 +1,33 @@ +--- +title: Unicode +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/Unicode +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Unicode +--- +

 

+

Unicode

+

Unicode 是一種全球通用的字元編碼標準，用於交換並顯示主要的書寫語言。Unicode 涵括了美國、歐洲、中東、非洲、印度、亞洲以及太平洋地區的語系，但不包括歷史手稿和專門符號。Unicode 可用於交換、處理並顯示多國語系的文書，除了一般的專門符號和數學符號以外。Unicode 期望能夠解決對於不同國家的字元標準的多國語言處理等國際化問題。但目前並未完整支援所有的現代或古代的文字。

+

Unicode 字元集可以使用所有已知編碼的字元。Unicode 是繼 ASCII（American Standard Code for Information Interchange；美國資訊交換標準碼）字元集之後的字元集模型。Unicode 為每一個字元分配一個數字和名稱。字元編碼規範了字元的識別資訊及其數值（編碼位置），但未指明數值的位元表示法。16 位元數值（編碼值）是以十六進制數並加上前綴 U 來定義的，例如，U+0041 表示 A。這個數值的專用名稱是 LATIN CAPITAL LETTER A。

+

JavaScript 1.3 以前的版本並不支援 Unicode。

+

Unicode 與 ASCII 和 ISO 的相容性

+

Unicode 完全相容於國際標準 ISO/IEC 10646-1; 1993，屬於 ISO 10646 的子集。

+

若干編碼標準（包括 UTF-8、UTF-16、ISO UCS-2）是用來把 Unicode 表示為實際的位元。

+

Unicode 的 UTF-8 編碼可相容於 ASCII 字元，並已有許多程式支援。並且把前 128 個 Unicode 字元對應至 ASCII 字元，而擁有相同的位元組內碼。從 U+0020 到 U+007E 的 Unicode 字元完全等價於從 0x20 到 0x7E 的 ASCII 字元。與 ASCII 不同之處在於，還支援了使用 7 位元字元集的拉丁字母，UTF-8 為各個字元使用 1 到 4 個位元組（原作“octet”，即位元組、8 位元），借此容納數以百萬計的字元。另一種編碼標準，UTF-16，使用 2 個位元組表示 Unicode 字元。藉由 4 位元組的跳脫序列，可讓 UTF-16 表示 Unicode 的全部範圍。ISO UCS-2（Universal Character Set）使用 2 個位元組。

+

JavaScript 和 Navigator 支援 UTF-8/Unicode，意味著你只需在 JavaScript 程式中加上特別的技術，就可以使用非拉丁文、國際性、地域性的文字。Unicode 為多國文字的編碼提供了標準方法。由於 Unicode 的 UTF-8 編碼可相容於 ASCII，程式可以使用 ASCII 字元。你可以在 JavaScript 的註解、字串的字面表達、識別子、正則表達式中使用非 ASCII 的 Unicode 字元。

+

Unicode 的跳脫序列

+

你可以在字串的字面表達、正則表達式、識別子中使用 Unicode 跳脫序列。跳脫序列是由 6 個 ASCII 字元所構成︰\u 和 4 個十六進制數。例如，\u00A9 表示版權符號。在 JavaScript 中，所有的 Unicode 跳脫序列都會被解譯為單一字元。

+

以下代碼返回版權符號和字串 "Netscape Communications"。

+
x="\u00A9 Netscape Communications"
+

下表列出最常用的特殊字元及其 Unicode 值。

+ +
分類 Unicode 值 名稱 格式名稱
空白的值 \u0009 Tab <TAB>
  \u000B Vertical Tab <VT>
  \u000C Form Feed <FF>
  \u0020 Space <SP>
行終止的值 \u000A Line Feed <LF>
  \u000D Carriage Return <CR>
額外的 Unicode 跳脫序列的值 \u0008 Backspace <BS>
  \u0009 Horizontal Tab <HT>
  \u0022 Double Quote "
  \u0027 Single Quote '
  \u005C Backslash \
+

表 2.2: 特殊字元的 Unicode 值

+

JavaScript 使用的 Unicode 跳脫序列與 Java 不同。在 JavaScript 中，跳脫序列一開始不會被解譯為特殊字元。例如，字串裡的換行的跳脫序列，在給函數解譯以前，並不會使字串換行。JavaScript 會忽略所有使用在註解裡的跳脫序列。在 Java 中，如果跳脫序列使用在單行註解裡，就會被解譯為 Unicode 字元。對於字串的字面表達而言，Java 編譯器將首先解譯跳脫序列。例如，如果在 Java 中使用換行的跳脫字元（即 \u000A），就會使字串的字面表達換行。這在 Java 中會引起錯誤，因為換行不可以用在字串的字面表達。你必須給字串的字面表達的換行替換成 \n。在 JavaScript 中，也同樣使用 \n 作為跳脫序列。

+

在 JavaScript 檔案裡的 Unicode 字元

+

Gecko 的早期版本假設從 XUL 載入的 JavaScript 檔案使用的是 Latin-1 字元編碼。從 Gecko 1.8 開始，就從 XUL 檔案的編碼來推斷字元編碼。請參閱 在 XUL JavaScript 中的國際化字元 取得進一步資訊。

+

使用 Unicode 顯示字元

+

你可以使用 Unicode 顯示不同語言或專門符號的字元。為使字元正確的顯示，像 Mozilla Firefox 或 Netscape 這類客戶端也需要支援 Unicode。此外，客戶端也必須有可用的 Unicode 字型，客戶端平台也必須支援 Unicode。通常，Unicode 字型並不會顯示所有的 Unicode 字元。部分平台，如 Windows 95，只提供對 Unicode 的一部分支援。

+

要接收非 ASCII 字元的輸入，客戶端需要把傳送進來的輸入視為 Unicode。使用標準的增強式鍵盤，客戶端無法簡單的輸入由 Unicode 支援的額外字元。在某些時候，使用 Unicode 跳脫序列輸入 Unicode 字元是唯一的輸入方法。

+

有關 Unicode 的詳細資訊，參閱 Unicode 首頁 以及 1996 年由 Addison-Wesley 出版的 Unicode Standard, Version 2.0。

+

{{ PreviousNext("Core_JavaScript_1.5_教學:字面表達", "Core_JavaScript_1.5_教學:表達式") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Unicode", "es": "es/Gu\u00eda_JavaScript_1.5/Unicode", "fr": "fr/Guide_JavaScript_1.5/Unicode", "ja": "ja/Core_JavaScript_1.5_Guide/Unicode", "ko": "ko/Core_JavaScript_1.5_Guide/Unicode", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Unicode" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_5c6f30ff8e011c45a011b9c8f3b5bcea/index.html b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_5c6f30ff8e011c45a011b9c8f3b5bcea/index.html new file mode 100644 index 0000000000..bea630e438 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_5c6f30ff8e011c45a011b9c8f3b5bcea/index.html @@ -0,0 +1,30 @@ +--- +title: 值 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/值 +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Values +--- +

 

+

值

+

JavaScript 識別下列值的類型︰

+ +

這是相對來說比較小的一組值的類型，也就是資料類型，可讓你的應用程式發揮出有用的功能。整數和實數之間並沒有明顯的區別。在 JavaScript 中也沒有明確的日期資料類型。不過你還是可以使用 Date 物件及其方法來處理日期。物件 和 函數 也是語言的基礎元素。你可以把物件想成已命名的值的容器，而函數是使程式可以執行的處理程序。

+

資料類型的轉換

+

JavaScript 是動態類型的語言。這表示當你宣告變數時，你不必指定變數的資料類型，而且資料類型會在 Script 執行過程中按需要自動的轉換。所以，舉例如下，你可以如下定義變數︰

+
var answer = 42;
+
+

然後，你可以把字串值代入給值，如下︰

+
answer = "Thanks for all the fish...";
+
+

因為 JavaScript 的類型是動態的，這個代入的代碼不會引起錯誤訊息。

+

在含有數值和字串值並介以 + 運算子的表達式中，JavaScript 把數值轉換為字串。例如，考慮下面的語句︰

+
x = "The answer is " + 42 // 返回 "The answer is 42"
+y = 42 + " is the answer" // 返回 "42 is the answer"
+
+

在含有其他運算子的語句裡，JavaScript 不會把數值轉換為字串。例如︰

+
"37" - 7 // 返回 30
+"37" + 7 // 返回 "377"
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:JavaScript_概要", "Core_JavaScript_1.5_教學:變數") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Values", "es": "es/Gu\u00eda_JavaScript_1.5/Valores", "fr": "fr/Guide_JavaScript_1.5/Valeurs", "ja": "ja/Core_JavaScript_1.5_Guide/Values", "ko": "ko/Core_JavaScript_1.5_Guide/Values", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Warto\u015bci", "zh-cn": "cn/Core_JavaScript_1.5_Guide/Values" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_d57082c2207b466127d8dc34a980addf/index.html b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_d57082c2207b466127d8dc34a980addf/index.html new file mode 100644 index 0000000000..0c66b79359 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_d57082c2207b466127d8dc34a980addf/index.html @@ -0,0 +1,118 @@ +--- +title: 字面表達 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/字面表達 +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Literals +--- +

 

+

字面表達

+

你在 JavaScript 使用字面表達來表示值。這是由你在 Script 中直接寫下的固定值，這些不是變數。本節說明下列各類型的字面表達︰

+ +

陣列的字面表達

+

陣列的字面表達是以零個以上的表達式所構成的列表，列表的每一項代表陣列的元素，以方括號 ([]) 包夾。當你使用陣列的字面表達建立陣列時，陣列會以指定的值作為元素來初始化，也會以指定的參數個數來設定陣列的長度。

+

以下範例以三個元素和長度建立 coffees 陣列︰

+
var coffees = ["French Roast", "Colombian", "Kona"];
+
+

附註: 陣列的字面表達是物件初始化子的一種類型。參閱 物件初始化子的使用。

+

如果在頂層 Script 裡使用字面表達建立陣列，每一次對含有陣列的字面表達的表達式求值時，JavaScript 就會解譯這些陣列。此外，每一次呼叫函數時，在函數中使用的字面表達就會被建立。

+

陣列的字面表達也是 Array 物件。參閱 Array 物件 取得有關 Array 物件的細節。

+

陣列的字面表達的額外的逗號

+

你不必在陣列的字面表達中指定所有的元素。如果你放上兩個連續的逗號，就會為未指定的元素預留空間來建立陣列。以下範例建立 fish 陣列︰

+
var fish = ["Lion", , "Angel"];
+
+

這個陣列含有兩個附有值的元素和一個空的元素（fish{{ mediawiki.external(0) }} 是“Lion”，fish{{ mediawiki.external(1) }} 是 undefined，fish{{ mediawiki.external(2) }} 是“Angel”）。

+

如果你在元表列表的尾部附帶逗號，這個逗號會被忽略。在下面的範例中，陣列的長度是 3，這裡不存在 myList{{ mediawiki.external(3) }}。所在位於列表裡面的逗號指的都是新的元素。

+
var myList = ['home', , 'school', ];
+
+

在下面的範例中，陣列的長度是 4，myList{{ mediawiki.external(0) }} 和 myList{{ mediawiki.external(2) }} 是空的。

+
var myList = [ , 'home', , 'school'];
+
+

在下面的範例中，陣列的長度是 4，myList{{ mediawiki.external(1) }} 和 myList{{ mediawiki.external(3) }} 是空的。只有最後面的逗號被忽略。

+
var myList = ['home', , 'school', , ];
+

布林的字面表達

+

布林類型有兩種字面表達︰true 和 false。

+

別被原始布林值的 true、false 和 Boolean 物件的 true、false 的值混淆了。Boolean 物件是以原始布林資料類型包裝起來的。參閱 Boolean 物件 取得更多資訊。

整數

+

整數可以表示為十進制、十六進制、八進制。十進制整數的字面表達由一系列不以 0 開頭的數字組成。以 0 開頭的整數的字面表達表示他是八進制，以 0x（或 0X）開頭表示十六進制。十六進制整數可以包含數字 (0-9) 和 a-f 和 A-F 的字母。八進制整數只可以包含 0-7 的數字。

+

八進制整數的字面表達在 ECMA-262 第三版的標準中已不被推薦。JavaScript 1.5 為了向後相容，仍然繼續支援。

+

整數的字面表達的一些範例︰

+
0、117、-345（十進制）
+015、0001、-077（八進制）
+0x1123、0x00111、-0xF1A7（十六進制）
+
+

浮點數的字面表達

+

浮點數的字面表達可分為以下部分︰

+ +

指數部分是以一個“e”或“E”後接數字所組成，可帶正負符號（在前面加上“+”或“-”）。浮點數的字面表達至少必須要有一個數字和一個小數點或“e”（或“E”）。

+

浮點數的字面表達的一些範例有 3.1415、-3.1E12、.1e12、2E-12。

+

表示成更精簡的語法結構是︰

+
[digits][.digits][(E|e)[(+|-)]digits]
+
+

例如︰

+
3.14
+2345.789
+.3333333333333333333
+
+

物件的字面表達

+

物件的字面表達是以零個以上的 屬性名稱-關聯值 的配對所構成，以花括號 ({}) 包夾。你不應該在語句的開始處使用物件的字面表達。這會導致錯誤，或出現非預期的行為，因為 { 會被解譯成區塊的開始處。

+

以下是物件的字面表達的範例。car 物件的第一個元素定義了 myCar 屬性；第二個元素，getCar 屬性，含有函數 (CarTypes("Honda"));；第三個元素，special 屬性，使用了現存的變數（Sales）。

+
var Sales = "Toyota";
+
+function CarTypes(name) {
+  if (name == "Honda")
+     return name;
+  else
+     return "Sorry, we don't sell " + name + ".";
+}
+
+var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };
+
+document.write(car.myCar);   // Saturn
+document.write(car.getCar);  // Honda
+document.write(car.special); // Toyota
+
+

此外，你可以使用數值或字串的字面表達作為屬性的名稱，或者嵌入其他的物件。以下是上述的範例。

+
var car = { manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda" };
+
+document.write(car.manyCars.b); // Jeep
+document.write(car[7]); // Mazda
+
+

請注意︰

+
var foo = {a: "alpha", 2: "two"};
+document.write(foo.a);    // alpha
+document.write(foo[2]);   // two
+//document.write(foo.2);  // 錯誤: 參數列表後面少了 )
+//document.write(foo[a]); // 錯誤: a 尚未定義
+document.write(foo["a"]); // alpha
+document.write(foo["2"]); // two
+

字串的字面表達

+

字串的字面表達是以零個以上的字元所構成，並以雙引號 (") 或單引號 (') 包夾。字串必須以相同的引號包夾，也就是成對的單、雙引號。以下是字串的字面表達的範例︰

+ +

你可以在字串的字面表達的值上呼叫 String 物件的所有方法—JavaScript 會自動的把字串的字面表達轉換成臨時的 String 物件，呼叫方法，然後丟棄臨時的 String 物件。你也可以使用 String.length 屬性︰

+ +

除非你特別使用 String 物件，否則就應該使用字串的字面表達。參閱 String 物件 取得有關 String 物件的細節。

+
在字串中使用特殊字元
+

除了普通的字元以外，你也可以在字串中包含特殊字元，如下範例︰

+
"one line \n another line"
+
+

下表列出了你可以使用於 JavaScript 字串中的特殊字元。

+ +
字元 意義
\b 後退一格
\f 換頁
\n 換行
\r 歸位
\t Tab
\v 垂直 Tab
\' 單引號
\" 雙引號
\\ 反斜線 (\)。
\XXX 使用介於 0 至 377 之間的三個八進制數 XXX 來表示以 Latin-1 編碼的字元。例如，\251 是版權符號的八進制內碼序列。
\xXX 使用介於 00 至 FF 之間的兩個十六進制數 XX 來表示以 Latin-1 編碼的字元。例如，\xA9 是版權符號的十六進制內碼序列。
\uXXXX 使用四個十六進制數 XXXX 來表示 Unicode 字元。例如，\u00A9 是版權符號的 Unicode 內碼序列。參閱 Unicode 的跳脫序列。
+

表 2.1: JavaScript 的特殊字元

+
字元的跳脫
+

對於未列在表 2.1 的字元，加在前面的反斜線將會被忽略，但是這個作法已被建議廢除，應該要避免。

+

你可以在字串裡面的引號前面插入反斜線。這就是引號的跳脫。例如︰

+
var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
+document.write(quote);
+
+

結果會是︰

+
He read "The Cremation of Sam McGee" by R.W. Service.
+
+

要在字串裡包含反斜線，你必須跳脫反斜線字元。例如，要把檔案路徑 c:\temp 代入成字串，方法如下︰

+
var home = "c:\\temp";
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:常數", "Core_JavaScript_1.5_教學:Unicode") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Literals", "es": "es/Gu\u00eda_JavaScript_1.5/Literales", "fr": "fr/Guide_JavaScript_1.5/Constantes_litt\u00e9rales", "ja": "ja/Core_JavaScript_1.5_Guide/Literals", "ko": "ko/Core_JavaScript_1.5_Guide/Literals", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Litera\u0142y", "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u6587\u672c\u5316" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_e5a53691c318855e3342ad91feb78f2e/index.html b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_e5a53691c318855e3342ad91feb78f2e/index.html new file mode 100644 index 0000000000..9eedc7a21a --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_e5a53691c318855e3342ad91feb78f2e/index.html @@ -0,0 +1,28 @@ +--- +title: 常數 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/常數 +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Constants +--- +

 

+

常數

+

你可以使用 const 關鍵字建立唯讀的常數。常數識別子的語法和變數識別子的相同︰以字母或底線開頭，可以包含字母、數值、底線字元。

+
const prefix = '212';
+
+

在 Script 執行時，常數不可以藉由代入或重新宣告來改變值。

+

常數的作用域規則和變數一樣，除了 const 關鍵字即使是全域常數也一直是必要的。如果省略了關鍵字，識別子就會被認定為變數。

+

你不可以在同一個作用域裡，使用和函數或變數的同樣的名稱來宣告常數。例如︰

+
// 這會引起錯誤
+function f() {};
+const f = 5;
+
+// 這也會引起錯誤
+function f() {
+  const g = 5;
+  var g;
+
+  //其他語句
+}
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:變數", "Core_JavaScript_1.5_教學:字面表達") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Constants", "es": "es/Gu\u00eda_JavaScript_1.5/Constantes", "fr": "fr/Guide_JavaScript_1.5/Constantes", "ja": "ja/Core_JavaScript_1.5_Guide/Constants", "ko": "ko/Core_JavaScript_1.5_Guide/Constants", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Sta\u0142e" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_ef6fc79abc28f5eadd6c126341df5e49/index.html b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_ef6fc79abc28f5eadd6c126341df5e49/index.html new file mode 100644 index 0000000000..151736f40c --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_ef6fc79abc28f5eadd6c126341df5e49/index.html @@ -0,0 +1,57 @@ +--- +title: 變數 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/變數 +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Variables +--- +

 

+

變數

+

你會在你的應用程式中使用變數作為值的名稱。變數的名稱稱為識別子，並遵守以下規則。

+

JavaScript 識別子必須以字母、底線 (_)、美金符號 ($) 開頭；之後的字元就可以使用數字 (0-9)。因為 JavaScript 區分大小寫，字母包括從“A”到“Z”的字元（大寫）和從“a”到“z”的字元（小寫）。

+

從 JavaScript 1.5 開始，你可以在識別子中使用 ISO 8859-1 或 Unicode 字母，如 å、ü。你也可以使用表列於 Unicode 跳脫序列 頁面的 \uXXXX 的 Unicode 跳脫序列作為識別子。

+

合規則的名稱例子有 Number_hits、temp99 和 _name。

+

變數的宣告

+

你可以使用兩個方法宣告變數︰

+ +

變數的求值

+

使用 var 語法宣告、且沒有初始值的變數，這個變數的值是 undefined。

+

企圖存取未宣告的變數，將導致 ReferenceError 例外的拋出︰

+
var a;
+print("The value of a is " + a); // 輸出 "a 的值是 undefined"
+print("The value of b is " + b); // 拋出 ReferenceError 例外
+
+

你可以使用 undefined 確認變數是否有值。在下列代碼中，變數 input 尚未代入值，所以 if 語法求出的是 true。

+
var input;
+if(input === undefined){
+  doThis();
+} else {
+  doThat();
+}
+
+

在用於布林邏輯時，undefined 值會被視為 false。例如，下面的代碼會執行函數 myFunction，因為 myArray 元素尚未定義︰

+
var myArray = new Array();
+if (!myArray[0]) myFunction();
+
+

當你對 null 變數求值時，null 值在用於數值時會被視為 0，而在用於布林邏輯時則視為 false。例如︰

+
var n = null;
+print(n * 32); // 輸出 0
+

變數的作用域

+

當你在任何函數之外宣告變數時，這個變數就稱為全域變數，因為這個變數可以在整份文件中的任何代碼裡使用。當你在函數之內宣告變數時，這個變數就稱為局域變數，因為這個變數只能在函數之內使用。

+

JavaScript 的 區塊語法 並沒有作用域；在區塊之內的代碼不會是局域的。例如在下面的代碼中，如果 condition 是 false，結果會輸出 0，而不是拋出例外︰

+
if (condition) {
+  var x = 5;
+}
+print(x ? x : 0);
+
+

另一個在 JavaScript 中關於變數的獨特行為是，你可以參考稍後才會宣告的變數，而不會引起例外︰

+
print(x === undefined); // 輸出 "true"
+var x = 3;
+
+

全域變數

+

全域變數其實就是全域物件的屬性。在 Web 頁面中，全域物件是 window，所以你可以使用 window.variable 語法設定並存取全域變數。

+

因此，你可以從另一個視窗或框架，藉由指定視窗或框架的名稱，來存取宣告在視窗或框架裡的全域變數。例如，如果有一個稱為 phoneNumber 的變數是在 FRAMESET 文件中宣告，你可以從名為 parent.phoneNumber 的子框架參考這個變數。

+

參閱

+

JavaScript 的 Sharp 變數

+

{{ PreviousNext("Core_JavaScript_1.5_教學:值", "Core_JavaScript_1.5_教學:常數") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Variables", "es": "es/Gu\u00eda_JavaScript_1.5/Variables", "fr": "fr/Guide_JavaScript_1.5/Variables", "ja": "ja/Core_JavaScript_1.5_Guide/Variables", "ko": "ko/Core_JavaScript_1.5_Guide/Variables", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Zmienne", "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u53d8\u91cf" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/index.html b/files/zh-tw/conflicting/web/javascript/guide/index.html new file mode 100644 index 0000000000..7f8133da58 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/index.html @@ -0,0 +1,452 @@ +--- +title: 陣列的運用 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/陣列的運用 +translation_of: Web/JavaScript/Guide +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Working_with_Arrays +--- +

陣列是值的有序序列。有別於其他的語言，JavaScript 並沒有明確的陣列資料類型。取而代之，提供了 Array 物件，可以直接實體化或使用陣列的字面表達記法。

+ +

Array 物件有以各種方式操作陣列的方法，如合併、反轉、排序。他有一個用來指定陣列長度的屬性。JavaScript 也提供有用的陣列的字面表達語法，用來建立這些物件。

+ +

陣列的建立

+ +

陣列可以使用字面表達語法（通常是首選）或使用 Array 的建構子（也可以稱作函數，兩者行為完全相同）來建立︰

+ +
var colors = ["Red", "Green", "Blue"];
+var colors = new Array("Red", "Green", "Blue");
+var colors = Array("Red", "Green", "Blue");
+
+ +

陣列具有 length 屬性，提供來存取陣列的長度。如果你使用上述其中一個例子來初始化陣列，陣列的長度將會是 3︰

+ +
print(colors.length); // 3
+
+ +

在建立陣列的時候，如果你知道你的陣列的預期長度，你可以給 Array 的建構子傳入長度︰

+ +
var fiveItems = new Array(5);
+
+ +

明確定義長度並不會影響陣列的實際容量；這樣只會影響新陣列的 length 屬性。（陣列本身並沒有小於指定值的索引的屬性。）構建子的變體極少使用到。

+ +

JavaScript 1.7 引入陣列的簡約式作為建立新陣列的捷徑；下面 會討論。

+ +

陣列元素的運用

+ +

你可以透過把值代入給陣列元素的方式儲存陣列。下面是我們的範例 colors 陣列更為完整的實例︰

+ +
var colors = []; // 空陣列
+print(colors.length); // 0
+
+colors[0] = 'Red';
+colors[1] = 'Green';
+colors[2] = 'Blue';
+print(colors.length); // 3
+
+ +

附加元素至陣列的末端的常見習慣是使用 array.length 作為索引︰

+ +
colors[colors.length] = 'Orange';
+
+ +

可以使用 array.push() 方法達到同樣效果︰

+ +
colors.push('Purple');
+
+ +

陣列的元素使用元素的索引來存取。陣列是以 0 開始索引，因此陣列中的第一個元素是 0︰

+ +
var red = colors[0];
+
+ +

可以使用各式各樣的陣列方法來存取陣列的元素。例如，pop() 方法移除並返回陣列的最後一個元素︰

+ +
var lastElement = colors.pop(); /* colors 的最後一個元素也被移除 */
+
+ +

理解 length

+ +

以實作的層級來說，JavaScript 的陣列實際上把元素存放成標準的物件屬性，並使用陣列的索引作為屬性的名稱。length 屬性很特別；他永遠會返回比保存在陣列中的最高索引值再高一的值︰

+ +
var cats = [];
+cats[30] = ['Dusty'];
+print(cats.length); // 31
+
+ +

你也可以把值代入給 length 屬性。寫下小於陣列中已存放的項目的數目，就會截掉其餘的項目；寫下 0 就完全清空陣列︰

+ +
var cats = ['Dusty', 'Misty', 'Twiggy'];
+print(cats.length); // 3
+
+cats.length = 2;
+print(cats); // 輸出 "Dusty,Misty" - Twiggy 被移除了
+
+cats.length = 0;
+print(cats); // 什麼也沒輸出；cats 陣列是空的
+
+ +

迭代整個陣列

+ +

常見的操作就是迭代所有陣列的值，並以同樣方式處理每一個值。做到這一點的最簡單的方式如下︰

+ +
var colors = ['red', 'green', 'blue'];
+for (var i = 0; i < colors.length; i++) {
+  alert(colors[i]);
+}
+
+ +

如果你知道陣列中沒有一個元素會在布林的求值結果中為 false - 如果你的陣列只以 DOM 的結點組成，例如，你可以使用更有效率的習慣︰

+ +
var divs = document.getElementsByTagName('div');
+for (var i = 0, div; div = divs[i]; i++) {
+  /* 以同樣方式處理 div */
+}
+
+ +

這樣可以避免檢查陣列長度的開支，並且確保 div 變數被重新指定到每一次循環的使用中項目，以方便加入。

+ +

 forEach 方法是在 JavaScript 1.6 引入的，提供了另一種迭代陣列的方式︰

+ +
var colors = ['red', 'green', 'blue'];
+colors.forEach(function(color) {
+  alert(color);
+});
+
+ +

傳給 forEach 的函數會在陣列中的每一個項目中執行一次，並把陣列的項目傳給函數作為參數。

+ +

Array 的方法

+ +

Array 物件有以下的方法︰

+ + + +
var a1 = [1, 2, 3];
+var a2 = a1.concat(['a', 'b', 'c']);
+print(a2); // 1,2,3,a,b,c
+
+ + + +
var a = ['Wind', 'Rain', 'Fire'];
+print(a.join(' - ')); // "Wind - Rain - Fire"
+
+ + + +
var a = [1, 2, 3];
+var last = a.pop();
+print(a); // 1,2
+print(last); // 3
+
+ + + +
var a = [1, 2];
+a.push(3);
+print(a); // 1,2,3
+
+ + + +
var a = [1, 2, 3, 4];
+a.reverse();
+print(a); // 4,3,2,1
+
+ + + +
var a = [1, 2, 3];
+var first = a.shift();
+print(a); // 2,3
+print(first); // 警報 1
+
+ + + +
var a1 = [1, 2, 3];
+a1.unshift(4);
+print(a1); // 4,1,2,3
+
+ + + +
var a1 = ['a', 'b', 'c', 'd', 'e'];
+var a2 = a1.slice(1, 4);
+print(a2); // 警報 b,c,d
+
+ + + +
var a = ['a', 'b', 'c', 'd', 'e'];
+var removed = a.splice(1, 3, 'f', 'g', 'h', 'i');
+print(removed); // b,c,d
+print(a); // a,f,g,h,i,e
+
+ + + +
var a = ['Wind', 'Rain', 'Fire'];
+a.sort();
+print(a); // Fire,Rain,Wind
+
+ +

sort 也可以接受 Callback 函數來決定如何排序陣列的內容。這個函數會對兩個值做比較，並返回下列三個值其中之一︰

+ + + +

例如，下面的例子會以字串的最後一個字母來排序︰

+ +
var a = ['Wind', 'Rain', 'Fire'];
+function sortFn(a, b) {
+  var lastA = a[a.length - 1];
+  var lastB = b[b.length - 1];
+  if (lastA < lastB) return -1;
+  if (lastA > lastB) return 1;
+  if (lastA == lastB) return 0;
+}
+a.sort(sortFn);
+print(a); // Wind,Fire,Rain
+
+ +

於 JavaScript 1.6 引入

+ + + +

 

+ +
   var a = ['a', 'b', 'a', 'b', 'a'];
+   alert(a.indexOf('b')); // 警報 1
+   // 現在再試一次，從最後的符合項之後的索引開始
+   alert(a.indexOf('b', 2)); // 警報 3
+   alert(a.indexOf('z')); // 警報 -1，因為找不到 'z'
+
+ +

 

+ + + +

 

+ +
   var a = ['a', 'b', 'c', 'd', 'a', 'b'];
+   alert(a.lastIndexOf('b')); // 警報 5
+   // 現在再試一次，從最後的符合項之前的索引開始
+   alert(a.lastIndexOf('b', 4)); // 警報 1
+   alert(a.lastIndexOf('z')); // 警報 -1
+
+ +

 

+ + + +

 

+ +
   var a = ['a', 'b', 'c'];
+   a.forEach(alert); // 依序警報每一個項目
+
+ +

 

+ + + +

 

+ +
   var a1 = ['a', 'b', 'c'];
+   var a2 = a1.map(function(item) { return item.toUpperCase(); });
+   alert(a2); // 警報 A,B,C
+
+ +

 

+ + + +

 

+ +
   var a1 = ['a', 10, 'b', 20, 'c', 30];
+   var a2 = a1.filter(function(item) { return typeof item == 'number'; });
+   alert(a2); // 警報 10,20,30
+
+ +

 

+ + + +

 

+ +
   function isNumber(value) { return typeof value == 'number'; }
+   var a1 = [1, 2, 3];
+   alert(a1.every(isNumber)); // 警報 true
+   var a2 = [1, '2', 3];
+   alert(a2.every(isNumber)); // 警報 false
+
+ +

 

+ + + +

 

+ +
   function isNumber(value) { return typeof value == 'number'; }
+   var a1 = [1, 2, 3];
+   alert(a1.some(isNumber)); // 警報 true
+   var a2 = [1, '2', 3];
+   alert(a2.some(isNumber)); // 警報 true
+   var a3 = ['1', '2', '3'];
+   alert(a3.some(isNumber)); // 警報 false
+
+ +

 

+ +

上面接受 Callback 的方法又稱為迭代方法，因為他們會以同樣的方式迭代整個陣列。其中第二個選用性的參數稱為 thisObject。如果有提供的話，thisObject 會變成 Callback 函數的本體內部的 this 關鍵字的值。

+ +

實際上 Callback 函數會以三個參數來呼叫。第一個是使用中項目的值，第二個是他的陣列索引，第三個是陣列本身的參考。JavaScript 函數會忽略任何沒有在參數列表中命名的參數，因此提供只接受單一參數的 Callback 函數也很安全，如 alert。

+ +

於 JavaScript 1.8 引入

+ + + +

 

+ +
   var a = [10, 20, 30];
+   var total = a.reduce(function(first, second) { return first + second; }, 0);
+   alert(total) // 警報 60
+
+ +

 

+ + + +

reduce 和 reduceRight 明顯是迭代陣列的方法中最少的。為了把序列降至單一的值，應該把他們用於遞歸合併兩個值的演算法。

+ +

近似陣列的物件的運用

+ +

 某些 JavaScript 物件，如 document.getElementsByTagName 返回的 NodeList，或者在函數本體內部可以利用的 arguments 物件，表面上看來外觀和行為和陣列很類似，但並未共用所有的方法。例如，arguments 物件提供 length 屬性，但並未實作 forEach 方法。

+ +

在 JavaScript 1.6 中引入的通用陣列，為其他類似陣列的物件提供執行 Array 方法的途徑。每一個標準的陣列方法在 Array 物件本身都有相對應的方法；例如︰

+ +
 function alertArguments() {
+   Array.forEach(arguments, function(item) {
+     alert(item);
+   });
+ }
+
+ +

這些通用方法可以在舊版本的 JavaScript 中，使用由 JavaScript 函數物件所提供的 call 方法，以更冗長的形式模擬。

+ +
 Array.prototype.forEach.call(arguments, function(item) {
+   alert(item);
+ });
+
+ +

陣列的通用方法也可以使用在字串上，因為字串提供的對字元循序存取的方式，和陣列的很類似︰

+ +
 Array.forEach("a string", function(char) {
+   alert(char);
+ });
+
+ +

二維陣列

+ +

下面的代碼建立二維陣列。

+ +
var a = [];
+for (i = 0; i < 4; i++) {
+   a[i] = [];
+   for (j = 0; j < 4; j++) {
+      a[i][j] = "[" + i + ", " + j + "]";
+   }
+}
+
+ +

本例以如下的行來建立陣列︰

+ +
行 0: [0,0][0,1][0,2][0,3]
+行 1: [1,0][1,1][1,2][1,3]
+行 2: [2,0][2,1][2,2][2,3]
+行 3: [3,0][3,1][3,2][3,3]
+
+ +

陣列的簡約式

+ +

在 JavaScript 1.7 中引入的陣列簡約式（array comprehension），對於以其他內容為基礎來建構新陣列提供了很有用的捷徑。簡約式通常可以用在 map() 和 filter() 呼叫的地方，或是結合這兩者的方式。

+ +

下面的簡約式接收數字的陣列，並建立每一個數字的雙倍的新陣列。

+ +
var numbers = [1, 2, 3, 4];
+var doubled = [i * 2 for each (i in numbers)];
+alert(doubled); // 警報 2,4,6,8
+
+ +

這等同於下面的 map() 操作︰

+ +
var doubled = numbers.map(function(i) { return i * 2; });
+
+ +

簡約式也可以用於選取符合特定表達式的項目。這是只選取偶數的簡約式︰

+ +
var numbers = [1, 2, 3, 21, 22, 30];
+var evens = [i for each (i in numbers) if (i % 2 == 0)];
+alert(evens); // 警報 2,22,30
+
+ +

filter() 也可以用於同樣的用途︰

+ +
var evens = numbers.filter(function(i) { return i % 2 == 0; });
+
+ +

map() 和 filter() 這類型的操作可以合併至單一的陣列簡約式。這是只篩出偶數的簡約式，然後建立內含雙倍數值的新陣列。

+ +
var numbers = [1, 2, 3, 21, 22, 30];
+var doubledEvens = [i * 2 for each (i in numbers) if (i % 2 == 0)];
+alert(doubledEvens); // 警報 4,44,60
+
+ +

陣列簡約式的方括號導入了默許的作用域區塊。新的變數（如範例中的 i）會被視為已經使用 let 宣告過了。其意義是不能在簡約式的外部使用這些變數。

+ +

輸入到陣列的簡約式本身並不需要是陣列；也可以使用 迭代器和產生器。

+ +

{{ PreviousNext("Core_JavaScript_1.5_教學:繼承", "Core_JavaScript_1.5_教學:迭代器和產生器") }}

+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Working_with_Arrays" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/regular_expressions/index.html b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions/index.html new file mode 100644 index 0000000000..792eec13b9 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions/index.html @@ -0,0 +1,59 @@ +--- +title: 正規表達式的運用 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用 +translation_of: Web/JavaScript/Guide/Regular_Expressions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions +--- + +

正規表達式的運用

+

RegExp 的 test 和 exec 方法，還有 String 的 match、replace、search、split 方法都有使用到正規表達式。這些方法在 Core JavaScript 參考 中已有詳細說明。

+ +
方法 說明
exec RegExp 的方法，在字串中比對以執行搜尋。他會返回搜尋資訊的陣列。
test RegExp 的方法，在字串中比對以進行測試。他會返回 true 或 false。
match String 的方法，在字串中比對以執行搜尋。他會返回搜尋資訊的陣列，或在比對不出時返回 null。
search String 的方法，在字串中比對以進行測試。他會返回符合比對的索引，或在搜尋失敗時返回 -1。
replace String 的方法，在字串中比對以執行搜尋，並以其他子字串取代符合比對的子字串。
split String 的方法，使用正規表達式或固定的字串，把字串分割為子字串的陣列。
+

表 4.2: 使用了正規表達式的方法

+

當你想知道是否可以在字串裡找出某個模式，可以使用 test 或 search 方法。要更詳細的資訊（不過執行速度也慢）可以使用 exec 或 match 方法。如果你使用 exec 或 match 並且比對成功，這些方法會返回陣列，並更新相關聯的正規表達式物件包括預先定義的 RegExp 的屬性，如果比對失敗，exec 方法返回 null（可轉換為 false）。

+

在以下的範例中，Script 使用了 exec 方法來在字串裡尋找符合的字串。

+
<SCRIPT type="text/javascript">
+  myRe = /d(b+)d/g;
+  myArray = myRe.exec("cdbbdbsbz");
+</SCRIPT>
+
+

如果你不需要存取正規表達式的屬性，另一個建立 myArray 的方式如下 Script︰

+
<SCRIPT type="text/javascript">
+  myArray = /d(b+)d/g.exec("cdbbdbsbz");
+</SCRIPT>
+
+

如果你想要從字串來建構正規表達式，還有其他選擇如下 Script︰

+
<SCRIPT type="text/javascript">
+  myRe = new RegExp ("d(b+)d", "g");
+  myArray = myRe.exec("cdbbdbsbz");
+</SCRIPT>
+
+

這些 Script 比對成功並返回陣列，並更新顯示在下表中的屬性。

+ +
物件 屬性或索引 說明 上面的範例
myArray   比對符合的字串和所有已記憶的子字串。 {{ mediawiki.external('\"dbbd\", \"bb\"') }}
  index 在輸入的字串中比對符合的索引位置。索引從 0 開始。 1
  input 原始的字串。 "cdbbdbsbz"
  {{ mediawiki.external(0) }} 最後一次比對符合的字元。 "dbbd"
myRe lastIndex 下一個符合項的開始處的索引位置。（這個屬性只在正規表達式使用 g 選項時設定，選項的說明在 使用標誌的進階搜尋。） 5
  source 模式的文字。在正規表達式建立時更新，而非執行時。 "d(b+)d"
+

表 4.3: 正規表達式的執行結果。

+

如上第二個範例所示，你可以藉由物件的初始化子使用正規表達式，而無需代入到變數裡。然而，如果你這樣做的話，每一次使用的都會是新的正規表達式。因此，如果你使用這個形式而不代入到變數，之後你就沒辦法存取正規表達式的屬性。舉例來說，假設你有這個 Script︰

+
<SCRIPT type="text/javascript">
+  myRe = /d(b+)d/g;
+  myArray = myRe.exec("cdbbdbsbz");
+  document.writeln("The value of lastIndex is " + myRe.lastIndex);
+</SCRIPT>
+
+

Script 顯示︰

+
The value of lastIndex is 5
+
+

然而，如果你有這個 Script︰

+
<SCRIPT type="text/javascript">
+  myArray = /d(b+)d/g.exec("cdbbdbsbz");
+  document.writeln("The value of lastIndex is " + /d(b+)d/g.lastIndex);
+</SCRIPT>
+
+

他會顯示︰

+
The value of lastIndex is 0
+
+

/d(b+)d/g 在兩個語句中是不同的正規表達式物件，也因此各自對 lastIndex 屬性有著不同的變數。如果你需要存取以物件初始化子所建立的正規表達式的屬性，你應該先把他代入到變數裡。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式模式的編寫", "Core_JavaScript_1.5_教學:正規表達式的運用:括弧子字串的比對結果的運用") }}

+
+

{{ languages( {"en": "en/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions", "es": "es/Gu\u00eda_JavaScript_1.5/Trabajar_con_expresiones_regulares", "fr": "fr/Guide_JavaScript_1.5/Travailler_avec_les_expressions_rationnelles", "ja": "ja/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Praca_z_wyra\u017ceniami_regularnymi" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_24eb6498b86da57e7fb5337fd8fa04a6/index.html b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_24eb6498b86da57e7fb5337fd8fa04a6/index.html new file mode 100644 index 0000000000..8abec68f16 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_24eb6498b86da57e7fb5337fd8fa04a6/index.html @@ -0,0 +1,44 @@ +--- +title: 括弧子字串的比對結果的運用 +slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用/括弧子字串的比對結果的運用 +translation_of: Web/JavaScript/Guide/Regular_Expressions#Using_Parenthesized_Substring_Matches +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions/Using_Parenthesized_Substring_Matches +--- +

括弧子字串的比對結果的運用

+

在正規表達式的模式中包含括弧，對應的子比對結果就會被記憶。舉例來說，/a(b)c/ 比對字元 'abc' 並把 'b' 記憶起來。若要取回括弧子字串的比對結果，就使用 Array 元素 {{ mediawiki.external(1) }}, ..., {{ mediawiki.external('n') }}。

+

括弧子字串的可能數目並沒有限制。返回的陣列保留了所有找到的子字串。以下範例解說如何使用括弧子字串的比對結果。

+

範例 1
+以下 Script 使用 replace 方法來置換字串裡的文字。對於那些替換用的文字，Script 使用了 $1 和 $2 來表示第一個和第二個括弧子字串的比對結果。

+
<script type="text/javascript">
+ re = /(\w+)\s(\w+)/;
+ str = "John Smith";
+ newstr = str.replace(re, "$2, $1");
+ document.write(newstr);
+</script>
+
+

本例輸出 "Smith, John"。

+

範例 2
+附註: 在 getInfo 函數中，exec 方法是以 () 省略記法所呼叫的，這個記法在 Firefox 可以運作，其他瀏覽器則不一定。

+
<html>
+
+<script type="text/javascript">
+ function getInfo(field){
+   var a = /(\w+)\s(\d+)/(field.value);
+   window.alert(a[1] + ", your age is " + a[2]);
+ }
+</script>
+
+Enter your first name and your age, and then press Enter.
+
+<form>
+  <input type="text" name="NameAge" onchange="getInfo(this);">
+</form>
+
+</html>
+
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的運用", "Core_JavaScript_1.5_教學:正規表達式的運用:使用標誌的進階搜尋") }}

+
+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Using_Parenthesized_Substring_Matches", "es": "es/Gu\u00eda_JavaScript_1.5/Trabajar_con_expresiones_regulares/Usar_coincidencias_de_subcadenas_parentizadas", "fr": "fr/Guide_JavaScript_1.5/Travailler_avec_les_expressions_rationnelles/Utilisation_des_parenth\u00e8ses_de_capture", "ja": "ja/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Using_Parenthesized_Substring_Matches", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Praca_z_wyra\u017ceniami_regularnymi/U\u017cycie_odpowiedniego_znaku" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_38b32725e0e3217a5542b1b4ee122407/index.html b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_38b32725e0e3217a5542b1b4ee122407/index.html new file mode 100644 index 0000000000..2dce68e5a9 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_38b32725e0e3217a5542b1b4ee122407/index.html @@ -0,0 +1,37 @@ +--- +title: 使用標誌的進階搜尋 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用/使用標誌的進階搜尋 +translation_of: Web/JavaScript/Guide/Regular_Expressions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions/Advanced_Searching_With_Flags +--- +

使用標誌的進階搜尋

+

正規表達式有四個選用的標誌，這些標誌可用於全域或不分大小寫等的搜尋。若要指明為全域搜尋，就使用 g 標誌。若要指明為區分大小寫來搜尋，就使用 i 標誌。若要指明為在多行中搜尋，就使用 m 標誌。若要進行“定點”搜尋，也就是以目標字串的目前位置為開始點來搜尋，那就使用 y 標誌。這些標誌可以單獨或不分順序混合使用，並作為正規表達式的一部分。

+

{{ Fx_minversion_note(3, "Firefox 3 新增了對 y 標誌的支援。如果在目標字串的目前位置上比對不成功，y 標誌就會失敗。") }}

+

要在正規表達式中包含標誌，使用以下語法︰

+
re = /pattern/flags
+re = new RegExp("pattern", ["flags"])
+
+

注意，標誌也是正規表達式整體的一部分。之後就不能新增或移除標誌。

+

舉例來說，re = /\w+\s/g 建立了可尋找 1 個以上的字元並且後接空白的正規表達式，並找出整個字串的組合部分。

+
<script type="text/javascript">
+ re = /\w+\s/g;
+ str = "fee fi fo fum";
+ myArray = str.match(re);
+ document.write(myArray);
+</script>
+
+

顯示出 {{ mediawiki.external('\"fee \", \"fi \", \"fo \"') }}。在這個範例中，你可以取代一整行︰

+
re = /\w+\s/g;
+
+

改用︰

+
re = new RegExp("\\w+\\s", "g");
+
+

得到同樣的結果。

+

m 標誌用來指明輸入的多行字串應該視為多行。如果使用 m 標誌，^ 和 $ 就會在輸入字串裡比對每一行的開始處和結尾處，而非整個字串的開始處和結尾處。

+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的運用:括弧子字串的比對結果的運用", "Core_JavaScript_1.5_教學:正規表達式的運用:正規表達式的範例") }}

+
+

 

+

 

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Advanced_Searching_With_Flags", "es": "es/Gu\u00eda_JavaScript_1.5/Trabajar_con_expresiones_regulares/Ejecutar_una_busqueda_global,_discriminar_mayusculas_y_minusculas_y_considerar_entrada_multil\u00ednea", "fr": "fr/Guide_JavaScript_1.5/Travailler_avec_les_expressions_rationnelles/Ex\u00e9cution_de_recherches_globales,_ignorer_la_casse,_utilisation_de_cha\u00eenes_multilignes", "ja": "ja/Core_JavaScript_1.5_Guide/Working_with_Regular_Expressions/Advanced_Searching_With_Flags", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Praca_z_wyra\u017ceniami_regularnymi/Globalne_wyszukiwanie,_wielko\u015b\u0107_znak\u00f3w,_wieloliniowe_wej\u015bcie" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide/working_with_objects/index.html b/files/zh-tw/conflicting/web/javascript/guide/working_with_objects/index.html new file mode 100644 index 0000000000..fc10840076 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/working_with_objects/index.html @@ -0,0 +1,43 @@ +--- +title: 物件和屬性 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/物件和屬性 +translation_of: Web/JavaScript/Guide/Working_with_Objects +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Objects_and_Properties +--- +

 

+

物件和屬性

+

JavaScript 的物件連結有屬性。你只需要使用簡單的記法就能存取物件的屬性︰

+
objectName.propertyName
+
+

物件的名稱和屬性的名稱兩者都區分大小寫。你可藉由給他代入值來定義屬性。例如，假設有名為 myCar 的物件（假設物件已經存在）。你可以把他的屬性命名為 make、model、year 如下所示︰

+
myCar.make = "Ford";
+myCar.model = "Mustang";
+myCar.year = 1969;
+
+

JavaScript 物件的屬性也可以使用方括號記法來存取或設定。物件有時又稱為關聯陣列，因為每一個屬性都和字串值連繫在一起，且可以用這些字串值來存取屬性。然後，舉例來說，你可以存取 myCar 物件的屬性如下所示︰

+
myCar["make"] = "Ford";
+myCar["model"] = "Mustang";
+myCar["year"] = 1969;
+
+

你也可以使用儲存在變數裡的字串值來存取屬性︰

+
var propertyName = "make";
+myCar[propertyName] = "Ford";
+
+propertyName = "model";
+myCar[propertyName] = "Mustang";
+
+

你也可以使用括弧和 for...in 來迭代物件所有的屬性。為解說這是如何運作的，以下函數用來顯示物件的屬性，當你把物件和物件的名稱作為參數傳給這個函數的時候︰

+
function show_props(obj, obj_name) {
+   var result = "";
+   for (var i in obj)
+      result += obj_name + "." + i + " = " + obj[i] + "\n";
+   return result;
+}
+
+

然後，呼叫函數 show_props(myCar, "myCar") 就會返回以下內容︰

+
myCar.make = Ford
+myCar.model = Mustang
+myCar.year = 1969
+
+

{{ PreviousNext("Core_JavaScript_1.5_教學:閉包的運用", "Core_JavaScript_1.5_教學:建立新的物件") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Objects_and_Properties", "es": "es/Gu\u00eda_JavaScript_1.5/Objetos_y_propiedades", "fr": "fr/Guide_JavaScript_1.5/Objets_et_propri\u00e9t\u00e9s", "ja": "ja/Core_JavaScript_1.5_Guide/Objects_and_Properties", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Obiekty_i_w\u0142asno\u015bci" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/guide_dc05b578fe0c2f7d9a89ed82daab4e65/index.html b/files/zh-tw/conflicting/web/javascript/guide_dc05b578fe0c2f7d9a89ed82daab4e65/index.html new file mode 100644 index 0000000000..181d55974e --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide_dc05b578fe0c2f7d9a89ed82daab4e65/index.html @@ -0,0 +1,13 @@ +--- +title: 預先定義的核心物件 +slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件 +translation_of: Web/JavaScript/Guide +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Core_Objects +--- +

 

+

預先定義的核心物件

+

本節解說在核心 JavaScript 裡預先定義的物件︰

+ +

{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:屬性的刪除", "Core_JavaScript_1.5_教學:預先定義的核心物件:Array_物件") }}

+

{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "es": "es/Gu\u00eda_JavaScript_1.5/Objetos_base_predefinidos", "fr": "fr/Guide_JavaScript_1.5/Objets_pr\u00e9d\u00e9finis", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "ko": "ko/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Obiekty_predefiniowane" } ) }}

diff --git a/files/zh-tw/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html b/files/zh-tw/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html new file mode 100644 index 0000000000..263726d7e0 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/global_objects/arraybuffer/index.html @@ -0,0 +1,111 @@ +--- +title: ArrayBuffer.prototype +slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer +translation_of_original: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype +--- +
{{JSRef}}
+ +

The ArrayBuffer.prototype property represents the prototype for the {{jsxref("ArrayBuffer")}} object.

+ +
{{js_property_attributes(0,0,0)}}
+ +

描述

+ +

ArrayBuffer instances inherit from ArrayBuffer.prototype. As with all constructors, you can change the constructor's prototype object to make changes to all ArrayBuffer instances.

+ +

屬性

+ +
+
ArrayBuffer.prototype.constructor
+
Specifies the function that creates an object's prototype. The initial value is the standard built-in ArrayBuffer constructor.
+
{{jsxref("ArrayBuffer.prototype.byteLength")}} {{readonlyInline}}
+
陣列大小，以位元組（byte）計算。此屬性在陣列建立之後就不可能改變了。唯讀。
+
+ +

方法

+ +
+
{{jsxref("ArrayBuffer.prototype.slice()")}}
+
Returns a new ArrayBuffer whose contents are a copy of this ArrayBuffer's bytes from begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.
+
+ +

規範

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}{{Spec2('ESDraft')}} 
+ +

瀏覽器相容性

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support7.0{{ CompatGeckoDesktop("2")}}1011.65.1
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support4.0{{CompatVersionUnknown}}{{CompatGeckoMobile("2")}}1011.64.2
+
+ +

參見

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/global_objects/date/index.html b/files/zh-tw/conflicting/web/javascript/reference/global_objects/date/index.html new file mode 100644 index 0000000000..5490743ec0 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/global_objects/date/index.html @@ -0,0 +1,246 @@ +--- +title: Date.prototype +slug: Web/JavaScript/Reference/Global_Objects/Date/prototype +tags: + - Date + - JavaScript + - 原型 + - 參考資料 + - 屬性 +translation_of: Web/JavaScript/Reference/Global_Objects/Date +translation_of_original: Web/JavaScript/Reference/Global_Objects/Date/prototype +--- +
{{JSRef}}
+ +

Date.prototype 屬性表示 {{jsxref("Date")}} 建構子的原型。

+ +
{{js_property_attributes(0, 0, 1)}}
+ +

描述

+ +

JavaScript {{jsxref("Date")}} 實體繼承自 Date.prototype。你可以藉由改變建構子的原型物件，來影響所有繼承自 JavaScript {{jsxref("Date")}} 的實體。

+ +

為了千年年份（換個說法，考慮現在已到了 2000 年）的相容性，設定上你應該採用完整的年份。舉例來說，使用 1998 而不是 98 。為了讓你能取得完整的年份資料， Javascript 包含了 {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}} ， {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} ， {{jsxref("Date.prototype.getUTCFullYear()", "getUTCFullYear()")}} 以及 {{jsxref("Date.prototype.setUTCFullYear()", "setUTCFullYear()")}} 方法。

+ +

自 ECMAScript 6 開始， Date.prototype 物件只是個一般物件，而不是一個 {{jsxref("Date")}} 實體。

+ +

屬性

+ +
+
Date.prototype.constructor
+
回傳一個能建立實體的函數，這是 {{jsxref("Date")}} 預設的建構子。
+
+ +

方法

+ +

Getter

+ +
+
{{jsxref("Date.prototype.getDate()")}}
+
回傳本地時間月份中的日期（1-31）。
+
{{jsxref("Date.prototype.getDay()")}}
+
回傳本地時間星期中的日子（0-6）。
+
{{jsxref("Date.prototype.getFullYear()")}}
+
回傳本地時間的年份（ 以 4 位數表現）。
+
{{jsxref("Date.prototype.getHours()")}}
+
回傳本地時間的小時（0-23）。
+
{{jsxref("Date.prototype.getMilliseconds()")}}
+
回傳本地時間的毫秒數（0-999）。
+
{{jsxref("Date.prototype.getMinutes()")}}
+
回傳本地時間的分鐘數（0-59）。
+
{{jsxref("Date.prototype.getMonth()")}}
+
回傳本地時間的月份（0-11）。
+
{{jsxref("Date.prototype.getSeconds()")}}
+
回傳本地時間的秒數（0-59)。
+
{{jsxref("Date.prototype.getTime()")}}
+
回傳由 1970-01-01 00:00:00 UTC 開始，到代表時間經過的毫秒數（以負值表示 1970 年之前的時間）。
+
{{jsxref("Date.prototype.getTimezoneOffset()")}}
+
回傳本地時差為多少分鐘。
+
{{jsxref("Date.prototype.getUTCDate()")}}
+
回傳標準時間的在月份中的日期（1-31）。
+
{{jsxref("Date.prototype.getUTCDay()")}}
+
回傳標準時間在星期中的日子（0-6）。
+
{{jsxref("Date.prototype.getUTCFullYear()")}}
+
回傳標準時間的年份（ 以 4 位數表現）。
+
{{jsxref("Date.prototype.getUTCHours()")}}
+
回傳標準時間的小時數（0-23）。
+
{{jsxref("Date.prototype.getUTCMilliseconds()")}}
+
回傳標準時間裡的毫秒數（0-999）。
+
{{jsxref("Date.prototype.getUTCMinutes()")}}
+
回傳標準時間的分鐘數（0-59）。
+
{{jsxref("Date.prototype.getUTCMonth()")}}
+
回傳標準時間的月份數（0-11）。
+
{{jsxref("Date.prototype.getUTCSeconds()")}}
+
回傳標準時間的秒數（0-59）。
+
{{jsxref("Date.prototype.getYear()")}} {{deprecated_inline}}
+
回本地時間的年份（通常 2-3 位數）。用 {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}} 取代。
+
+ +

Setter

+ +
+
{{jsxref("Date.prototype.setDate()")}}
+
設定本地時間月份中的日期。
+
{{jsxref("Date.prototype.setFullYear()")}}
+
設定本地時間的完整年份（以 4 位數表達 4 位數年份）。
+
{{jsxref("Date.prototype.setHours()")}}
+
設定本地時間的小時數。
+
{{jsxref("Date.prototype.setMilliseconds()")}}
+
設定本地時間的毫秒數。
+
{{jsxref("Date.prototype.setMinutes()")}}
+
設定本地時間的分鐘數。
+
{{jsxref("Date.prototype.setMonth()")}}
+
設定本地時間的月份。
+
{{jsxref("Date.prototype.setSeconds()")}}
+
設定本地時間的秒數。
+
{{jsxref("Date.prototype.setTime()")}}
+
設定這個 {{jsxref("Date")}} 物件距 1970-01-01 00:00:00 UTC 的毫秒數，允許使用負值表示之前的時間。
+
{{jsxref("Date.prototype.setUTCDate()")}}
+
設定標準時間月份中的日期。
+
{{jsxref("Date.prototype.setUTCFullYear()")}}
+
設定標準時間的完整年份（以 4 位數表示 4 位數年分）。
+
{{jsxref("Date.prototype.setUTCHours()")}}
+
設定標準時間的小時數。
+
{{jsxref("Date.prototype.setUTCMilliseconds()")}}
+
設定標準時間的毫秒數。
+
{{jsxref("Date.prototype.setUTCMinutes()")}}
+
設定標準時間的分鐘數。
+
{{jsxref("Date.prototype.setUTCMonth()")}}
+
設定標準時間的月份數。
+
{{jsxref("Date.prototype.setUTCSeconds()")}}
+
設定標準時間的秒數。
+
{{jsxref("Date.prototype.setYear()")}} {{deprecated_inline}}
+
設定本地時間的年份（使用 2-3 位數）。使用 {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} 取代。
+
+ +

Conversion getter

+ +
+
{{jsxref("Date.prototype.toDateString()")}}
+
以可閱讀的字串型式，回傳 {{jsxref("Date")}} 的部分資訊。
+
{{jsxref("Date.prototype.toISOString()")}}
+
將日期時間轉換成 ISO 8601 格式的字串回傳。
+
{{jsxref("Date.prototype.toJSON()")}}
+
回傳等義於 {{jsxref("Date")}} 物件使用 {{jsxref("Date.prototype.toISOString()", "toISOString()")}} 方法的結果。特別使用 {{jsxref("JSON.stringify()")}} 處理。
+
{{jsxref("Date.prototype.toGMTString()")}} {{deprecated_inline}}
+
回傳 {{jsxref("Date")}} 以 GMT (UT) 時區基準代表的時間字串。使用 {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}} 方法來取代。
+
{{jsxref("Date.prototype.toLocaleDateString()")}}
+
依照系統的時間地區設定，回傳日期字串。
+
{{jsxref("Date.prototype.toLocaleFormat()")}} {{non-standard_inline}}
+
傳入格式化字串參數，將日期時間轉換成指定格式的字串。
+
{{jsxref("Date.prototype.toLocaleString()")}}
+
回傳依系統的地區設定導出的日期時間字串。覆寫自 {{jsxref("Object.prototype.toLocaleString()")}} 方法。
+
{{jsxref("Date.prototype.toLocaleTimeString()")}}
+
回傳依系統的地區設定導出的時間字串。
+
{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}}
+
回傳一個建立相同 {{jsxref("Date")}} 物件的程式碼字串；你可以拿這個結果來建立新物件。覆寫自 {{jsxref("Object.prototype.toSource()")}} 方法。
+
{{jsxref("Date.prototype.toString()")}}
+
回傳代表此 {{jsxref("Date")}} 物件的字串。覆寫自 {{jsxref("Object.prototype.toString()")}} 方法。
+
{{jsxref("Date.prototype.toTimeString()")}}
+
以人類可讀的格式，回傳時間部分的字串。
+
{{jsxref("Date.prototype.toUTCString()")}}
+
依 UTC 時區，轉換出時間日期字串。
+
{{jsxref("Date.prototype.valueOf()")}}
+
回傳 {{jsxref("Date")}} 物件的原始數值。覆寫自 {{jsxref("Object.prototype.valueOf()")}} 方法。
+
+ +

規範

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
規範狀態註
{{SpecName('ES1')}}{{Spec2('ES1')}}初步定義。實作在 JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.9.5', 'Date.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}{{Spec2('ESDraft')}} 
+ +

瀏覽器相容性

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
平台ChromeFirefox (Gecko)Internet ExplorerOperaSafari
基本支援{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
一般物件{{CompatUnknown}}{{CompatGeckoDesktop("41")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
平台AndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
基本支援{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
一般物件{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile("41")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
diff --git a/files/zh-tw/conflicting/web/javascript/reference/global_objects/function/index.html b/files/zh-tw/conflicting/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..718454721b --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,139 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Reference/Global_Objects/Function/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Function +translation_of_original: Web/JavaScript/Reference/Global_Objects/Function/prototype +--- +
{{JSRef}}
+ +

Function.prototype 屬性表示 {{jsxref("Function")}} 的原型物件。

+ +

描述

+ +

{{jsxref("Function")}} objects inherit from Function.prototype.  Function.prototype cannot be modified.

+ +

屬性

+ +
+
{{jsxref("Function.arguments")}} {{deprecated_inline}}
+
An array corresponding to the arguments passed to a function. This is deprecated as property of {{jsxref("Function")}}, use the {{jsxref("Functions/arguments", "arguments")}} object available within the function instead.
+
{{jsxref("Function.arity")}} {{obsolete_inline}}
+
Used to specifiy the number of arguments expected by the function, but has been removed. Use the {{jsxref("Function.length", "length")}} property instead.
+
{{jsxref("Function.caller")}} {{non-standard_inline}}
+
Specifies the function that invoked the currently executing function.
+
{{jsxref("Function.length")}}
+
Specifies the number of arguments expected by the function.
+
{{jsxref("Function.name")}}
+
The name of the function.
+
{{jsxref("Function.displayName")}} {{non-standard_inline}}
+
The display name of the function.
+
Function.prototype.constructor
+
Specifies the function that creates an object's prototype. See {{jsxref("Object.prototype.constructor")}} for more details.
+
+ +

方法

+ +
+
{{jsxref("Function.prototype.apply()")}}
+
Calls a function and sets its this to the provided value, arguments can be passed as an {{jsxref("Array")}} object.
+
{{jsxref("Function.prototype.bind()")}}
+
Creates a new function which, when called, has its this set to the provided value, with a given sequence of arguments preceding any provided when the new function was called.
+
{{jsxref("Function.prototype.call()")}}
+
Calls (executes) a function and sets its this to the provided value, arguments can be passed as they are.
+
{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}
+
Returns true if the function is a generator; otherwise returns false.
+
{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}
+
Returns a string representing the source code of the function. Overrides the {{jsxref("Object.prototype.toSource")}} method.
+
{{jsxref("Function.prototype.toString()")}}
+
Returns a string representing the source code of the function. Overrides the {{jsxref("Object.prototype.toString")}} method.
+
+ +

規範

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.1
{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ESDraft')}} 
+ +

瀏覽器相容性

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

參見

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/global_objects/number/index.html b/files/zh-tw/conflicting/web/javascript/reference/global_objects/number/index.html new file mode 100644 index 0000000000..bfd57f3d21 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,85 @@ +--- +title: Number.prototype +slug: Web/JavaScript/Reference/Global_Objects/Number/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number +translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype +--- +
{{JSRef}}
+ +

Number.prototype 屬性用來表示 {{jsxref("Number")}} 建構式的原型。

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

說明

+ +

所有 {{jsxref("Number")}} 實體都繼承自 Number.prototype 。{{jsxref("Number")}} 建構式的原型物件可以被修改並作用在所有 {{jsxref("Number")}} 實體。

+ +

屬性

+ +
+
Number.prototype.constructor
+
回傳建立這個物件實體的建構式。預設為 {{jsxref("Number")}} 物件。
+
+ +

方法

+ +
+
{{jsxref("Number.prototype.toExponential()")}}
+
回傳以「科學記數法」表示的數值字串。
+
{{jsxref("Number.prototype.toFixed()")}}
+
回傳以定點表示的數值字串。
+
{{jsxref("Number.prototype.toLocaleString()")}}
+
回傳以當地語言為主的數值字串。這覆寫 {{jsxref("Object.prototype.toLocaleString()")}} 的方法。
+
{{jsxref("Number.prototype.toPrecision()")}}
+
回傳以定點或科學記數表示的數值字串。
+
{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}
+
Returns an object literal representing the specified {{jsxref("Number")}} object; you can use this value to create a new object. Overrides the {{jsxref("Object.prototype.toSource()")}} method.
+
{{jsxref("Number.prototype.toString()")}}
+
回傳以特定基數表示的數值字串。這覆寫 {{jsxref("Object.prototype.toString()")}} 的方法 。
+
{{jsxref("Number.prototype.valueOf()")}}
+
回傳這個物件的原始型別，即原始數值。這覆寫 {{jsxref("Object.prototype.valueOf()")}} 。
+
+ +

規範

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
規範狀態註記
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}{{Spec2('ESDraft')}} 
+ +

瀏覽器相容性

+ + + +

{{Compat("javascript.builtins.Number.prototype")}}

+ +

參見

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/global_objects/object/index.html b/files/zh-tw/conflicting/web/javascript/reference/global_objects/object/index.html new file mode 100644 index 0000000000..4365b10c61 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,219 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Reference/Global_Objects/Object/prototype +tags: + - JavaScript + - Object + - 待翻譯 +translation_of: Web/JavaScript/Reference/Global_Objects/Object +translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype +--- +
{{JSRef}}
+ +

Object.prototype 代表 {{jsxref("Object")}} 的原型物件。

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

描述

+ +

All objects in JavaScript are descended from {{jsxref("Object")}}; all objects inherit methods and properties from Object.prototype, although they may be overridden (except an Object with a null prototype, i.e. Object.create(null)). For example, other constructors' prototypes override the constructor property and provide their own {{jsxref("Object.prototype.toString()", "toString()")}} methods. Changes to the Object prototype object are propagated to all objects unless the properties and methods subject to those changes are overridden further along the prototype chain.

+ +

屬性

+ +
+
{{jsxref("Object.prototype.constructor")}}
+
Specifies the function that creates an object's prototype.
+
{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}
+
Points to the object which was used as prototype when the object was instantiated.
+
{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}
+
Allows a function to be defined that will be executed when an undefined object member is called as a method.
+
{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}
+
Used to return the number of enumerable properties directly on a user-defined object, but has been removed.
+
{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}
+
Used to point to an object's context, but has been removed.
+
+ +

方法

+ +
+
{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Associates a function with a property that, when accessed, executes that function and returns its return value.
+
{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Associates a function with a property that, when set, executes that function which modifies the property.
+
{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Returns the function associated with the specified property by the {{jsxref("Object.defineGetter", "__defineGetter__")}} method.
+
{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}
+
Returns the function associated with the specified property by the {{jsxref("Object.defineSetter", "__defineSetter__")}} method.
+
{{jsxref("Object.prototype.hasOwnProperty()")}}
+
Returns a boolean indicating whether an object contains the specified property as a direct property of that object and not inherited through the prototype chain.
+
{{jsxref("Object.prototype.isPrototypeOf()")}}
+
Returns a boolean indication whether the specified object is in the prototype chain of the object this method is called upon.
+
{{jsxref("Object.prototype.propertyIsEnumerable()")}}
+
Returns a boolean indicating if the internal ECMAScript DontEnum attribute is set.
+
{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}
+
Returns string containing the source of an object literal representing the object that this method is called upon; you can use this value to create a new object.
+
{{jsxref("Object.prototype.toLocaleString()")}}
+
Calls {{jsxref("Object.toString", "toString()")}}.
+
{{jsxref("Object.prototype.toString()")}}
+
Returns a string representation of the object.
+
{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}
+
Removes a watchpoint from a property of the object.
+
{{jsxref("Object.prototype.valueOf()")}}
+
Returns the primitive value of the specified object.
+
{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}
+
Adds a watchpoint to a property of the object.
+
{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}
+
Used to evaluate a string of JavaScript code in the context of the specified object, but has been removed.
+
+ +

範例

+ +

因為 JavaScript 並沒有子類別的物件，所以原型是個很有用的解決辦法, 使某些函數作為物件的基本類別物件。例如：

+ +
var Person = function() {
+  this.canTalk = true;
+};
+
+Person.prototype.greet = function() {
+  if (this.canTalk) {
+    console.log('Hi, I am ' + this.name);
+  }
+};
+
+var Employee = function(name, title) {
+  Person.call(this);
+  this.name = name;
+  this.title = title;
+};
+
+Employee.prototype = Object.create(Person.prototype);
+Employee.prototype.constructor = Employee;
+
+Employee.prototype.greet = function() {
+  if (this.canTalk) {
+    console.log('Hi, I am ' + this.name + ', the ' + this.title);
+  }
+};
+
+var Customer = function(name) {
+  Person.call(this);
+  this.name = name;
+};
+
+Customer.prototype = Object.create(Person.prototype);
+Customer.prototype.constructor = Customer;
+
+var Mime = function(name) {
+  Person.call(this);
+  this.name = name;
+  this.canTalk = false;
+};
+
+Mime.prototype = Object.create(Person.prototype);
+Mime.prototype.constructor = Mime;
+
+var bob = new Employee('Bob', 'Builder');
+var joe = new Customer('Joe');
+var rg = new Employee('Red Green', 'Handyman');
+var mike = new Customer('Mike');
+var mime = new Mime('Mime');
+
+bob.greet();
+// Hi, I am Bob, the Builder
+
+joe.greet();
+// Hi, I am Joe
+
+rg.greet();
+// Hi, I am Red Green, the Handyman
+
+mike.greet();
+// Hi, I am Mike
+
+mime.greet();
+
+ +

規範

+ + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}{{Spec2('ES6')}} 
+ +

瀏覽器相容性

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

參見

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/global_objects/promise/index.html b/files/zh-tw/conflicting/web/javascript/reference/global_objects/promise/index.html new file mode 100644 index 0000000000..f93572bea3 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/global_objects/promise/index.html @@ -0,0 +1,65 @@ +--- +title: Promise.prototype +slug: Web/JavaScript/Reference/Global_Objects/Promise/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +translation_of_original: Web/JavaScript/Reference/Global_Objects/Promise/prototype +--- +
{{JSRef}}
+ +

Promise.prototype 屬性代表了 {{jsxref("Promise")}} 建構式的原型物件。

+ +
{{js_property_attributes(0,0,0)}}
+ +

描述

+ +

所有 {{jsxref("Promise")}} 實例都繼承自 {{jsxref("Promise.prototype")}}。您可以使用建構式的原型物件來增加屬性或方法到所有的 Promise 實例。

+ +

屬性

+ +
+
Promise.prototype.constructor
+
回傳一個建立實例原型（instance's prototype）的函式。預設為 {{jsxref("Promise")}} 函數。
+
+ +

方法

+ +
+
{{jsxref("Promise.catch", "Promise.prototype.catch(onRejected)")}}
+
繫結一個拒絕回呼函式（rejection handler callback）到 promise，當它被呼叫時回傳一個以回傳值作解析的新 promise，或者當 promise 被實現時以原值作解析。
+
{{jsxref("Promise.then", "Promise.prototype.then(onFulfilled, onRejected)")}}
+
繫結實現或拒絕回呼函式到 promise，回傳一個以 handler 之回傳值作解析的新 promise，或者當 promise 未處理（not handled）時以原值作解析。(i.e. 比如相關聯的 onFulfilled 或 onRejected 不是函式。)
+
+ +

規範

+ + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES6', '#sec-promise.prototype', 'Promise.prototype')}}{{Spec2('ES6')}}Initial definition.
{{SpecName('ESDraft', '#sec-promise.prototype', 'Promise.prototype')}}{{Spec2('ESDraft')}} 
+ +

瀏覽器相容性

+ + + +

{{Compat("javascript/promise","Promise.prototype")}}

+ +

參見

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/global_objects/string/index.html b/files/zh-tw/conflicting/web/javascript/reference/global_objects/string/index.html new file mode 100644 index 0000000000..011c61418e --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/global_objects/string/index.html @@ -0,0 +1,177 @@ +--- +title: String.prototype +slug: Web/JavaScript/Reference/Global_Objects/String/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/String +translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype +--- +
{{JSRef}}
+ +

The String.prototype property represents the {{jsxref("String")}} prototype object.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Description

+ +

All {{jsxref("String")}} instances inherit from String.prototype. Changes to the String prototype object are propagated to all {{jsxref("String")}} instances.

+ +

Properties

+ +
+
String.prototype.constructor
+
Specifies the function that creates an object's prototype.
+
{{jsxref("String.prototype.length")}}
+
Reflects the length of the string.
+
N
+
Used to access the character in the Nth position where N is a positive integer between 0 and one less than the value of {{jsxref("String.length", "length")}}. These properties are read-only.
+
+ +

Methods

+ +

Methods unrelated to HTML

+ +
+
{{jsxref("String.prototype.charAt()")}}
+
Returns the character (exactly one UTF-16 code unit) at the specified index.
+
{{jsxref("String.prototype.charCodeAt()")}}
+
Returns a number that is the UTF-16 code unit value at the given index.
+
{{jsxref("String.prototype.codePointAt()")}}
+
Returns a nonnegative integer Number that is the code point value of the UTF-16 encoded code point starting at the specified index.
+
{{jsxref("String.prototype.concat()")}}
+
Combines the text of two strings and returns a new string.
+
{{jsxref("String.prototype.includes()")}}
+
Determines whether one string may be found within another string.
+
{{jsxref("String.prototype.endsWith()")}}
+
Determines whether a string ends with the characters of another string.
+
{{jsxref("String.prototype.indexOf()")}}
+
Returns the index within the calling {{jsxref("String")}} object of the first occurrence of the specified value, or -1 if not found.
+
{{jsxref("String.prototype.lastIndexOf()")}}
+
Returns the index within the calling {{jsxref("String")}} object of the last occurrence of the specified value, or -1 if not found.
+
{{jsxref("String.prototype.localeCompare()")}}
+
Returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.
+
{{jsxref("String.prototype.match()")}}
+
Used to match a regular expression against a string.
+
{{jsxref("String.prototype.normalize()")}}
+
Returns the Unicode Normalization Form of the calling string value.
+
{{jsxref("String.prototype.padEnd()")}}
+
Pads the current string from the end with a given string to create a new string from a given length.
+
{{jsxref("String.prototype.padStart()")}}
+
Pads the current string from the start with a given string to create a new string from a given length.
+
{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}
+
Wraps the string in double quotes (""").
+
{{jsxref("String.prototype.repeat()")}}
+
Returns a string consisting of the elements of the object repeated the given times.
+
{{jsxref("String.prototype.replace()")}}
+
Used to find a match between a regular expression and a string, and to replace the matched substring with a new substring.
+
{{jsxref("String.prototype.search()")}}
+
Executes the search for a match between a regular expression and a specified string.
+
{{jsxref("String.prototype.slice()")}}
+
Extracts a section of a string and returns a new string.
+
{{jsxref("String.prototype.split()")}}
+
Splits a {{jsxref("Global_Objects/String", "String")}} object into an array of strings by separating the string into substrings.
+
{{jsxref("String.prototype.startsWith()")}}
+
Determines whether a string begins with the characters of another string.
+
{{jsxref("String.prototype.substr()")}}
+
Returns the characters in a string beginning at the specified location through the specified number of characters.
+
{{jsxref("String.prototype.substring()")}}
+
Returns the characters in a string between two indexes into the string.
+
{{jsxref("String.prototype.toLocaleLowerCase()")}}
+
The characters within a string are converted to lower case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.
+
{{jsxref("String.prototype.toLocaleUpperCase()")}}
+
The characters within a string are converted to upper case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.
+
{{jsxref("String.prototype.toLowerCase()")}}
+
Returns the calling string value converted to lower case.
+
{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}
+
Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the {{jsxref("Object.prototype.toSource()")}} method.
+
{{jsxref("String.prototype.toString()")}}
+
Returns a string representing the specified object. Overrides the {{jsxref("Object.prototype.toString()")}} method.
+
{{jsxref("String.prototype.toUpperCase()")}}
+
Returns the calling string value converted to uppercase.
+
{{jsxref("String.prototype.trim()")}}
+
Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5 standard.
+
{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}
+
Trims whitespace from the left side of the string.
+
{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}
+
Trims whitespace from the right side of the string.
+
{{jsxref("String.prototype.valueOf()")}}
+
Returns the primitive value of the specified object. Overrides the {{jsxref("Object.prototype.valueOf()")}} method.
+
{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}
+
Returns a new Iterator object that iterates over the code points of a String value, returning each code point as a String value.
+
+ +

HTML wrapper methods

+ +

These methods are of limited use, as they provide only a subset of the available HTML tags and attributes.

+ +
+
{{jsxref("String.prototype.anchor()")}}
+
{{htmlattrxref("name", "a", "<a name=\"name\">")}} (hypertext target)
+
{{jsxref("String.prototype.big()")}} {{deprecated_inline}}
+
{{HTMLElement("big")}}
+
{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}
+
{{HTMLElement("blink")}}
+
{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}
+
{{HTMLElement("b")}}
+
{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}
+
{{HTMLElement("tt")}}
+
{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}
+
{{htmlattrxref("color", "font", "<font color=\"color\">")}}
+
{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}
+
{{htmlattrxref("size", "font", "<font size=\"size\">")}}
+
{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}
+
{{HTMLElement("i")}}
+
{{jsxref("String.prototype.link()")}}
+
{{htmlattrxref("href", "a", "<a href=\"url\">")}} (link to URL)
+
{{jsxref("String.prototype.small()")}} {{deprecated_inline}}
+
{{HTMLElement("small")}}
+
{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}
+
{{HTMLElement("strike")}}
+
{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}
+
{{HTMLElement("sub")}}
+
{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}
+
{{HTMLElement("sup")}}
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ + + +

{{Compat("javascript.builtins.String.prototype")}}

+ +

See also

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/operators/index.html b/files/zh-tw/conflicting/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..050c362008 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,309 @@ +--- +title: 算術運算子 +slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators +--- +
{{jsSidebar("Operators")}}
+ +

算術運算子接受數值（資料型態為字串或變數都可）作為其運算子並回傳單個數值。 標準算術運算符號有加號（+），減號（ - ），乘（*）和除（/）。

+ +
{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}
+ + + +

Addition (+)

+ +

加法運算子生成數字(運算元)的總和或字串串接。

+ +

Syntax

+ +
Operator: x + y
+
+ +

Examples

+ +
// Number + Number -> addition
+1 + 2 // 3
+
+// Boolean + Number -> addition
+true + 1 // 2
+
+// Boolean + Boolean -> addition
+false + false // 0
+
+// Number + String -> concatenation
+5 + 'foo' // "5foo"
+
+// String + Boolean -> concatenation
+'foo' + false // "foofalse"
+
+// String + String -> concatenation
+'foo' + 'bar' // "foobar"
+
+ +

Subtraction (-)

+ +

減法運算子能算出兩個運算元間的差異。

+ +

Syntax

+ +
Operator: x - y
+
+ +

Examples

+ +
5 - 3 // 2
+3 - 5 // -2
+'foo' - 3 // NaN
+ +

Division (/)

+ +

The division operator produces the quotient of its operands where the left operand is the dividend and the right operand is the divisor.

+ +

Syntax

+ +
Operator: x / y
+
+ +

Examples

+ +
1 / 2      // returns 0.5 in JavaScript
+1 / 2      // returns 0 in Java
+// (neither number is explicitly a floating point number)
+
+1.0 / 2.0  // returns 0.5 in both JavaScript and Java
+
+2.0 / 0    // returns Infinity in JavaScript
+2.0 / 0.0  // returns Infinity too
+2.0 / -0.0 // returns -Infinity in JavaScript
+ +

Multiplication (*)

+ +

The multiplication operator produces the product of the operands.

+ +

Syntax

+ +
Operator: x * y
+
+ +

Examples

+ +
2 * 2 // 4
+-2 * 2 // -4
+Infinity * 0 // NaN
+Infinity * Infinity // Infinity
+'foo' * 2 // NaN
+
+ +

Remainder (%)

+ +

The remainder operator returns the remainder left over when one operand is divided by a second operand. It always takes the sign of the dividend.

+ +

Syntax

+ +
Operator: var1 % var2
+
+ +

Examples

+ +
12 % 5 // 2
+-1 % 2 // -1
+1 % -2 // 1
+NaN % 2 // NaN
+1 % 2 // 1
+2 % 3 // 2
+-4 % 2 // -0
+5.5 % 2 // 1.5
+
+ +

Exponentiation (**)

+ +

The exponentiation operator returns the result of raising first operand to the power second operand. that is, var1var2, in the preceding statement, where var1 and var2 are variables. Exponentiation operator is right associative. a ** b ** c is equal to a ** (b ** c).

+ +

Syntax

+ +
Operator: var1 ** var2
+
+ +

Notes

+ +

In most languages like PHP and Python and others that have an exponentiation operator (**), the exponentiation operator is defined to have a higher precedence than unary operators such as unary + and unary -, but there are a few exceptions. For example, in Bash the ** operator is defined to have a lower precedence than unary operators. In JavaScript, it is impossible to write an ambiguous exponentiation expression, i.e. you cannot put a unary operator (+/-/~/!/delete/void/typeof) immediately before the base number.

+ +
-2 ** 2;
+// 4 in Bash, -4 in other languages.
+// This is invalid in JavaScript, as the operation is ambiguous.
+
+
+-(2 ** 2);
+// -4 in JavaScript and the author's intention is unambiguous.
+
+ +

Examples

+ +
2 ** 3 // 8
+3 ** 2 // 9
+3 ** 2.5 // 15.588457268119896
+10 ** -1 // 0.1
+NaN ** 2 // NaN
+
+2 ** 3 ** 2 // 512
+2 ** (3 ** 2) // 512
+(2 ** 3) ** 2 // 64
+
+ +

To invert the sign of the result of an exponentiation expression:

+ +
-(2 ** 2) // -4
+
+ +

To force the base of an exponentiation expression to be a negative number:

+ +
(-2) ** 2 // 4
+
+ +
+

Note: JavaScript also has a bitwise operator ^ (logical XOR). ** and ^ are different (for example : 2 ** 3 === 8 when 2 ^ 3 === 1.)

+
+ +

Increment (++)

+ +

The increment operator increments (adds one to) its operand and returns a value.

+ + + +

Syntax

+ +
Operator: x++ or ++x
+
+ +

Examples

+ +
// Postfix
+var x = 3;
+y = x++; // y = 3, x = 4
+
+// Prefix
+var a = 2;
+b = ++a; // a = 3, b = 3
+
+ +

Decrement (--)

+ +

The decrement operator decrements (subtracts one from) its operand and returns a value.

+ + + +

Syntax

+ +
Operator: x-- or --x
+
+ +

Examples

+ +
// Postfix
+var x = 3;
+y = x--; // y = 3, x = 2
+
+// Prefix
+var a = 2;
+b = --a; // a = 1, b = 1
+
+ +

Unary negation (-)

+ +

The unary negation operator precedes its operand and negates it.

+ +

Syntax

+ +
Operator: -x
+
+ +

Examples

+ +
var x = 3;
+y = -x; // y = -3, x = 3
+
+// Unary negation operator can convert non-numbers into a number
+var x = "4";
+y = -x; // y = -4
+
+ +

Unary plus (+)

+ +

The unary plus operator precedes its operand and evaluates to its operand but attempts to convert it into a number, if it isn't already. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number. It can convert string representations of integers and floats, as well as the non-string values true, false, and null. Integers in both decimal and hexadecimal ("0x"-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to {{jsxref("NaN")}}.

+ +

Syntax

+ +
Operator: +x
+
+ +

Examples

+ +
+3     // 3
++'3'   // 3
++true  // 1
++false // 0
++null  // 0
++function(val){ return val } // NaN
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-11.3')}}{{Spec2('ES5.1')}}Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators.
{{SpecName('ES2015', '#sec-postfix-expressions')}}{{Spec2('ES2015')}}Defined in several sections of the specification: Additive operators, Multiplicative operators, Postfix expressions, Unary operators.
{{SpecName('ES2016', '#sec-postfix-expressions')}}{{Spec2('ES2016')}}Added Exponentiation operator.
{{SpecName('ES2017', '#sec-postfix-expressions')}}{{Spec2('ES2017')}} 
{{SpecName('ESDraft', '#sec-additive-operators')}}{{Spec2('ESDraft')}} 
+ +

Browser compatibility

+ + + +

{{Compat("javascript.operators.arithmetic")}}

+ +

See also

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/operators_310dc67549939233c3d18a8fa2cdbb23/index.html b/files/zh-tw/conflicting/web/javascript/reference/operators_310dc67549939233c3d18a8fa2cdbb23/index.html new file mode 100644 index 0000000000..f0b3e39c6e --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/operators_310dc67549939233c3d18a8fa2cdbb23/index.html @@ -0,0 +1,284 @@ +--- +title: 比較運算子 +slug: Web/JavaScript/Reference/Operators/Comparison_Operators +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators +--- +
{{jsSidebar("Operators")}}
+ +

JavaScript has both strict and type–converting comparisons. A strict comparison (e.g., ===) is only true if the operands are of the same type and the contents match. The more commonly-used abstract comparison (e.g. ==) converts the operands to the same type before making the comparison. For relational abstract comparisons (e.g., <=), the operands are first converted to primitives, then to the same type, before comparison.

+ +

Strings are compared based on standard lexicographical ordering, using Unicode values.

+ +

Features of comparisons:

+ + + +

Equality operators

+ +

Equality (==)

+ +

The equality operator converts the operands if they are not of the same type, then applies strict comparison. If both operands are objects, then JavaScript compares internal references which are equal when operands refer to the same object in memory.

+ +

Syntax

+ +
x == y
+
+ +

Examples

+ +
  1   ==  1        // true
+ "1"  ==  1        // true
+  1   == '1'       // true
+  0   == false     // true
+  0   == null      // false
+var object1 = {"value":"key"}, object2={"value":"key"};
+object1 == object2 //false
+
+  0   == undefined // false
+null  == undefined // true
+
+ +

Inequality (!=)

+ +

The inequality operator returns true if the operands are not equal. If the two operands are not of the same type, JavaScript attempts to convert the operands to an appropriate type for the comparison. If both operands are objects, then JavaScript compares internal references which are not equal when operands refer to different objects in memory.

+ +

Syntax

+ +
x != y
+ +

Examples

+ +
1 !=   2     // true
+1 !=  "1"    // false
+1 !=  '1'    // false
+1 !=  true   // false
+0 !=  false  // false
+
+ +

Identity / strict equality (===)

+ +

The identity operator returns true if the operands are strictly equal (see above) with no type conversion. 

+ +

Syntax

+ +
x === y
+ +

Examples

+ +
3 === 3   // true
+3 === '3' // false
+var object1 = {"value":"key"}, object2={"value":"key"};
+object1 === object2 //false
+ +

 

+ +

Non-identity / strict inequality (!==)

+ +

The non-identity operator returns true if the operands are not equal and/or not of the same type.

+ +

Syntax

+ +
x !== y
+ +

Examples

+ +
3 !== '3' // true
+4 !== 3   // true
+
+ +

Relational operators

+ +

Each of these operators will call the valueOf() function on each operand before a comparison is made.

+ +

Greater than operator (>)

+ +

The greater than operator returns true if the left operand is greater than the right operand.

+ +

Syntax

+ +
x > y
+ +

Examples

+ +
4 > 3 // true
+
+ +

Greater than or equal operator (>=)

+ +

The greater than or equal operator returns true if the left operand is greater than or equal to the right operand.

+ +

Syntax

+ +
 x >= y
+ +

Examples

+ +
4 >= 3 // true
+3 >= 3 // true
+
+ +

Less than operator (<)

+ +

The less than operator returns true if the left operand is less than the right operand.

+ +

Syntax

+ +
 x < y
+ +

Examples

+ +
3 < 4 // true
+
+ +

Less than or equal operator (<=)

+ +

The less than or equal operator returns true if the left operand is less than or equal to the right operand.

+ +

Syntax

+ +
 x <= y
+ +

Examples

+ +
3 <= 4 // true
+
+ +

Using the Equality Operators

+ +

The standard equality operators (== and !=) use the Abstract Equality Comparison Algorithm to compare two operands. If the operands are of different types, it will attempt to convert them to the same type before making the comparison, e.g., in the expression 5 == '5', the string on the right is converted to {{jsxref("Number")}} before the comparison is made.

+ +

The strict equality operators (=== and !==) use the Strict Equality Comparison Algorithm and are intended for performing equality comparisons on operands of the same type. If the operands are of different types, the result is always false so 5 !== '5'.

+ +

Use strict equality operators if the operands must be of a specific type as well as value or if the exact type of the operands is important. Otherwise, use the standard equality operators, which allow you to compare the identity of two operands even if they are not of the same type.

+ +

When type conversion is involved in the comparison (i.e., non–strict comparison), JavaScript converts the types {{jsxref("String")}}, {{jsxref("Number")}}, {{jsxref("Boolean")}}, or {{jsxref("Object")}} operands as follows:

+ + + +
Note: String objects are Type Object, not String! String objects are rarely used, so the following results might be surprising:
+ +
// true as both operands are type String (i.e. string primitives):
+'foo' === 'foo'
+
+var a = new String('foo');
+var b = new String('foo');
+
+// false as a and b are type Object and reference different objects
+a == b
+
+// false as a and b are type Object and reference different objects
+a === b
+
+// true as a and 'foo' are of different type and, the Object (a)
+// is converted to String 'foo' before comparison
+a == 'foo'
+ +

規範

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition. Implemented in JavaScript 1.0
{{SpecName('ES3')}}{{Spec2('ES3')}}Adds === and !== operators. Implemented in JavaScript 1.3
{{SpecName('ES5.1', '#sec-11.8')}}{{Spec2('ES5.1')}}Defined in several sections of the specification: Relational Operators, Equality Operators
{{SpecName('ES6', '#sec-relational-operators')}}{{Spec2('ES6')}}Defined in several sections of the specification: Relational Operators, Equality Operators
{{SpecName('ESDraft', '#sec-relational-operators')}}{{Spec2('ESDraft')}}Defined in several sections of the specification: Relational Operators, Equality Operators
+ +

瀏覽器相容性

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

參見

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html b/files/zh-tw/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html new file mode 100644 index 0000000000..86f78270b5 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html @@ -0,0 +1,555 @@ +--- +title: 位元運算子 +slug: Web/JavaScript/Reference/Operators/Bitwise_Operators +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators +--- +
{{jsSidebar("Operators")}}
+ +

位元運算子將運算元視為一段 32 位元長的 0 和 1 序列，而不是十進位、十六進位或八進位的 Numbers。 舉例來說，十進位的 9 可以用二進位表示為 1001。位元運算子對這樣的二進位表示法進行運算，然後回傳標準 JavaScript 數值。

+ +
{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}
+ + + +

下表總結了 JavaScript 的位元運算子：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
OperatorUsageDescription
位元 ANDa & b當兩運算元的該位置皆為 1 時，回傳值的該位置為 1。
位元 ORa | b當兩運算元的該位置有一者為 1 時，回傳值的該位置為 1。
位元 XORa ^ b當兩運算元的該位置恰好一者為 1 時，回傳值的該位置為 1。
位元 NOT~ a將運算元的所有位元反轉。
左移a << b將 a 的二進位表示法左移 b (< 32) 位元，右側補 0。
保持符號右移a >> b將 a 的二進位表示法右移 b (< 32) 位元，拋棄被移出的位元。
填零右移a >>> b  將 a 的二進位表示法右移 b (< 32) 位元，拋棄被移出的位元，並於右側補 0。
+ +

帶號的 32位元整數

+ +

所有位元運算子的運算元皆會被轉換成二補數系統下的帶號32位元整數。二補數系統意味著一個整數的加法反元素(例如 5和 -5)是該整數的所有位元反轉(位元 NOT，也就是該數的一補數) 再加一。舉例來說，下面的序列代表著整數 314：

+ +
00000000000000000000000100111010
+
+ +

下面的序列代表 ~314，也就是 314 的一補數：

+ +
11111111111111111111111011000101
+
+ +

接著，下面代表著 -314，也就是 314 的二補數：

+ +
11111111111111111111111011000110
+
+ +

二補數系統確保了正值時最左邊的位元為 0，反之則為 1。因此，最左邊的位元被稱作符號位。

+ +

整數 0 全由位元 0組成。

+ +
0 (base 10) = 00000000000000000000000000000000 (base 2)
+
+ +

整數 -1 全由位元 1組成。

+ +
-1 (base 10) = 11111111111111111111111111111111 (base 2)
+
+ +

整數 -2147483648 (十六進位： -0x80000000) 除了第一位為 1，其餘皆由位元 0組成。

+ +
-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
+
+ +

整數 -2147483648 (十六進位： -0x7fffffff) 除了第一位為 0，其餘皆由位元 1組成。

+ +
2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
+
+ +

整數 -2147483648 和 2147483647 分別為帶號32位元整數所能表示的最小值和最大值。

+ +

位元邏輯運算子

+ +

大致上，位元邏輯運算子的運作如下︰

+ + + +

& (位元 AND)

+ +

對每一組位元執行 AND 運算。a AND b 只在 a 和 b 同時為 1 時得到 1。AND運算的真值表如下：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba AND b
000
010
100
111
+ +
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
+
+ +

將任何數 x 和 0 做位元 AND 皆會得到 0。將任何數 x 和 -1 做位元 AND 皆會得到 x。

+ +

| (位元 OR)

+ +

對每一組位元執行 OR 運算。a OR b 在 a 和 b 有一者為 1 時得到 1。OR運算的真值表如下：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba OR b
000
011
101
111
+ +
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
+
+ +

將任何數 x 和 0 做位元 OR 皆會得到 x。將任何數 x 和 -1 做位元 OR 皆會得到 -1。

+ +

^ (位元 XOR)

+ +

對每一組位元執行 XOR 運算。a XOR b 只在 a 和 b 恰一者為 1 時得到 1。XOR運算的真值表如下：

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba XOR b
000
011
101
110
+ +
.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
+
+ +

將任何數 x 和 0 做位元 AND 皆會得到 x。將任何數 x 和 -1 做位元 AND 皆會得到 ~x。

+ +

~ (位元 NOT)

+ +

對每一個位元執行 NOT 運算。NOT a 會得到 a 的反轉值(也就是一補數)。NOT運算的真值表如下：

+ + + + + + + + + + + + + + + + +
aNOT a
01
10
+ +
 9 (base 10) = 00000000000000000000000000001001 (base 2)
+               --------------------------------
+~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
+
+ +

將任何數 x 做位元 NOT 皆會得到 -(x + 1)。舉例來說，~-5 會得到 4。

+ +

值得注意的是，因為使用 32位元表示法表示數值 ~-1 和 ~4294967295 (232-1) 皆會得到 0。

+ +

位元位移運算子

+ +

位移運算子需要兩個運算元：第一個是要被位移的值，第二個是位元位移量。位移的方向取決於使用的運算子。

+ +

位移運算子將運算元轉換成 32位元的大端序整數並回傳一個與左運算元相同類別的值。右運算元應不大於32，如果超過的話，將只會使用後 5個位元。

+ +

<< (左移)

+ +

將第一個運算元向左位移指定的量。被移出的位元會被拋棄，並從右側補零。

+ +

例如，9 << 2 會得到 36：

+ +
.    9 (base 10): 00000000000000000000000000001001 (base 2)
+                  --------------------------------
+9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
+
+ +

將任意值 x 左移 y 位元會得到 x * 2 ** y。

+ +

>> (保持符號右移)

+ +

將第一個運算元向右位移指定的量。被移出的位元會被拋棄，並從左側補進和原本最左端相同的位元值。因為新的最左端位元和原本的最左端位元是一樣的，符號位(最左端位元)並不會改變。「保持符號」之名便是因此。

+ +

例如，9 >> 2 會得到 2：

+ +
.    9 (base 10): 00000000000000000000000000001001 (base 2)
+                  --------------------------------
+9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
+
+ +

同樣地，-9 >> 2 會得到 -3，因為符號會保持不變。

+ +
.    -9 (base 10): 11111111111111111111111111110111 (base 2)
+                   --------------------------------
+-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
+
+ +

>>> (填零右移)

+ +

將第一個運算元向右位移指定的量。被移出的位元會被拋棄，並從左側補零。因為符號位變成 0，所以結果永遠都是正值。

+ +

對非負的數來說，填零右移會得到和保持符號右移一樣的結果。例如，9 >>> 2 和 9 >> 2 一樣，皆會得到 2：

+ +
.     9 (base 10): 00000000000000000000000000001001 (base 2)
+                   --------------------------------
+9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
+
+ +

然而對負值來說並不是這麼一回事。例如，-9 >>> 2 會得到 1073741821，跟 -9 >> 2 (得到 -3)的結果是不一樣的：

+ +
.     -9 (base 10): 11111111111111111111111111110111 (base 2)
+                    --------------------------------
+-9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
+
+ +

範例

+ +

旗標(flags) 和遮罩 (bitmasks)

+ +

位元運算子常被用於生成、修改、和讀取旗標序列，就像是二進制的變數一般。雖然也可以使用普通變數，但使用二進制的旗標序列大大的減少了所需空間 (32 倍)。

+ +

假設有 4個旗標：

+ + + +

這些旗標倍表達成一個位元序列：DCBA。當一個旗標被立起 (set)時，其值為1。當一個旗標被放下 (clear)，其值為0。假設有一變數 flags 的二進位值為 0101：

+ +
var flags = 5;   // 二進位 0101
+
+ +

這個值表示：

+ + + +

因為位元運算子進行的是 32位元操作，0101 實際上是 00000000000000000000000000000101，但前導的 0可被忽略因為他們沒有實際上的意義。

+ +

位元遮罩則為一個可以修改且(或)讀取旗標序列的位元序列。通常為每個單獨旗標為真的「初始」值：

+ +
var FLAG_A = 1; // 0001
+var FLAG_B = 2; // 0010
+var FLAG_C = 4; // 0100
+var FLAG_D = 8; // 1000
+
+ +

新的位元遮罩可以透過對初始遮罩進行位元運算獲得。例如，遮罩 1011 可以透過對 FLAG_A、FLAG_B、和 FLAG_D進行 OR運算獲得：

+ +
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011
+
+ +

Individual flag values can be extracted by ANDing them with a bitmask, where each bit with the value of one will "extract" the corresponding flag. The bitmask masks out the non-relevant flags by ANDing with zeroes (hence the term "bitmask"). For example, the bitmask 0100 can be used to see if flag C is set:

+ +
// if we own a cat
+if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
+   // do stuff
+}
+
+ +

A bitmask with multiple set flags acts like an "either/or". For example, the following two are equivalent:

+ +
// if we own a bat or we own a cat
+// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
+if ((flags & FLAG_B) || (flags & FLAG_C)) {
+   // do stuff
+}
+
+ +
// if we own a bat or cat
+var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
+if (flags & mask) { // 0101 & 0110 => 0100 => true
+   // do stuff
+}
+
+ +

Flags can be set by ORing them with a bitmask, where each bit with the value one will set the corresponding flag, if that flag isn't already set. For example, the bitmask 1100 can be used to set flags C and D:

+ +
// yes, we own a cat and a duck
+var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
+flags |= mask;   // 0101 | 1100 => 1101
+
+ +

Flags can be cleared by ANDing them with a bitmask, where each bit with the value zero will clear the corresponding flag, if it isn't already cleared. This bitmask can be created by NOTing primitive bitmasks. For example, the bitmask 1010 can be used to clear flags A and C:

+ +
// no, we don't have an ant problem or own a cat
+var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

The mask could also have been created with ~FLAG_A & ~FLAG_C (De Morgan's law):

+ +
// no, we don't have an ant problem, and we don't own a cat
+var mask = ~FLAG_A & ~FLAG_C;
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

Flags can be toggled by XORing them with a bitmask, where each bit with the value one will toggle the corresponding flag. For example, the bitmask 0110 can be used to toggle flags B and C:

+ +
// if we didn't have a bat, we have one now,
+// and if we did have one, bye-bye bat
+// same thing for cats
+var mask = FLAG_B | FLAG_C;
+flags = flags ^ mask;   // 1100 ^ 0110 => 1010
+
+ +

Finally, the flags can all be flipped with the NOT operator:

+ +
// entering parallel universe...
+flags = ~flags;    // ~1010 => 0101
+
+ +

Conversion snippets

+ +

Convert a binary String to a decimal Number:

+ +
var sBinString = '1011';
+var nMyNumber = parseInt(sBinString, 2);
+alert(nMyNumber); // prints 11, i.e. 1011
+
+ +

Convert a decimal Number to a binary String:

+ +
var nMyNumber = 11;
+var sBinString = nMyNumber.toString(2);
+alert(sBinString); // prints 1011, i.e. 11
+
+ +

Automate Mask Creation

+ +

You can create multiple masks from a set of Boolean values, like this:

+ +
function createMask() {
+  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
+  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
+  return nMask;
+}
+var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
+var mask2 = createMask(false, false, true); // 4, i.e.: 0100
+var mask3 = createMask(true); // 1, i.e.: 0001
+// etc.
+
+alert(mask1); // prints 11, i.e.: 1011
+
+ +

Reverse algorithm: an array of booleans from a mask

+ +

If you want to create an Array of Booleans from a mask you can use this code:

+ +
function arrayFromMask(nMask) {
+  // nMask must be between -2147483648 and 2147483647
+  if (nMask > 0x7fffffff || nMask < -0x80000000) {
+    throw new TypeError('arrayFromMask - out of range');
+  }
+  for (var nShifted = nMask, aFromMask = []; nShifted;
+       aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
+  return aFromMask;
+}
+
+var array1 = arrayFromMask(11);
+var array2 = arrayFromMask(4);
+var array3 = arrayFromMask(1);
+
+alert('[' + array1.join(', ') + ']');
+// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011
+
+ +

You can test both algorithms at the same time…

+ +
var nTest = 19; // our custom mask
+var nResult = createMask.apply(this, arrayFromMask(nTest));
+
+alert(nResult); // 19
+
+ +

For the didactic purpose only (since there is the Number.toString(2) method), we show how it is possible to modify the arrayFromMask algorithm in order to create a String containing the binary representation of a Number, rather than an Array of Booleans:

+ +
function createBinaryString(nMask) {
+  // nMask must be between -2147483648 and 2147483647
+  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
+       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
+  return sMask;
+}
+
+var string1 = createBinaryString(11);
+var string2 = createBinaryString(4);
+var string3 = createBinaryString(1);
+
+alert(string1);
+// prints 00000000000000000000000000001011, i.e. 11
+
+ +

規範

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-11.7')}}{{Spec2('ES5.1')}}Defined in several sections of the specification: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
{{SpecName('ES6', '#sec-bitwise-shift-operators')}}{{Spec2('ES6')}}Defined in several sections of the specification: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}{{Spec2('ESDraft')}}Defined in several sections of the specification: Bitwise NOT operator, Bitwise shift operators, Binary bitwise operators
+ +

瀏覽器相容性

+ + + +

{{Compat("javascript.operators.bitwise")}}

+ +

另見

+ + diff --git a/files/zh-tw/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html b/files/zh-tw/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html new file mode 100644 index 0000000000..2fb07f891e --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html @@ -0,0 +1,244 @@ +--- +title: Logical operators +slug: Web/JavaScript/Reference/Operators/Logical_Operators +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators +--- +
{{jsSidebar("Operators")}}
+ +

邏輯運算子通常會搭配 {{jsxref("Boolean")}} (logical) 值。若是，則回傳布林值。然而， && 和 ||  運算子通常回傳其中一運算元的值, 因此若這些運算子搭配非布林值使用，他們會回傳非布林值。

+ +
{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}
+ + + +

說明

+ +

邏輯運算子的使用方式如下(expr 可能會是 type，不只是布林值)：

+ + + + + + + + + + + + + + + + + + + + + + + + +
OperatorSyntaxDescription
邏輯 AND (&&)expr1 && expr2若 expr1 可被轉換成 true, 回傳 expr2; 否則 回傳 expr1.
邏輯 OR (||)expr1 || expr2若 expr1 可被轉換成 true, 回傳 expr1; 否則 回傳 expr2.
邏輯 NOT (!)!expr回傳 false 若它的單一運算元可被轉換成 true; 否則回傳 true.
+ +

If a value can be converted to true, the value is so-called {{Glossary("truthy")}}. If a value can be converted to false, the value is so-called {{Glossary("falsy")}}.

+ +

Examples of expressions that can be converted to false are:

+ + + +

Even though the && and || operators can be used with operands that are not Boolean values, they can still be considered boolean operators since their return values can always be converted to boolean primitives. To explicitly convert their return value (or any expression in general) to the corresponding boolean value, use a double NOT operator or the Boolean constructor.

+ +

Short-circuit evaluation

+ +

As logical expressions are evaluated left to right, they are tested for possible "short-circuit" evaluation using the following rules:

+ + + +

Short circuit means that the expr parts above are not evaluated, hence any side effects of doing so do not take effect (e.g., if expr is a function call, the calling never takes place). This happens because the value of the operator is already determined after the evaluation of the first operand. See example:

+ +
function A(){ console.log('called A'); return false; }
+function B(){ console.log('called B'); return true; }
+
+console.log( A() && B() );
+// logs "called A" due to the function call,
+// then logs false (which is the resulting value of the operator)
+
+console.log( B() || A() );
+// logs "called B" due to the function call,
+// then logs true (which is the resulting value of the operator)
+
+ +

Operator precedence

+ +

The following expressions might seem equivalent, but they are not, because the && operator is executed before the || operator (see operator precedence).

+ +
true || false && false      // returns true, because && is executed first
+(true || false) && false    // returns false, because operator precedence cannot apply
+ +

Logical AND (&&)

+ +

The following code shows examples of the && (logical AND) operator.

+ +
a1 = true  && true       // t && t returns true
+a2 = true  && false      // t && f returns false
+a3 = false && true       // f && t returns false
+a4 = false && (3 == 4)   // f && f returns false
+a5 = 'Cat' && 'Dog'      // t && t returns "Dog"
+a6 = false && 'Cat'      // f && t returns false
+a7 = 'Cat' && false      // t && f returns false
+a8 = ''    && false      // f && f returns ""
+a9 = false && ''         // f && f returns false
+
+ +

Logical OR (||)

+ +

The following code shows examples of the || (logical OR) operator.

+ +
o1 = true  || true       // t || t returns true
+o2 = false || true       // f || t returns true
+o3 = true  || false      // t || f returns true
+o4 = false || (3 == 4)   // f || f returns false
+o5 = 'Cat' || 'Dog'      // t || t returns "Cat"
+o6 = false || 'Cat'      // f || t returns "Cat"
+o7 = 'Cat' || false      // t || f returns "Cat"
+o8 = ''    || false      // f || f returns false
+o9 = false || ''         // f || f returns ""
+o10 = false || varObject // f || object returns varObject
+
+ +

Logical NOT (!)

+ +

The following code shows examples of the ! (logical NOT) operator.

+ +
n1 = !true               // !t returns false
+n2 = !false              // !f returns true
+n3 = !''                 // !f returns true
+n4 = !'Cat'              // !t returns false
+
+ +

Double NOT (!!)

+ +

It is possible to use a couple of NOT operators in series to explicitly force the conversion of any value to the corresponding boolean primitive. The conversion is based on the "truthyness" or "falsyness" of the value (see {{Glossary("truthy")}} and {{Glossary("falsy")}}).

+ +

The same conversion can be done through the {{jsxref("Boolean")}} function.

+ +
n1 = !!true                   // !!truthy returns true
+n2 = !!{}                     // !!truthy returns true: any object is truthy...
+n3 = !!(new Boolean(false))   // ...even Boolean objects with a false .valueOf()!
+n4 = !!false                  // !!falsy returns false
+n5 = !!""                     // !!falsy returns false
+n6 = !!Boolean(false)         // !!falsy returns false
+
+ +

Conversion rules for booleans

+ +

Converting AND to OR

+ +

The following operation involving booleans:

+ +
bCondition1 && bCondition2
+ +

is always equal to:

+ +
!(!bCondition1 || !bCondition2)
+ +

Converting OR to AND

+ +

The following operation involving booleans:

+ +
bCondition1 || bCondition2
+ +

is always equal to:

+ +
!(!bCondition1 && !bCondition2)
+ +

Converting between NOTs

+ +

The following operation involving booleans:

+ +
!!bCondition
+ +

is always equal to:

+ +
bCondition
+ +

Removing nested parentheses

+ +

As logical expressions are evaluated left to right, it is always possible to remove parentheses from a complex expression following some rules.

+ +

Removing nested AND

+ +

The following composite operation involving booleans:

+ +
bCondition1 || (bCondition2 && bCondition3)
+ +

is always equal to:

+ +
bCondition1 || bCondition2 && bCondition3
+ +

Removing nested OR

+ +

The following composite operation involving booleans:

+ +
bCondition1 && (bCondition2 || bCondition3)
+ +

is always equal to:

+ +
!(!bCondition1 || !bCondition2 && !bCondition3)
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('ES1')}}{{Spec2('ES1')}}Initial definition.
{{SpecName('ES5.1', '#sec-11.11')}}{{Spec2('ES5.1')}}Defined in several sections of the specification: Logical NOT Operator, Binary Logical Operators
{{SpecName('ES6', '#sec-binary-logical-operators')}}{{Spec2('ES6')}}Defined in several sections of the specification: Logical NOT Operator, Binary Logical Operators
{{SpecName('ESDraft', '#sec-binary-logical-operators')}}{{Spec2('ESDraft')}}Defined in several sections of the specification: Logical NOT Operator, Binary Logical Operators
+ +

Browser compatibility

+ + + +

{{Compat("javascript.operators.logical")}}

+ +

See also

+ + -- cgit v1.2.3-54-g00ecf