diff options
Diffstat (limited to 'files/zh-tw/conflicting/web/javascript/guide')
36 files changed, 2100 insertions, 0 deletions
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..7db9752799 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling/index.html @@ -0,0 +1,35 @@ +--- +title: 區塊語法 +slug: conflicting/Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Block_Statement +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/區塊語法 +--- +<h3 id="區塊語法" name="區塊語法">區塊語法</h3> +<p>區塊語法用於把語句群組化。區塊的範圍是由一對大括號所界定︰</p> +<pre class="eval">{ + statement_1 + statement_2 + . + . + . + statement_n +} +</pre> +<p><strong>範例</strong><br> 區塊語法通常和流程控制語法（例如 <code>if</code>、<code>for</code>、<code>while</code>）一併使用。</p> +<pre class="eval">while (x < 10) { + x++; +} +</pre> +<p>此處，<code>{ x++; }</code> 就是區塊語法。</p> +<p><strong>重要</strong>: JavaScript <strong>並沒有</strong> 區塊作用域。區塊裡的變數其作用域相當於函數或 Script，對變數的設定會一直持續到區塊本身之外。換言之，區塊語法並沒有作用域。儘管“單獨”的區塊仍是有效的句法，你也不會想要在 JavaScript 中使用單獨的區塊，因為這樣做並不會產生任何你所期待的機能，譬如說如果你期待類似 C 或 Java 而這樣做的話。例如︰</p> +<pre class="eval">var x = 1; +{ + var x = 2; +} +alert(x); // 輸出 2 +</pre> +<p>這樣會輸出 2，因為在區塊之內的 <code>var x</code> 語法，其作用域如同沒有區塊的 <code>var x</code> 語法。而在 C 或 Java 中，同樣的代碼將會輸出 1。</p> +<div class="noinclude"> <p>{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的運用:正規表達式的範例", "Core_JavaScript_1.5_教學:條件語法") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..ab5427f972 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_2691b613803afee4bca87dca2a41b5c5/index.html @@ -0,0 +1,106 @@ +--- +title: 條件語法 +slug: >- + conflicting/Web/JavaScript/Guide/Control_flow_and_error_handling_2691b613803afee4bca87dca2a41b5c5 +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Conditional_Statements +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/條件語法 +--- +<h3 id="條件語法" name="條件語法">條件語法</h3> +<p>條件語法是在當指定的條件為 true 時，就執行一整組指令。JavaScript 支援兩種條件語法︰<code>if...else</code> 和 <code>switch</code>。</p> +<h4 id="if...else_語法" name="if...else_語法">if...else 語法</h4> +<p>如果邏輯條件為 true 時，就執行 <code>if</code> 語法裡的語句。如果條件為 false 的話，可以使用選用性的 <code>else</code> 子句來執行語句。<code>if</code> 語法如下︰</p> +<pre class="eval">if (condition) + statement_1 +[else + statement_2] +</pre> +<p><code>condition</code> 可以是任何可求值為 true 或 false 的表達式。如果 <code>condition</code> 的求值為 true，就會執行 <code>statement_1</code>，否則執行 <code>statement_2</code>。<code>statement_1</code> 和 <code>statement_2</code> 可以是任何的語句，包括嵌套的 <code>if</code> 語法。</p> +<p>你也可以使用 <code>else if</code> 來組合語句，並依序測試各個條件，如下︰</p> +<pre class="eval">if (condition) + statement_1 +[else if (condition_2) + statement_2] +... +[else if (condition_n_1) + statement_n_1] +[else + statement_n] +</pre> +<p>要執行多個語句，就使用區塊語法（<code>{ ... }</code>）把語句群組化。一般來說，固定使用區塊語法是非常好的作法，尤其是當代碼內部還有嵌套的 <code>if</code> 語法時︰</p> +<pre class="eval">if (condition) { + statements_1 +} else { + statements_2 +} +</pre> +<p>不要在條件表達式裡使用簡單的代入動作會比較明智，因為在快速瀏覽代碼時，代入和相等很容易彼此混淆。例如，不要使用如下代碼︰</p> +<pre class="eval">if (x = y) { + /* 做一些事 */ +} +</pre> +<p>如果你需要在條件表達式中使用代入的話，常見的作法是在代入語句加上額外的括弧。例如︰</p> +<pre class="eval">if ((x = y)) { + /* 做一些事 */ +} +</pre> +<p>不要把 Boolean 物件的 true、false 值和原始的布林值 <code>true</code>、<code>false</code> 相混淆。任何值只要不是 <code>undefined</code>、<code>null</code>、<code>0</code>、<code>NaN</code>、空字串 (<code>""</code>)、物件，即使是含有 false 值的 Boolean 物件，傳給條件語法的求值結果也會是 true。例如︰</p> +<pre class="eval">var b = new Boolean(false); +if (b) // 這個條件的求值結果為 true +</pre> +<p><strong>範例</strong><br> +在以下的範例中，如果在 <code>Text</code> 物件裡的字元數目為 3，函數 <code>checkData</code> 就返回 true。否則，他會顯示警報並返回 false。</p> +<pre class="eval">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; + } +} +</pre><h4 id="switch_語法" name="switch_語法">switch 語法</h4> +<p><code>switch</code> 語法可讓程式對表達式求值，並試著以表達式的值來一一比對 case 標籤。如果發現比對符合，程式就會執行與之關聯的語句。<code>switch</code> 語法如下︰</p> +<pre class="eval">switch (expression) { + case label_1: + statements_1 + [break;] + case label_2: + statements_2 + [break;] + ... + default: + statements_def + [break;] +} +</pre> +<p>程式首先從附有標籤的 <code>case</code> 子句找出能夠符合表達式的值的標籤，然後把控制權轉移到那個子句，並執行與之相關的語句。如果找不到相符的標籤，程式就會尋找選用性的 <code>default</code> 子句，如果找到的話，就把控制權轉移到那個子句，並執行與之相關的語句。如果找不到 <code>default</code> 子句，程式就會繼續執行 <code>switch</code> 語法後面的語句。根據慣例，<code>default</code> 語句一定是最後一個子句，但是並非只能這樣使用。</p> +<p>可用在每一個 <code>case</code> 子句的選用性 <code>break</code> 語法，可確實從 <code>switch</code> 裡已執行完且後面還有其他語句的符合語句中跳出。如果省略 <code>break</code>，程式就會繼續執行 <code>switch</code> 語法裡的下一個語法。</p> +<p><strong>範例</strong><br> +在以下範例中，如果 <code>fruittype</code> 求值為 "Bananas"，程式就會比對出 case "Bananas" 的值，並執行相聯的語句。如果遇到 <code>break</code>，程式就會終止 <code>switch</code> 並執行 <code>switch</code> 後面的語句。如果省略了 <code>break</code>，case "Cherries" 裡的語句也會被執行。</p> +<pre>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>"); +</pre> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:區塊語法", "Core_JavaScript_1.5_教學:循環語法") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..1d70a58a8a --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_74154e098f4b1e7026df3945ceb0fa4a/index.html @@ -0,0 +1,23 @@ +--- +title: 註解 +slug: >- + conflicting/Web/JavaScript/Guide/Control_flow_and_error_handling_74154e098f4b1e7026df3945ceb0fa4a +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Comments +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/註解 +--- +<h3 id="註解" name="註解">註解</h3> +<p>註解是作者用來解釋 Script 在做什麼的標記符號。註解會被解譯器忽略。JavaScript 支援 Java 和 C++ 形式的註解︰</p> +<ul> <li>單行註解是在前面加上兩個斜線 (//)。</li> <li>多行註解是在前面加上 /* 並在尾端加上 */。</li> +</ul> +<p><strong>範例</strong><br> +以下範例示範這兩種註解︰</p> +<pre>// 這是單行註解。 + +/* 這是多行註解。不管是什麼長度都可以，你也 +可以在任何你喜歡的地方使用。 */ +</pre> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:物件的操作語法", "Core_JavaScript_1.5_教學:例外處理語法") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..cb91b2ace4 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/control_flow_and_error_handling_a2d11ceeaeb3cb8c43292be7771f9b23/index.html @@ -0,0 +1,18 @@ +--- +title: 循環語法 +slug: >- + conflicting/Web/JavaScript/Guide/Control_flow_and_error_handling_a2d11ceeaeb3cb8c43292be7771f9b23 +translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Loop_Statements +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法 +--- +<h3 id="循環語法" name="循環語法">循環語法</h3> +<p>循環（或稱迴圈）是一組反覆執行的指令，直到滿足指定的條件為止。JavaScript 支援 for、do while、while 循環語法，除了 label 以外（label 本身不是循環語法，但經常和循環語法一起使用）。此外，你也可以在循環語法內部使用 <code>break</code> 和 <code>continue</code> 語法。</p> +<p>還有另一種語法 <code>for...in</code> 反覆執行語句，但是只用於物件的操作。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E7%89%A9%E4%BB%B6%E7%9A%84%E6%93%8D%E4%BD%9C%E8%AA%9E%E6%B3%95" title="zh tw/Core JavaScript 1.5 教學/物件的操作語法">物件的操作語法</a>。</p> +<p>循環語法如下︰</p> +<ul> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BE%AA%E7%92%B0%E8%AA%9E%E6%B3%95/for_%E8%AA%9E%E6%B3%95" title="zh_tw/Core_JavaScript_1.5_教學/Loop_語法/for_Statement">for 語法</a></li> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BE%AA%E7%92%B0%E8%AA%9E%E6%B3%95/do...while_%E8%AA%9E%E6%B3%95" title="zh_tw/Core_JavaScript_1.5_教學/Loop_語法/do...while_Statement">do...while 語法</a></li> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BE%AA%E7%92%B0%E8%AA%9E%E6%B3%95/while_%E8%AA%9E%E6%B3%95" title="zh_tw/Core_JavaScript_1.5_教學/Loop_語法/while_Statement">while 語法</a></li> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BE%AA%E7%92%B0%E8%AA%9E%E6%B3%95/label_%E8%AA%9E%E6%B3%95" title="zh_tw/Core_JavaScript_1.5_教學/Loop_語法/label_Statement">label 語法</a></li> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BE%AA%E7%92%B0%E8%AA%9E%E6%B3%95/break_%E8%AA%9E%E6%B3%95" title="zh_tw/Core_JavaScript_1.5_教學/Loop_語法/break_Statement">break 語法</a></li> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BE%AA%E7%92%B0%E8%AA%9E%E6%B3%95/continue_%E8%AA%9E%E6%B3%95" title="zh_tw/Core_JavaScript_1.5_教學/Loop_語法/continue_Statement">continue 語法</a></li> +</ul> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:條件語法", "Core_JavaScript_1.5_教學:循環語法:for_語法") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..91ff45f5bd --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model/index.html @@ -0,0 +1,29 @@ +--- +title: 以類別為基礎的語言 vs. 以原型為基礎的語言 +slug: conflicting/Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Class-Based_vs._Prototype-Based_Languages +original_slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/以類別為基礎的語言_vs._以原型為基礎的語言 +--- +<h3 id="以類別為基礎的語言_vs._以原型為基礎的語言" name="以類別為基礎的語言_vs._以原型為基礎的語言">以類別為基礎的語言 vs. 以原型為基礎的語言</h3> +<p>以類別為基礎的語言，如 Java 和 C++，是以兩種不同實體的概念為根基︰類別（Class）和實體（Instance）。</p> +<ul> <li>類別定義了所有的屬性（就 Java 的方法和欄位以及 C++ 的成員而論），刻劃出明確的物件集合。類別是抽象的事物，而不是任何他所刻劃的物件集合的實際成員。例如，Employee 類別可以代表所有職員的集合。</li> <li>實體從另一個角度來看就是類別的實際例證；也就是類別成員的其中一者。例如，Victoria 可以是 Employee 類別的實體，代表作為職員的獨特個體。實體恰好有親類別的屬性（且不多也不少）。</li> +</ul> +<p>以原型為基礎的語言，如 JavaScript，並沒有這些分別︰他簡單到只有物件。以原型為基礎的語言具有原型物件的概念。物件被當作模板來使用，從中取得最初的屬性以提供給新物件。不論是在你建立物件或執行時期的時候，任何物件都可以指定他自己的屬性。此外，任何物件都可以作為其他物件的原型而連繫起來，讓第二個物件共用第一個物件的屬性。</p> +<h4 id="類別的定義" name="類別的定義">類別的定義</h4> +<p>在以類別為基礎的語言中，你會在獨立的類別定義中定義類別。在這些定義中，你可以指定稱為建構子的特殊方法，用來建立類別的實體。建構子方法可以為實體的屬性指定初始值，並進行在建立時期的其他適當處理。你會使用 new 運算子配合建構子方法來建立類別的實體。</p> +<p>JavaScript 遵從類似的模型，但是建構子和其他類別的定義並沒有分別。取而代之，你會定義建構子函數來建立帶有特定初始值的一組屬性和值的物件。任何的 JavaScript 函數都可以用作建構子。你會使用 new 運算子配合建構子函數來建立新的物件。</p> +<h4 id="子類別和繼承" name="子類別和繼承">子類別和繼承</h4> +<p>在以類別為基礎的語言中，你會建立出類別定義整體的類別階層。在類別的定義中，你可以把新的類別指定為另一個既存類別的子類別。這個子類別會繼承親類別所有的屬性，也可以另外加入新的屬性或修改繼承下來的。例如，假定 Employee 類別只含有 name 和 dept 屬性，而 Manager 是 Employee 的子類別，且加入了 reports 屬性。在這個情況下，Manager 類別的實體將具有全部的三個屬性︰name、dept、reports。</p> +<p>JavaScript 可讓你把任意的建構子函數和原型物件連結在一起，以此實現繼承。因此，你可以準確的建立出 Employee 和 Manager 的範例，但是你會使用有點不一樣的術語。首先，你會定義 Employee 的建構子函數，指定 name 和 dept 屬性。接著，你會定義 Manager 的建構子函數，指定 reports 屬性。最後，你會把新的 Employee 物件作為原型代入給 Manager 的建構子函數。然後，當你建立新的 Manager 的時候，他就會從 Employee 物件繼承 name 和 dept 屬性。</p> +<h4 id="屬性的加入和移除" name="屬性的加入和移除">屬性的加入和移除</h4> +<p>在以類別為基礎的語言中，你通常會在編譯時期建立類別，然後你會在編譯時期或執行時期實體化類別的實體。在你定義了類別以後，你就不能改變類別的屬性的類型或數目。然而在JavaScript 中，你可以在執行時期加入或移除任何物件的屬性。如果你把屬性加入到用作為一整群物件的原型的物件裡，使用同一個原型的物件也會得到新的屬性。</p> +<h4 id="不同點的摘要" name="不同點的摘要">不同點的摘要</h4> +<p>下表給出了這些不同點的簡短摘要。本章的剩餘部分描述了使用 JavaScript 的建構子和原型來建立物件的階層，並和 Java 的做法來做比較。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>以類別為基礎 (Java)</th> <th>以原型為基礎 (JavaScript)</th> </tr> <tr> <td>類別和實體這兩者有分別。</td> <td>所有的物件都是實體。</td> </tr> <tr> <td>使用類別定義來定義類別；使用建構子方法來把類別實體化。</td> <td>使用建構子函數來定義並建立一整群物件。</td> </tr> <tr> <td>使用 <code>new</code> 運算子來建立單一的物件。</td> <td>相同。</td> </tr> <tr> <td>使用類別定義來建構物件的階層，用以定義既存類別的子類。</td> <td>藉由代入，把作為原型的物件和建構子函數連結起來，來建構出物件的階層。</td> </tr> <tr> <td>藉由遵從類別鏈來繼承屬性。</td> <td>藉由遵從原型鏈來繼承屬性。</td> </tr> <tr> <td>類別定義指定了類別的所有實體的所有屬性。不能在執行時期動態的加入屬性。</td> <td>建構子函數或原型指定並初始化了一系列屬性。可以給單獨的物件或一整組物件來動態的加入或移除屬性。</td> </tr> </tbody> +</table> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:迭代器和產生器", "Core_JavaScript_1.5_教學:職員的例子") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..6997ed22f5 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_3193ca1e5a7bdb78e9d9418a947916aa/index.html @@ -0,0 +1,48 @@ +--- +title: 實體關係的確定 +slug: >- + conflicting/Web/JavaScript/Guide/Details_of_the_Object_Model_3193ca1e5a7bdb78e9d9418a947916aa +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Determining_Instance_Relationships +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/實體關係的確定 +--- +<h3 id="實體關係的確定" name="實體關係的確定">實體關係的確定</h3> +<p>Javascript 搜尋屬性時，會先從物件內部所擁有的屬性開始，如果找不到屬性的名稱，就會從特殊的物件屬性 <code>__proto__</code> 內部搜尋。不斷反覆執行；這個過程就稱為〝在原型鏈中搜尋〞。</p> +<p>當物件建構完成時，就會設定這個特殊的屬性 <code>__proto__</code>；他會被設成建構子的 <code>prototype</code> 屬性的值。因此，表達式 <code>new Foo()</code> 會以 <code>__proto__ == <code class="moz-txt-verticalline">Foo.prototype</code></code> 來建立物件。因此，變更 <code class="moz-txt-verticalline">Foo.prototype</code> 的屬性，就會改變所有由 <code>new Foo()</code> 所建立的物件的屬性的搜尋。</p> +<p>每一個物件都有 <code>__proto__</code> 物件屬性（除了 <code>Object</code> 以外）；每一個函數都有 <code>prototype</code> 物件屬性。所以物件可藉由“原型的繼承”與其他物件建立起關係。你可以藉由物件的 <code>__proto__</code> 與函數的 <code>prototype</code> 物件的比較來對繼承進行測試。JavaScript 也提供了便捷方式︰<code>instanceof</code> 運算子會對照函數以檢測物件，如果這個物件繼承自函數的原型，就返回 true。例如，</p> +<pre>var f = new Foo(); +var isTrue = (f instanceof Foo);</pre> +<p>舉個更詳細的例子，假設你有顯示在 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E8%81%B7%E5%93%A1%E7%9A%84%E4%BE%8B%E5%AD%90/%E7%89%A9%E4%BB%B6%E7%9A%84%E5%B1%AC%E6%80%A7/%E5%B1%AC%E6%80%A7%E7%9A%84%E7%B9%BC%E6%89%BF" title="zh tw/Core JavaScript 1.5 教學/職員的例子/物件的屬性/屬性的繼承">屬性的繼承</a> 中的同一組定義。並建立 <code>Engineer</code> 物件如下︰</p> +<pre>chris = new Engineer("Pigman, Chris", ["jsd"], "fiji"); +</pre> +<p>對於這個物件，以下語句全部為 true︰</p> +<pre>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; +</pre> +<p>有鑑於此，你可以編寫 <code>instanceOf</code> 函數如下︰</p> +<pre>function instanceOf(object, constructor) { + while (object != null) { + if (object == constructor.prototype) + return true; + object = object.__proto__; + } + return false; +} +</pre> +<p>根據這個定義，以下語句全部為 true︰</p> +<pre>instanceOf (chris, Engineer) +instanceOf (chris, WorkerBee) +instanceOf (chris, Employee) +instanceOf (chris, Object) +</pre> +<p>但下面的表達式是 false︰</p> +<pre>instanceOf (chris, SalesPerson) +</pre> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承:局域值和繼承值", "Core_JavaScript_1.5_教學:再談屬性的繼承:建構子中的全域資訊") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..86bcfcdac9 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_483bbc3a620ead7b721647d1a2cb216f/index.html @@ -0,0 +1,59 @@ +--- +title: 局域值和繼承值 +slug: >- + conflicting/Web/JavaScript/Guide/Details_of_the_Object_Model_483bbc3a620ead7b721647d1a2cb216f +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 +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/局域值和繼承值 +--- +<h3 id="局域值和繼承值" name="局域值和繼承值">局域值和繼承值</h3> +<p>當你存取物件屬性的時候，JavaScript 會進行這些步驟，如同本章前面所提到過的︰</p> +<ol> <li>檢查局域值是否存在。如果存在，就返回局域值。</li> <li>如果局域值不存在，就檢查原型鏈（使用 <code>__proto__</code> 屬性）。</li> <li>如果在原型鏈上的物件具有所求的指定屬性，就返回這個屬性的值。</li> <li>如果找不到這樣的屬性，這個物件就不具有這個屬性。</li> +</ol> +<p>這些步驟之後的結果，取決於你如何循著這個方式來定義。一開始的例子有這些定義︰</p> +<pre>function Employee () { +this.name = ""; +this.dept = "general"; +} + +function WorkerBee () { +this.projects = []; +} +WorkerBee.prototype = new Employee; +</pre> +<p>藉由這些定義，假定你以如下語句建立 <code>amy</code> 作為 <code>WorkerBee</code> 的實體︰</p> +<pre>amy = new WorkerBee; +</pre> +<p><code>amy</code> 物件具有一個局域的屬性，<code>projects</code>。<code>name</code> 和 <code>dept</code> 屬性的值並不是 <code>amy</code> 的局域值，所以是從 <code>amy</code> 物件的 <code>__proto__</code> 屬性得來的。因此，<code>amy</code> 具有這些屬性值︰</p> +<pre>amy.name == ""; +amy.dept == "general"; +amy.projects == []; +</pre> +<p>現在假定你在與 <code>Employee</code> 連結的原型改變 <code>name</code> 屬性的值︰</p> +<pre>Employee.prototype.name = "Unknown" +</pre> +<p>乍看之下，你可能會預期新的值會被向下傳播給 <code>Employee</code> 所有的實體。然而，事情並不如此。</p> +<p>當你建立 <code>Employee</code> 物件的<em>任何</em>實體，這些實體會取得 <code>name</code> 屬性的局域值（空字串的那個）。這意味著當你使用新建立的 <code>Employee</code> 物件來設定 <code>WorkerBee</code> 原型的時候，<code>WorkerBee.prototype</code> 就具有 <code>name</code> 屬性的局域值。因此，當 JavaScript 找到 <code>amy</code> 物件（<code>WorkerBee</code> 的實體）的 <code>name</code> 屬性的時候，JavaScript 在 <code>WorkerBee.prototype</code> 找到了這些屬性的局域值。也因此並不會進一步在鏈的上一層 <code>Employee.prototype</code> 裡尋找。</p> +<p>如果你想要在執行時期改變物件屬性的值，而且希望新的值能被這個物件的所有子孫所繼承，你就不能在物件的建構子函數中定義這個屬性。相對的，你要把這個屬性加入到與建構子相連結的原型。例如，假定你修改前面的代碼如下︰</p> +<pre>function Employee () { + this.dept = "general"; +} +Employee.prototype.name = ""; + +function WorkerBee () { +this.projects = []; +} +WorkerBee.prototype = new Employee; + +amy = new WorkerBee; + +Employee.prototype.name = "Unknown"; +</pre> +<p>在這個情況下，<code>amy</code> 的 <code>name</code> 屬性就會變成 "Unknown"。</p> +<p>如同這些範例所示，如果你希望物件的屬性有預設值，而且還希望能夠在執行時期修改這些預設值，你就應該在建構子的原型中設定這些屬性，而不是在建構子函數本身。</p> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承", "Core_JavaScript_1.5_教學:再談屬性的繼承:實體關係的確定") }}</p> +</div> + +<p>{{ 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" } ) }}</p> 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..717baf86bb --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_60d6c39d4282c67c117db9fdaf83be08/index.html @@ -0,0 +1,44 @@ +--- +title: 沒有多重繼承 +slug: >- + conflicting/Web/JavaScript/Guide/Details_of_the_Object_Model_60d6c39d4282c67c117db9fdaf83be08 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/No_Multiple_Inheritance +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/沒有多重繼承 +--- +<h3 id="沒有多重繼承" name="沒有多重繼承">沒有多重繼承</h3> +<p>部分物件導向語言允許多重繼承。也就是說，物件可以從互不相關的親物件繼承屬性和值。不過 JavaScript 並不支援多重繼承。</p> +<p>屬性值的繼承發生在執行時期，由 JavaScript 搜尋物件的原型鏈以找出繼承值。由於物件只有單一的已連結原型，因此 JavaScript 並不能從多於一個以上的原型鏈中動態的繼承。</p> +<p>在 JavaScript 中，建構子函數的內部可以有很多個其他的建構子函數的呼叫。如此可提供多重繼承的假象。例如，思考下面的語句︰</p> +<pre>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") +</pre> +<p>接著假定 <code>WorkerBee</code> 的定義使用的是本章先前的內容。在這個情況下，<code>dennis</code> 物件就有了這些屬性︰</p> +<pre>dennis.name == "Doe, Dennis" +dennis.dept == "engineering" +dennis.projects == ["collabra"] +dennis.machine == "hugo" +dennis.hobby == "scuba" +</pre> +<p>所以 <code>dennis</code> 從 <code>Hobbyist</code> 建構子中得到了 <code>hobby</code> 的屬性。然而，假定你稍後把新的屬性加入到 <code>Hobbyist</code> 建構子的原型︰</p> +<pre>Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"] +</pre> +<p><code>dennis</code> 物件並未繼承到這個新的屬性。</p> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承:建構子中的全域資訊", "Core_JavaScript_1.5_教學:LiveConnect_概要") }}</p> +</div> + +<p>{{ 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" } ) }}</p> 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..b437e78707 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_8898a6dd437cc51f48b4e8cade0385ac/index.html @@ -0,0 +1,60 @@ +--- +title: 建構子中的全域資訊 +slug: >- + conflicting/Web/JavaScript/Guide/Details_of_the_Object_Model_8898a6dd437cc51f48b4e8cade0385ac +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 +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/建構子中的全域資訊 +--- +<h3 id="建構子中的全域資訊" name="建構子中的全域資訊">建構子中的全域資訊</h3> +<p>當你建立建構子的時候，如果你在建構子中設定全域資訊，需要很小心。例如，假定你想要自動的給每一個新的職員指定一個專有的 ID。你可以給 <code>Employee</code> 使用下面的定義︰</p> +<pre>var idCounter = 1; + +function Employee (name, dept) { + this.name = name || ""; + this.dept = dept || "general"; + this.id = idCounter++; +} +</pre> +<p>根據這個定義，當你建立新的 <code>Employee</code> 的時候，建構子會依序把下一個 ID 指定給他，然後增加全域 ID 的計數器。因此，如果你的下一條語句如下，<code>victoria.id</code> 為 1，且 <code>harry.id</code> 為 2︰</p> +<pre>victoria = new Employee("Pigbert, Victoria", "pubs") +harry = new Employee("Tschopik, Harry", "sales") +</pre> +<p>乍看之下很好。然而，<code>idCounter</code> 會在每一次建立 <code>Employee</code> 物件的時候遞增，而不問用途。如果你建立顯示在本章中的整個 <code>Employee</code> 階層結構，<code>Employee</code> 建構子會在你每一次設定原型的時候被呼叫。假設你有下面的代碼︰</p> +<pre>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"); +</pre> +<p>在此略過 <code>base</code> 屬性的定義，並呼叫原型鏈中在他們之上的建構子。在這個情況下，等到 <code>mac</code> 物件被建立的時候，<code>mac.id</code> 是 5。</p> +<p>根據應用程式而定，計數器遞增了額外的次數，這也許重要，也許不重要。如果你很在意計數器額外的數值，有一個可能的解決方案是改用下面的建構子來代替︰</p> +<pre>function Employee (name, dept) { + this.name = name || ""; + this.dept = dept || "general"; + if (name) + this.id = idCounter++; +} +</pre> +<p>當你建立用作為原型的 <code>Employee</code> 實體時候，你並不需要提供參數給建構子。使用這個定義的建構子，當你並未提供參數時，建構子並不會把值代入給 id，也不會更新計數器。因此，若要 <code>Employee</code> 取得指定的 id，你就必須為職員指定名稱。在這個範例中，<code>mac.id</code> 將會是 1。</p> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承:實體關係的確定", "Core_JavaScript_1.5_教學:再談屬性的繼承:沒有多重繼承") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..bca39463d4 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_937645e235e25783cc4e9b0d7a1f6d76/index.html @@ -0,0 +1,16 @@ +--- +title: 再談屬性的繼承 +slug: >- + conflicting/Web/JavaScript/Guide/Details_of_the_Object_Model_937645e235e25783cc4e9b0d7a1f6d76 +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承 +--- +<h3 id="再談屬性的繼承" name="再談屬性的繼承">再談屬性的繼承</h3> +<p>前面的章節說明了 JavaScript 建構子和原型如何提供階層組織和實體。本節將會討論一些稍早的討論中所看不到的細微差別。</p> +<ul> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%86%8D%E8%AB%87%E5%B1%AC%E6%80%A7%E7%9A%84%E7%B9%BC%E6%89%BF/%E5%B1%80%E5%9F%9F%E5%80%BC%E5%92%8C%E7%B9%BC%E6%89%BF%E5%80%BC" title="zh_tw/Core_JavaScript_1.5_教學/再談屬性的繼承/局域值和繼承值">局域值和繼承值</a></li> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%86%8D%E8%AB%87%E5%B1%AC%E6%80%A7%E7%9A%84%E7%B9%BC%E6%89%BF/%E5%AF%A6%E9%AB%94%E9%97%9C%E4%BF%82%E7%9A%84%E7%A2%BA%E5%AE%9A" title="zh_tw/Core_JavaScript_1.5_教學/再談屬性的繼承/實體關係的確定">實體關係的確定</a></li> <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%86%8D%E8%AB%87%E5%B1%AC%E6%80%A7%E7%9A%84%E7%B9%BC%E6%89%BF/%E5%BB%BA%E6%A7%8B%E5%AD%90%E4%B8%AD%E7%9A%84%E5%85%A8%E5%9F%9F%E8%B3%87%E8%A8%8A" title="zh_tw/Core_JavaScript_1.5_教學/再談屬性的繼承/建構子中的全域資訊">建構子中的全域資訊</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%86%8D%E8%AB%87%E5%B1%AC%E6%80%A7%E7%9A%84%E7%B9%BC%E6%89%BF/%E6%B2%92%E6%9C%89%E5%A4%9A%E9%87%8D%E7%B9%BC%E6%89%BF" title="zh tw/Core JavaScript 1.5 教學/再談屬性的繼承/沒有多重繼承">沒有多重繼承</a></li> +</ul> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:職員的例子:更靈活的建構子", "Core_JavaScript_1.5_教學:再談屬性的繼承:局域值和繼承值") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..ea17a4b80d --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/details_of_the_object_model_b021bd32308e4c421518cdd7104ac7bc/index.html @@ -0,0 +1,147 @@ +--- +title: 更靈活的建構子 +slug: >- + conflicting/Web/JavaScript/Guide/Details_of_the_Object_Model_b021bd32308e4c421518cdd7104ac7bc +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/The_Employee_Example/More_Flexible_Constructors +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子/更靈活的建構子 +--- +<h3 id="更靈活的建構子" name="更靈活的建構子">更靈活的建構子</h3> +<p>目前為止所介紹的建構子函數並不能讓你在建立實體的時候指定屬性值。如同 Java 一般，你可以提供參數給建構子來為實體初始化屬性值。下圖顯示了做到這點的其中一個方式。</p> +<p><img alt="Image:hier05.gif" class="internal" src="/@api/deki/files/712/=Hier05.gif"><br> +<small><strong>圖 8.5: 在建構子中指定屬性，之一</strong></small></p> +<p>下表顯示出 Java 和 JavaScript 對這些物件的定義。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>JavaScript</th> <th>Java</th> </tr> <tr> <td> <pre> +function Employee (name, dept) { + this.name = name || ""; + this.dept = dept || "general"; +} +</pre> </td> <td> <pre> +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; + } +} +</pre> </td> </tr> <tr> <td> <pre> +function WorkerBee (projs) { + this.projects = projs || []; +} +WorkerBee.prototype = new Employee; +</pre> </td> <td> <pre> +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; + } +} + +</pre> </td> </tr> <tr> <td> <pre> + +function Engineer (mach) { + this.dept = "engineering"; + this.machine = mach || ""; +} +Engineer.prototype = new WorkerBee; +</pre> </td> <td> <pre> +public class Engineer extends WorkerBee { + public String machine; + public Engineer () { + dept = "engineering"; + machine = ""; + } + public Engineer (String mach) { + dept = "engineering"; + machine = mach; + } +} +</pre> </td> </tr> </tbody> +</table> +<p><br> +JavaScript 的這些定義使用了特殊的用語來設定預設值︰</p> +<pre>this.name = name || ""; +</pre> +<p>JavaScript 的邏輯 OR 運算子 (||) 會對他的第一參數求值。如果參數轉換為 true，運算子就返回這個參數。否則，運算子返回第二個參數的值。因此，這一行測試代碼可以看成，如果 <code>name</code> 具有對 <code>name</code> 屬性而言有用的值。如果是的話，他就把 <code>this.name</code> 設定成這個值。否則，他就把 <code>this.name</code> 設定成空字串。為簡單起見，本章使用這個用語；然而，第一眼看到這種用法的時候會使人迷惑不解<span style="font-style: italic;">。</span><em>請注意</em>︰這個用法在數字或布林參數中，可能不會如預期般運作，例如 <code>0</code>（零）和 <code>false</code> 會導致預設值被選取；在這種情況下，你將會需要使用下面更為冗長的用語，他會使所有的資料類型都發生預期般的行為︰</p> +<pre>this.authorized = typeof(authorized) !== 'undefined' ? authorized : true; +</pre> +<p>當你使用這個定義來建立物件的實體的時候，你可以為在局域中定義的屬性來指定值。如同圖 8.5 所示，你可以使用如下語句來建立新的 Engineer︰</p> +<pre>jane = new Engineer("belau"); +</pre> +<p> <code>Jane</code> 的屬性現在是︰</p> +<pre>jane.name == ""; +jane.dept == "engineering"; +jane.projects == []; +jane.machine == "belau" +</pre> +<p>注意這些定義，你不能為像 <code>name</code> 這種繼承下來的屬性指定初始值。如果你想要在 JavaScript 中，給繼承下來的屬性指定初始值，你就需要加入更多的代碼到建構子函數中。</p> +<p>截至目前為止，建構子函數建立了通用的物件，然後為新物件指定局域的屬性和值。你的建構子也可以直接呼叫建構子函數，來為原型鏈中較高層的物件加入更多的屬性。下圖顯示了這些定義。</p> +<p><img alt="Image:hier06.gif" class="internal" src="/@api/deki/files/713/=Hier06.gif"><br> +<small><strong>圖 8.6 在建構子中指定屬性，之二</strong></small></p> +<p>讓我們來更仔細的觀察其中一個定義。這是 Engineer 建構子的新定義︰</p> +<pre>function Engineer (name, projs, mach) { + this.base = WorkerBee; + this.base(name, "engineering", projs); + this.machine = mach || ""; +} +</pre> +<p>假設你如下建立新的 <code>Engineer</code> 物件︰</p> +<pre>jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau"); +</pre> +<p>JavaScript 遵循以下步驟︰</p> +<ol> <li>new 運算子建立通用物件，並且把他的 <code>__proto__</code> 屬性設定為 <code>Engineer.prototype</code>。</li> <li>new 運算子把新物件傳遞給 <code>Engineer</code> 建構子當作 <code>this</code> 關鍵字的值。</li> <li>建構子為這個物件建立稱為 <code>base</code> 的新屬性，並且把 <code>WorkerBee</code> 建構子的值代入給 <code>base</code> 屬性。這會使 <code>WorkerBee</code> 建構子成為 <code>Engineer</code> 物件的一個方法。<code>base</code> 屬性的名稱並無特別之處。你可以使用任意的有效的屬性名稱；<code>base</code> 這個名稱只是簡單的為了他的用途而取的。</li> <li>建構子呼叫 <code>base</code> 方法，把傳入給建構子的其中兩個參數（"Doe, Jane" 以及 {{ mediawiki.external('\"navigator\", \"javascript\"') }}）以及字串 "engineering" 當作自己的參數傳入。在建構子中明確的使用 "engineering"，表明了所有 <code>Engineer</code> 物件所繼承下來的 <code>dept</code> 屬性都有相同的值，而且這個值會覆蓋繼承自 <code>Employee</code> 的值。</li> <li>因為 <code>base</code> 是 <code>Engineer</code> 的方法，<code>base</code> 呼叫端的內部是 JavaScript 在步驟 1 時和新建立的物件綁在一起的 <code>this</code> 關鍵字。因此，<code>WorkerBee</code> 函數依序把 "Doe, Jane" 以及 {{ mediawiki.external('\"navigator\", \"javascript\"') }} 參數傳遞給 <code>Employee</code> 建構子函數。從 <code>Employee</code> 建構子函數返回以後，<code>WorkerBee</code> 函數使用剩下的參數來設定 <code>projects</code> 屬性。</li> <li>從 <code>base</code> 方法返回以後，<code>Engineer</code> 建構子把物件的 <code>machine</code> 屬性初始化成 "belau"。</li> <li>從建構子返回以後，JavaScript 就把新物件代入給 <code>jane</code> 變數。</li> +</ol> +<p>你可能在想，要從 <code>Engineer</code> 建構子的內部呼叫 <code> WorkerBee</code> 的建構子，明明你已經為 <code>Engineer</code> 物件設置適當的繼承了。實際情形並非如此。呼叫 <code>WorkerBee</code> 建構子可以確保，與已指定屬性的 <code>Engineer</code> 物件一起開始的所有建構子函數都會被呼叫。然而，如果你稍後把屬性加入到 <code>Employee</code> 或者 <code>WorkerBee</code> 屬性，這些屬性並不會被 <code>Engineer</code> 物件所繼承。例如，假設你使用如下語句︰</p> +<pre>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"; +</pre> +<p><code>jane</code> 物件並未繼承 <code>specialty</code> 屬性。你仍然需要明確的設置原型，以確保動態繼承。假設你改用這些語句︰</p> +<pre>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"; +</pre> +<p>現在 <code> jane</code> 物件的 <code>specialty</code> 屬性的值是 "none"。</p> +<hr> +<p>另一種繼承的方式是使用 <code>.call</code>/<code>.apply</code> 方法。以下兩者是等價的︰</p> +<table> <tbody> <tr> <td> <pre class="eval"> +function Engineer (name, projs, mach) { + this.base = WorkerBee; + this.base(name, "engineering", projs); + this.machine = mach || ""; +} +</pre> </td> <td> <pre class="eval"> +function Engineer (name, projs, mach) { + WorkerBee.call(this, name, "engineering", projs); + this.machine = mach || ""; +} +</pre> </td> </tr> </tbody> +</table> +<p>使用 Javascript<span style="font-family: monospace;"> 的 </span><code>.call</code> 方法可以產生較為簡潔的實作，因為不再需要 <code>".base"</code>。</p> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:職員的例子:物件的屬性:屬性的加入", "Core_JavaScript_1.5_教學:再談屬性的繼承") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..3acabca172 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators/index.html @@ -0,0 +1,17 @@ +--- +title: 表達式 +slug: conflicting/Web/JavaScript/Guide/Expressions_and_Operators +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Expressions +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/表達式 +--- +<p> </p> +<h3 id="表達式" name="表達式">表達式</h3> +<p><em>表達式</em>即任何有效的一組字面表達、變數、運算子、可求值的單一的值，值可以使用數字、字串、或邏輯值。</p> +<p>大致上來說，表達式可分為兩種︰把值代入給變數，和單純的持有值。例如，表達式 <code>x = 7</code> 是把值 7 代入給 x 的表達式。表達式本身的求值結果是 7。這些表達式使用<em>代入運算子</em>。換句話說，表達式 <code>3 + 4</code> 單純的求值結果為 7，且沒有代入動作。這些表達式使用的運算子又可以簡單的稱為<em>運算子</em>。</p> +<p>JavaScript 有以下幾種表達式︰</p> +<ul> <li>算術式: 求出數值，例如，3.14159。（一般使用 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E7%AE%97%E8%A1%93%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/算術運算子">算術運算子</a>。）</li> <li>字串式: 求出字元、字串，例如，"Fred" 或 "234"。（一般使用 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E5%AD%97%E4%B8%B2%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/字串運算子">字串運算子</a>。）</li> <li>邏輯式: 求出真值或假值。（通常和 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E9%82%8F%E8%BC%AF%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/邏輯運算子">邏輯運算子</a> 有關。）</li> <li>物件式: 求出物件。（參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E7%89%B9%E6%AE%8A%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/特殊運算子">特殊運算子</a> 取得有關求出物件的各種例子。）</li> +</ul> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:Unicode", "Core_JavaScript_1.5_教學:運算子") }}</p> + +<p>{{ 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" } ) }}</p> 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..52ff50ee43 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_05717c12b1ecaebc9d68cf43524d31b1/index.html @@ -0,0 +1,22 @@ +--- +title: 算術運算子 +slug: >- + conflicting/Web/JavaScript/Guide/Expressions_and_Operators_05717c12b1ecaebc9d68cf43524d31b1 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Arithmetic_Operators +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/算術運算子 +--- +<p> </p> +<h3 id="算術運算子" name="算術運算子">算術運算子</h3> +<p>算術運算子把數值（字面表達或變數其中一種）作為運算元，並返回 1 個數值。標準的算術運算子有加法 (+)、減法 (-)、乘法 (*)、除法 (/)。這些運算子在大部分的程式語言中，都以原來的方式運作。當使用於浮點數時（須特別注意，除以零會產生 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E5%B1%AC%E6%80%A7/NaN" title="zh tw/Core JavaScript 1.5 參考/全域屬性/NaN"><code>NaN</code></a>）︰</p> +<pre class="eval">1 / 2 // 在 JavaScript 中返回 0.5 +1 / 2 // 在 Java 中返回 0（這兩個數並未明確表示為浮點數） + +1.0 / 2.0 // 在 JavaScript 和 Java 中都返回 0.5 +</pre> +<p>此外，JavaScript 提供了列於下表的算術運算子。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>運算子</th> <th>說明</th> <th>範例</th> </tr> <tr> <td>%（模數）</td> <td>二元運算子。返回兩數相除之後的整數餘數。</td> <td>12 % 5 返回 2。</td> </tr> <tr> <td>++（遞增）</td> <td>一元運算子。運算元加 1。如果用作為前綴運算子 (++x)，返回運算元加 1 之後的值；如果用作為後綴運算子 (x++)，返回運算元加 1 之前的值。</td> <td>如果 <code>x</code> 是 3，然後 <code>++x</code> 把 <code>x</code> 設為 4 並返回 4，反之 <code>x++</code> 返回 3，然後把 <code>x</code> 設為 4。</td> </tr> <tr> <td>--（遞減）</td> <td>一元運算子。運算元減 1。返回的值和遞增運算子類似。</td> <td>如果 <code>x</code> 是 3，然後 <code>--x</code> 把 <code>x</code> 設為 2 並返回 2，反之 <code>x--</code> 返回 3，然後把 <code>x</code> 設為 2。</td> </tr> <tr> <td>-（正負反轉）</td> <td>一元運算子。返回將運算子的正負號反轉的值。</td> <td>如果 <code>x</code> 是 3，然後 <code>-x</code> 返回 -3。</td> </tr> </tbody> +</table> +<p><small><strong>表 3.4: 算術運算子</strong></small></p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:比較運算子", "Core_JavaScript_1.5_教學:運算子:位元運算子") }}</p> +<p>{{ 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" } ) }}</p> 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..900bd8c313 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_11969cb29fead65c26360f554426c217/index.html @@ -0,0 +1,33 @@ +--- +title: 位元運算子 +slug: >- + conflicting/Web/JavaScript/Guide/Expressions_and_Operators_11969cb29fead65c26360f554426c217 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Bitwise_Operators +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/位元運算子 +--- +<p> </p> +<p> </p> +<h3 id="位元運算子" name="位元運算子">位元運算子</h3> +<p>位元運算子把他們的運算元視為一組 32 位元的集合（零或一），而非十進制、十六進制、八進制。例如，十進制數 9 的二進制表示法為 1001。位元運算子對這些二進制表示法進行運算，並返回標準的 JavaScript 數值。</p> +<p>下表解說 JavaScript 的位元運算子。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>運算子</th> <th>用法</th> <th>說明</th> </tr> <tr> <td>位元 AND</td> <td><code>a & b</code></td> <td>每一個對應至同一位元位置的兩個運算元兩者為 1 時，返回 1。</td> </tr> <tr> <td>位元 OR</td> <td><code>a | b</code></td> <td>每一個對應至同一位元位置的兩個運算元兩者或其中一者為 1 時，返回 1。</td> </tr> <tr> <td>位元 XOR</td> <td><code>a ^ b</code></td> <td>每一個對應至同一位元位置的兩個運算元其中一者而非兩者為 1 時，返回 1。</td> </tr> <tr> <td>位元 NOT</td> <td><code>~ a</code></td> <td>反轉運算元的位元。</td> </tr> <tr> <td>左移</td> <td><code>a << b</code></td> <td>往左移動 a 的二進制表示法 b 位元，從右邊補 0。</td> </tr> <tr> <td>維持符號右移</td> <td><code>a >> b</code></td> <td>往右移動 a 的二進制表示法 b 位元，丟棄移出的位元。</td> </tr> <tr> <td>填 0 右移</td> <td><code>a >>> b</code></td> <td>往右移動 a 的二進制表示法 b 位元，丟棄移出的位元，並從左邊補 0。</td> </tr> </tbody> +</table> +<p><small><strong>表 3.5: 位元運算子</strong></small></p> +<h4 id="位元邏輯運算子" name="位元邏輯運算子">位元邏輯運算子</h4> +<p>大致上，位元邏輯運算子的運作如下︰</p> +<ul> <li>運算元轉換成 32 位元整數，並表示為一系列的位元（0 或 1）。</li> <li>第一個運算元的每一個位元與第二個運算元對應的位元結成配對︰第一個位元對第一個位元、第二個位元對第二個位元，餘類推。</li> <li>運算子套用到每一對位元，運算結果以位元構成。</li> +</ul> +<p>舉個例子，9 的二進制表示法是 1001，15 的二進制表示法是 1111。因此，當位元的運算子套用到這些值上時，結果如下︰</p> +<ul> <li>15 & 9 的結果是 9 (1111 & 1001 = 1001)</li> <li>15 | 9 的結果是 15 (1111 | 1001 = 1111)</li> <li>15 ^ 9 的結果是 6 (1111 ^ 1001 = 0110)</li> +</ul> +<h4 id="位元位移運算子" name="位元位移運算子">位元位移運算子</h4> +<p>位元位移運算子有兩個運算元︰第一個是被移動的數值，第二個指定第一個運算元要移動的位元位置的數目。位移運算元的方向是以使用的運算元來控制。</p> +<p>位移運算子轉換這些運算元為 32 位元整數，並返回與左邊運算元同類型的結果。</p> +<p>位移運算子列於下表。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>運算子</th> <th>說明</th> <th>範例</th> </tr> <tr> <td><<（左移）</td> <td>這個運算子把第一個運算元向左移動指定的位元數。丟棄向左移出的多餘位元。從右邊填補 0 的位元。</td> <td>9<<2 的結果是 36，因為 1001 向左移動 2 位元而變成 100100，此即 36。</td> </tr> <tr> <td>>>（維持符號右移）</td> <td>這個運算子把第一個運算元向右移動指定的位元數。丟棄向右移出的多餘位元。從左邊填補在最左邊複製的位元。</td> <td>9>>2 的結果是 2，因為 1001 向右移動 2 位元而變成 10，此即 2。同樣的，-9>>2 的結果是 -3，因為保留了正負號。</td> </tr> <tr> <td>>>>（填 0 右移）</td> <td>這個運算子把第一個運算元向右移動指定的位元數。丟棄向右移出的多餘位元。從右邊填補 0 的位元。</td> <td>19>>>2 的結果是 4，因為 10011 向右移動 2 位元而變成 100，此即 4。對於非負數而言，補 0 右移和維持符號右移的結果相同。</td> </tr> </tbody> +</table> +<p><small><strong>表 3.6: 位元位移運算子</strong></small></p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:算術運算子", "Core_JavaScript_1.5_教學:運算子:邏輯運算子") }}</p> + +<p>{{ 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" } ) }}</p> 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..e6c3371fd8 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_351a6d9e4d31b32eff9762ef5deead93/index.html @@ -0,0 +1,45 @@ +--- +title: 邏輯運算子 +slug: >- + conflicting/Web/JavaScript/Guide/Expressions_and_Operators_351a6d9e4d31b32eff9762ef5deead93 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Logical_Operators +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/邏輯運算子 +--- +<p> </p> +<h3 id="邏輯運算子" name="邏輯運算子">邏輯運算子</h3> +<p>邏輯運算子通常和布林（邏輯）值一起使用，並返回布林值。然而，&& 和 || 運算子實際上返回的是指定的運算元的其中一個的值，所以如果這些運算子與非布林值一起使用，有可能返回非布林值。邏輯運算子的說明如下表。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>運算子</th> <th>用法</th> <th>說明</th> </tr> <tr> <td>&&</td> <td>expr1 && expr2</td> <td>（邏輯 AND）如果 expr1 可以轉換為 false，就返回 expr1。否則返回 expr2。所以，當使用於布林值時，如果兩個運算元都為 true，&& 返回 true。否則返回 false。</td> </tr> <tr> <td>||</td> <td>expr1 || expr2</td> <td>（邏輯 OR）如果 expr1 可以轉換為 true，就返回 expr1。否則返回 expr2。所以，當使用於布林值時，如果其中一個運算元為 true，|| 返回 true，如果兩個運算元都為 false，就返回 false。</td> </tr> <tr> <td>!</td> <td>!expr</td> <td>（邏輯 NOT）如果運算元可以轉換為 true，就返回 false。否則返回 true。</td> </tr> </tbody> +</table> +<p><small><strong>表 3.7: 邏輯運算子</strong></small></p> +<p>可以轉換成 false 的表達式的例子有︰對 null、0、空字串 ("") 或 undefined 求值。</p> +<p>以下代碼為 &&（邏輯 AND）運算子的範例。</p> +<pre>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 +</pre> +<p>以下代碼為 ||（邏輯 OR）運算子的範例。</p> +<pre>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 +</pre> +<p>以下代碼為 !（邏輯 NOT）運算子的範例。</p> +<pre>n1=!true // !t 返回 false +n2=!false // !f 返回 true +n3=!"Cat" // !t 返回 false +</pre> +<h4 id="求值的最短路徑" name="求值的最短路徑">求值的最短路徑</h4> +<p>由於邏輯表達式是由左往右求值，他們使用以下規則來測試，儘可能以“最短路徑”求值︰</p> +<ul> <li><code>false</code> && <em>anything</em> 中的 false 是求值的最短路徑。</li> <li><code>true</code> || <em>anything</em> 中的 true 是求值的最短路徑。</li> +</ul> +<p>這些邏輯規則保證求出的值永遠正確。注意，上述表達式中的 <em>anything</em> 部分並未求值，因此所有未求值的部分都不會產生作用。</p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:位元運算子", "Core_JavaScript_1.5_教學:運算子:字串運算子") }}</p> +<p>{{ 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" } ) }}</p> 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..f080db0e15 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_952d66f1fe521bc0574c89750f5b406e/index.html @@ -0,0 +1,188 @@ +--- +title: 特殊運算子 +slug: >- + conflicting/Web/JavaScript/Guide/Expressions_and_Operators_952d66f1fe521bc0574c89750f5b406e +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Special_Operators +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/特殊運算子 +--- +<p> </p> +<h3 id="特殊運算子" name="特殊運算子">特殊運算子</h3> +<p>JavaScript 提供下列的特殊運算子︰</p> +<ul> <li>{{ Anch("條件運算子") }}</li> <li>{{ Anch("逗號運算子") }}</li> <li>{{ Anch("delete") }}</li> <li>{{ Anch("in") }}</li> <li>{{ Anch("instanceof") }}</li> <li>{{ Anch("new") }}</li> <li>{{ Anch("this") }}</li> <li>{{ Anch("typeof") }}</li> <li>{{ Anch("void") }}</li> +</ul> +<h4 id="條件運算子" name="條件運算子">條件運算子</h4> +<p>條件運算子是 JavaScript 唯一使用三個運算元的運算子。運算子根據條件得到兩個值的其中一個。語法為︰</p> +<pre>condition ? val1 : val2 +</pre> +<p>如果 <code>condition</code> 為 true，運算子得到 <code>val1</code> 的值。否則得到 <code>val2</code> 的值。你可以在條件運算子上使用標準運算子。</p> +<p>例如，</p> +<pre>status = (age >= 18) ? "adult" : "minor" +</pre> +<p>這個語句把“adult”的值代入給變數 <code>status</code>，只要 <code>age</code> 是 18 以上。否則，把“minor”的值代入給 <code>status</code>。</p> +<h4 id="逗號運算子" name="逗號運算子">逗號運算子</h4> +<p>逗號運算子 (,) 簡單的對他的兩個運算元求值，並返回第二個運算元的值。這個運算子主要用在 <code>for</code> 迴圈內部，使多個變數可在每一次的循環中更新。</p> +<p>例如，如果 <code>a</code> 是各邊含有 10 個元素的二維陣列，以下代碼使用逗號運算子同時遞增兩個變數。這個代碼在陣列裡輸出斜三角元素︰</p> +<pre>for (var i=0, j=9; i <= 9; i++, j--) + document.writeln("a["+i+"]["+j+"]= " + a[i][j]) +</pre> +<h4 id="delete" name="delete">delete</h4> +<p>delete 運算子可刪除物件、物件的屬性、陣列中指定索引的元素。語法為︰</p> +<pre>delete objectName +delete objectName.property +delete objectName[index] +delete property // 只在 with 語法之內有效 +</pre> +<p>此處的 <code>objectName</code> 是指物件的名稱，<code>property</code> 是指現存的屬性，<code>index</code> 是指陣列中以整數表示的元素位置。</p> +<p>第四種於物件中刪除屬性的形式，只在 <code>with</code> 語法之內有效。</p> +<p>你可以使用 <code>delete</code> 運算子刪除以隱式宣告、沒有使用 <code>var</code> 語法的變數。</p> +<p>如果 <code>delete</code> 運算子成功的話，他會把屬性或元素設定為 <code>undefined</code>。如果操作是可行的話，<code>delete</code> 運算子返回 true；如果操作不可行，就返回 false。</p> +<pre>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（如果以隱式宣告，就可以刪除）</pre> +<p><strong>刪除陣列裡的元素</strong><br> +當你刪除陣列元素時，陣列的長度並不受影響。舉例來說，如果你刪除 a{{ mediawiki.external(3) }}，a{{ mediawiki.external(4) }} 仍然是 {{ mediawiki.external(4) }}，a{{ mediawiki.external(3) }} 則是 undefined。</p> +<p>當 <code>delete</code> 運算子移除陣列的元素時，這個元素便不復存在於陣列之中。在以下範例中，使用 <code>delete</code> 移除 trees{{ mediawiki.external(3) }}。</p> +<pre>trees=new Array("redwood","bay","cedar","oak","maple") +delete trees[3] +if (3 in trees) { + // 此處不會被執行 +} +</pre> +<p>如果你希望陣列元素存在、且元素的值是未定義，就使用 <code>undefined</code> 關鍵字取代 <code>delete</code> 運算子。在以下範例中，<code>trees{{ mediawiki.external(3) }}</code> 的值被代入為 <code>undefined</code>，而陣列元素仍然存在︰</p> +<pre>trees=new Array("redwood","bay","cedar","oak","maple") +trees[3]=undefined +if (3 in trees) { + // 此處會被執行 +} +</pre><h4 id="in" name="in">in</h4> +<p>如果指定的屬性存在於指定的物件中，<code>in</code> 運算子返回 true。語法為︰</p> +<pre>propNameOrNumber in objectName +</pre> +<p>此處 <code>propNameOrNumber</code> 是指表示為屬性名的字串、或表示為陣列索引的數值的表達式，<code>objectName</code> 是指物件的名稱。</p> +<p>以下範例示範 <code>in</code> 運算子的使用方法。</p> +<pre>// 陣列 +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 +</pre><h4 id="instanceof" name="instanceof">instanceof</h4> +<p>如果指定的物件屬於指定的物件的類型，<code>instanceof</code> 運算子返回 true。語法為︰</p> +<pre>objectName instanceof objectType +</pre> +<p>此處 <code>objectName</code> 是指用來和 <code>objectType</code> 作比較的物件的名稱，<code>objectType</code> 是指物件的類型，如 <code>Date</code> 或 <code>Array</code>。</p> +<p>當你需要確認執行中物件的類型時，就使用 <code>instanceof</code>。舉個例子，當接受到例外時，你可以根據被拋出的例外來決定要執行哪一條例外處理。</p> +<p>例如，以下代碼使用 <code>instanceof</code> 確認 <code>theDay</code> 是否屬於 <code>Date</code> 物件。由於 <code>theDay</code> 屬於 <code>Date</code> 物件，所以會執行 <code>if</code> 語法裡的語句。</p> +<pre>theDay=new Date(1995, 12, 17) +if (theDay instanceof Date) { + // 被執行的語句 +} +</pre><h4 id="new" name="new">new</h4> +<p>你可以使用 <code>new</code> 運算子來建立使用者定義的物件類型的實體，或建立預先定義的物件類型 <code>Array、Boolean</code><code>、</code><code>Date</code><code>、</code><code>Function</code><code>、</code><code>Image</code><code>、</code><code>Number</code><code>、</code><code>Object</code><code>、</code><code>Option</code><code>、</code><code>RegExp</code><code>、</code><code>String</code> 其中之一。在伺服器上，你也可以用於 <code>DbPool</code><code>、</code><code>Lock</code><code>、</code><code>File</code><code>、</code><code>SendMail</code>。<code>new</code> 的使用方法如下︰</p> +<pre>objectName = new objectType ( param1 [,param2] ...[,paramN] ) +</pre> +<p>你也可以使用物件的初始化子來建立物件，如同 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BB%BA%E7%AB%8B%E6%96%B0%E7%9A%84%E7%89%A9%E4%BB%B6/%E7%89%A9%E4%BB%B6%E5%88%9D%E5%A7%8B%E5%8C%96%E5%AD%90%E7%9A%84%E4%BD%BF%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學/建立新的物件/物件初始化子的使用">物件初始化子的使用</a> 所述。</p> +<p>參閱 Core JavaScript 參考中的 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E9%81%8B%E7%AE%97%E5%AD%90/%E7%89%B9%E6%AE%8A%E9%81%8B%E7%AE%97%E5%AD%90/new_%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 參考/運算子/特殊運算子/new 運算子">new 運算子</a> 頁面，以取得更多資訊。</p><h4 id="this" name="this">this</h4> +<p>使用 <code>this</code> 關鍵字可參考目前所使用的物件。一般而言，<code>this</code> 是在方法裡、並參考了呼叫這個方法的物件。<code>this</code> 的使用方法如下︰</p> +<pre>this[propertyName] +</pre> +<p><strong>範例 1</strong><br> +假設有一個稱為 <code>validate</code> 的函數可驗證某一物件的 <code>value</code> 屬性，並以物件和上限、下限值作為參數︰</p> +<pre>function validate(obj, lowval, hival) { + if ((obj.value < lowval) || (obj.value > hival)) + alert("Invalid Value!") +} +</pre> +<p>你可以在每一個表單元素的 <code>onChange</code> 事件處理器中呼叫 <code>validate</code>，並使用 <code>this</code> 傳送表單元素，如下範例︰</p> +<pre><B>Enter a number between 18 and 99:</B> +<INPUT TYPE = "text" NAME = "age" SIZE = 3 + onChange="validate(this, 18, 99)"> +</pre> +<p><strong>範例 2</strong><br> +結合 <code>form</code> 屬性時，<code>this</code> 也可以參考目前所使用的物件的親表單。在以下範例中，表單 <code>myForm</code> 內含一個 <code>Text</code> 物件和按鈕。當使用者點擊按鈕，<code>Text</code> 物件的值便設定為表單的名稱。按鈕的 <code>onClick</code> 事件處理器使用 <code>this.form</code> 來參考親表單 <code>myForm</code>。</p> +<pre><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> +</pre> +<h4 id="typeof" name="typeof">typeof</h4> +<p><code>typeof</code> 運算子可按下列兩種方式來使用︰</p> +<pre>1. typeof operand +2. typeof (operand) +</pre> +<p><code>typeof</code> 運算子可返回字串，這些字串指出未求值的運算元的類型。<code>operand</code> 是指字串、變數、關鍵字、物件，其類型可被 <code>typeof</code> 返回。括弧並非必要的。</p> +<p>假設你定義了以下變數︰</p> +<pre>var myFun = new Function("5+2") +var shape="round" +var size=1 +var today=new Date() +</pre> +<p><code>typeof</code> 運算子對以下變數返回以下結果︰</p> +<pre>typeof myFun 返回的是 function +typeof shape 返回的是 string +typeof size 返回的是 number +typeof today 返回的是 object +typeof dontExist 返回的是 undefined +</pre> +<p>對於 <code>true</code> 和 <code>null</code> 關鍵字而言，<code>typeof</code> 運算子返回以下結果︰</p> +<pre>typeof true 返回的是 boolean +typeof null 返回的是 object +</pre> +<p>對於數字或字串而言，<code>typeof</code> 運算子返回以下結果︰</p> +<pre>typeof 62 返回的是 number +typeof 'Hello world' 返回的是 string +</pre> +<p>對於屬性值而言，<code>typeof</code> 運算子返回屬性裡的值的類型︰</p> +<pre>typeof document.lastModified 返回的是 string +typeof window.length 返回的是 number +typeof Math.LN2 返回的是 number +</pre> +<p>對於方法和函數而言，<code>typeof</code> 運算子返回以下結果︰</p> +<pre>typeof blur 返回的是 function +typeof eval 返回的是 function +typeof parseInt 返回的是 function +typeof shape.split 返回的是 function +</pre> +<p>對於預先定義的物件而言，<code>typeof</code> 運算子返回以下結果︰</p> +<pre>typeof Date 返回的是 function +typeof Function 返回的是 function +typeof Math 返回的是 function +typeof Option 返回的是 function +typeof String 返回的是 function +</pre> +<h4 id="void" name="void">void</h4> +<p><code>void</code> 運算子可按下列兩種方式來使用︰</p> +<pre>1. void (expression) +2. void expression +</pre> +<p><code>void</code> 運算子表示表達式求值之後不必把值返回。<code>expression</code> 是指可供求值的 JavaScript 表達式。表達式兩邊的圓括號並不是必要的，但圓括號的使用對閱讀有利。</p> +<p>你可以把 <code>void</code> 運算子使用於當作超連結的表達式。表達式會被求值，但不會被載入而取代目前的文件。</p> +<p>以下代碼建立了什麼也不做的超連結。當使用者點擊連結時，<code>void(0)</code> 的求值為 undefined，這在 JavaScript 中並沒有作用。</p> +<pre><A HREF="javascript:void(0)">Click here to do nothing</A> +</pre> +<p>以下代碼建立了超連結，當使用者點擊時，就傳送表單。</p> +<pre><A HREF="javascript:void(document.form.submit())"> +Click here to submit</A> +</pre> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:字串運算子", "Core_JavaScript_1.5_教學:正規表達式的建立") }}</p> +<p>{{ 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" } ) }}</p> 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..57fc4f5c9a --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e6fc14473511cf01e7062dfb7751f49d/index.html @@ -0,0 +1,32 @@ +--- +title: 運算子 +slug: >- + conflicting/Web/JavaScript/Guide/Expressions_and_Operators_e6fc14473511cf01e7062dfb7751f49d +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子 +--- +<p> </p> +<h3 id="運算子" name="運算子">運算子</h3> +<p>JavaScript 有以下幾種運算子。本節說明運算子，且包含有關運算子優先順序的資訊。</p> +<ul> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E4%BB%A3%E5%85%A5%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/代入運算子">代入運算子</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E6%AF%94%E8%BC%83%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/比較運算子">比較運算子</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E7%AE%97%E8%A1%93%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/算術運算子">算術運算子</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E4%BD%8D%E5%85%83%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/位元運算子">位元運算子</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E9%82%8F%E8%BC%AF%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/邏輯運算子">邏輯運算子</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E5%AD%97%E4%B8%B2%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/字串運算子">字串運算子</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%81%8B%E7%AE%97%E5%AD%90/%E7%89%B9%E6%AE%8A%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/運算子/特殊運算子">特殊運算子</a></li> +</ul> +<p>JavaScript 有一元和二元兩種運算子，以及特殊的三元運算子，也就是條件運算子。二元運算子需要兩個運算元，一個在運算子之前，一個在運算子之後︰</p> +<pre>operand1 operator operand2 +</pre> +<p>例如，<code>3+4</code> 或 <code>x*y</code>。</p> +<p>一元運算子需要一個運算元，可以運算子之前或之後︰</p> +<pre>operator operand +</pre> +<p>或</p> +<pre>operand operator +</pre> +<p><span style="font-family: monospace;">例如，</span><code>x++</code> 或 <code>++x</code>。</p> +<h4 id="運算子的優先順序" name="運算子的優先順序">運算子的優先順序</h4> +<p><small><em>按照<a href="/Talk:en/Core_JavaScript_1.5_Guide/Operators#Precedence_Table" title="Talk:en/Core_JavaScript_1.5_Guide/Operators#Precedence_Table">相關的討論</a>，本表採用<strong>由高到低</strong>的優先順序。</em></small></p> +<table class="fullwidth-table"> <tbody> <tr> <th>運算子類型</th> <th>單獨的運算子</th> </tr> <tr> <td>成員</td> <td>. []</td> </tr> <tr> <td>呼叫 / 建立實體</td> <td>() new</td> </tr> <tr> <td>反轉 / 遞增</td> <td>! ~ - + ++ -- typeof void delete</td> </tr> <tr> <td>乘法 / 除法</td> <td>* / %</td> </tr> <tr> <td>加法 / 減法</td> <td>+ -</td> </tr> <tr> <td>位元位移</td> <td><< >> >>></td> </tr> <tr> <td>關係</td> <td>< <= > >= in instanceof</td> </tr> <tr> <td>等價</td> <td>== != === !==</td> </tr> <tr> <td>位元 AND</td> <td>&</td> </tr> <tr> <td>位元 XOR</td> <td>^</td> </tr> <tr> <td>位元 OR</td> <td>|</td> </tr> <tr> <td>邏輯 AND</td> <td>&&</td> </tr> <tr> <td>邏輯 OR</td> <td>||</td> </tr> <tr> <td>條件</td> <td>?:</td> </tr> <tr> <td>代入</td> <td>= += -= *= /= %= <<= >>= >>>= &= ^= |=</td> </tr> <tr> <td>逗號</td> <td>,</td> </tr> </tbody> +</table> +<p><small><strong>表 3.1: 運算子的優先順序</strong></small></p> +<p>有關本表的詳細版本，且附有關於運算子的完整細節，請參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E9%81%8B%E7%AE%97%E5%AD%90/%E9%81%8B%E7%AE%97%E5%AD%90%E7%9A%84%E5%84%AA%E5%85%88%E9%A0%86%E5%BA%8F#%E8%A1%A8" title="zh tw/Core JavaScript 1.5 參考/運算子/運算子的優先順序#表">參考的章節</a>。</p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:表達式", "Core_JavaScript_1.5_教學:運算子:代入運算子") }}</p> +<p>{{ 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" } ) }}</p> 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..64ee4bfe92 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_e70c1f2655520c542321ddbdb2c4f28d/index.html @@ -0,0 +1,67 @@ +--- +title: 代入運算子 +slug: >- + conflicting/Web/JavaScript/Guide/Expressions_and_Operators_e70c1f2655520c542321ddbdb2c4f28d +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Comparison_Operators +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/代入運算子 +--- +<p> </p> +<h3 id="代入運算子" name="代入運算子">代入運算子</h3> +<p>代入運算子根據右邊運算元的值，把值代入給左邊運算元的值。最基本的代入運算子是等號 (=)，他會把右邊運算元的值代入給左邊運算元的值。也就是說，x = y 就是把 y 的值代入給 x。</p> +<p>其餘的代入運算子只是標準運算子的簡記法，如下表所示。</p> +<table class="fullwidth-table"> + <tbody> + <tr> + <th>運算子的簡記法</th> + <th>意義</th> + </tr> + <tr> + <td>x += y</td> + <td>x = x + y</td> + </tr> + <tr> + <td>x -= y</td> + <td>x = x - y</td> + </tr> + <tr> + <td>x *= y</td> + <td>x = x * y</td> + </tr> + <tr> + <td>x /= y</td> + <td>x = x / y</td> + </tr> + <tr> + <td>x %= y</td> + <td>x = x % y</td> + </tr> + <tr> + <td>x <<= y</td> + <td>x = x << y</td> + </tr> + <tr> + <td>x >>= y</td> + <td>x = x >> y</td> + </tr> + <tr> + <td>x >>>= y</td> + <td>x = x >>> y</td> + </tr> + <tr> + <td>x &= y</td> + <td>x = x & y</td> + </tr> + <tr> + <td>x ^= y</td> + <td>x = x ^ y</td> + </tr> + <tr> + <td>x |= y</td> + <td>x = x | y</td> + </tr> + </tbody> +</table> +<p><small><strong>表 3.2: 代入運算子</strong></small></p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:運算子", "Core_JavaScript_1.5_教學:運算子:比較運算子") }}</p> +<p> </p> 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..05b4e3b3d6 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/expressions_and_operators_eb65eb8f4e6b3c16f08b95149183cfb8/index.html @@ -0,0 +1,14 @@ +--- +title: 字串運算子 +slug: >- + conflicting/Web/JavaScript/Guide/Expressions_and_Operators_eb65eb8f4e6b3c16f08b95149183cfb8 +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/String_Operators +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/字串運算子 +--- +<p> </p> +<h4 id="字串運算子" name="字串運算子">字串運算子</h4> +<p>除了比較運算子可以用於字串值以外，連結運算子 (+) 把兩個字串值串連在一起，返回另一個以兩個運算元字串連結的字串。例如，<code>"my " + "string"</code> 返回<code> "my string"</code> 字串。</p> +<p>代入運算子 += 的簡記法也可用於連結字串。例如，如果變數 <code>mystring</code> 內有 "alpha" 值，<code>mystring += "bet"</code> 表達式的求值為“alphabet”，並把這個值代入到 <code>mystring</code>。</p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:邏輯運算子", "Core_JavaScript_1.5_教學:運算子:特殊運算子") }}</p> +<p>{{ 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" } ) }}</p> 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..503122c1bb --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions/index.html @@ -0,0 +1,35 @@ +--- +title: 函數的呼叫 +slug: conflicting/Web/JavaScript/Guide/Functions +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Calling_Functions +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/函數的呼叫 +--- +<p> </p> +<div class="onlyinclude"> +<h3 id="函數的呼叫">函數的呼叫</h3> +<p>定義函數並不會執行函數。函數的定義只是簡單的給函數命名，並指定當函數被呼叫的時候要做些什麼。函數的<em>呼叫</em>會以指定的參數真正的執行指定的動作。例如，如果你定義了函數 square，你可以如下呼叫。</p> +<pre>square(5) +</pre> +<p>上面的語句以 5 為參數呼叫函數。函數執行他的語句，並返回 25 的值。</p> +<p>函數的參數並不限於字串和數字。你也可以傳遞一整個物件給函數。<code>show_props</code> 函數（定義在 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E7%89%A9%E4%BB%B6%E5%92%8C%E5%B1%AC%E6%80%A7" title="zh tw/Core JavaScript 1.5 教學/物件和屬性">物件和屬性</a>）即是接收一個物件作為參數的函數的範例。</p> +<p>函數甚至可以遞歸循環，也就是他可以呼叫他自己。例如，這裡有個計算階乘的函數︰</p> +<pre>function factorial(n) { + if ((n == 0) || (n == 1)) + return 1; + else { + var result = (n * factorial(n-1) ); + return result; + } +} +</pre> +<p>你可以計算一到五的階乘如下︰</p> +<pre>a=factorial(1); // 返回 1 +b=factorial(2); // 返回 2 +c=factorial(3); // 返回 6 +d=factorial(4); // 返回 24 +e=factorial(5); // 返回 120 +</pre> +</div> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:函數的定義", "Core_JavaScript_1.5_教學:arguments_物件的使用") }}</p> +<p>{{ 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" } ) }}</p> 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..2c791124d8 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_536f6bf46bbdf38cc1a0b28ca1bc41b9/index.html @@ -0,0 +1,37 @@ +--- +title: Number 和 String 函數 +slug: conflicting/Web/JavaScript/Guide/Functions_536f6bf46bbdf38cc1a0b28ca1bc41b9 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/parseInt_and_parseFloat_Functions +original_slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/Number_和_String_函數 +--- +<h4 id="Number_和_String_函數">Number 和 String 函數</h4> +<div class="onlyinclude"> +<p><code>Number</code> 和 <code>String</code> 函數讓你把物件轉換為數字或字串。這些函數的語句是︰</p> +<pre>var objRef=Number(objRef); +var objRef=String(objRef); +</pre> +<p>此處的 <code>objRef</code> 就是物件的參考。</p> +<p>以下的範例把 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/Date" title="zh tw/Core JavaScript 1.5 參考/全域物件/Date">Date</a></code> 物件轉換為可讀的字串。</p> +<pre>var D = new Date (430054663215); +// 返回以下字串 +// "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983" +var x = String(D); +</pre> +</div> +<p> </p> +<p>以下範例把 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/String" title="zh tw/Core JavaScript 1.5 參考/全域物件/String">String</a></code> 物件轉換為 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/Number" title="zh tw/Core JavaScript 1.5 參考/全域物件/Number"><font face="Courier New">Number</font></a> 物件。</p> +<pre>var str="12"; +var num=Number(str); +</pre> +<p>你可以使用 DOM 的方法 write() 和 JavaScript 的 typeof 運算子來檢驗。</p> +<pre>var str="12"; +document.write(typeof str); +document.write("<br/>"); +var num=Number(str); +document.write(typeof num); +</pre> +<p> {{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:parseInt_和_parseFloat_函數", "Core_JavaScript_1.5_教學:預先定義的函數:escape_和_unescape_函數") }}</p> +<p>{{ 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" } ) }}</p> 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..1e8d32dd1a --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_587eb671a310bac0771e73a91b0abe6d/index.html @@ -0,0 +1,16 @@ +--- +title: 預先定義的函數 +slug: conflicting/Web/JavaScript/Guide/Functions_587eb671a310bac0771e73a91b0abe6d +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數 +--- +<p> </p> +<div class="onlyinclude"> +<h3 id="預先定義的函數" name="預先定義的函數">預先定義的函數</h3> +<p>JavaScript 有一些最頂層的已預先定義的函數︰</p> +<ul> <li><a href="/zh%20tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E5%87%BD%E6%95%B8/eval_%E5%87%BD%E6%95%B8" title="zh tw/Core_JavaScript_1.5_教學/預先定義的函數/eval_函數">eval</a></li> <li><a href="/zh%20tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E5%87%BD%E6%95%B8/isFinite_%E5%87%BD%E6%95%B8" title="zh tw/Core_JavaScript_1.5_教學/預先定義的函數/isFinite_函數">isFinite</a></li> <li><a href="/zh%20tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E5%87%BD%E6%95%B8/isNaN_%E5%87%BD%E6%95%B8" title="zh tw/Core_JavaScript_1.5_教學/預先定義的函數/isNaN_函數">isNaN</a></li> <li><a href="/zh%20tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E5%87%BD%E6%95%B8/parseInt_%E5%92%8C_parseFloat_%E5%87%BD%E6%95%B8" title="zh tw/Core_JavaScript_1.5_教學/預先定義的函數/parseInt_和_parseFloat_函數">parseInt 和 parseFloat</a></li> <li><a href="/zh%20tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E5%87%BD%E6%95%B8/Number_%E5%92%8C_String_%E5%87%BD%E6%95%B8" title="zh tw/Core_JavaScript_1.5_教學/預先定義的函數/Number_和_String_函數">Number 和 String</a></li> <li><a href="/zh%20tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E5%87%BD%E6%95%B8/escape_%E5%92%8C_unescape_%E5%87%BD%E6%95%B8" title="zh tw/Core_JavaScript_1.5_教學/預先定義的函數/escape_和_unescape_函數">encodeURI、decodeURI、encodeURIComponent、decodeURIComponent（Javascript 1.5 以後的版本皆可使用）。</a></li> +</ul> +</div> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:arguments_物件的使用", "Core_JavaScript_1.5_教學:預先定義的函數:eval_函數") }}</p> +<p>{{ 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" } ) }}</p> 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..7d47f51efa --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_925b2d10050621507a9c990cb803dcca/index.html @@ -0,0 +1,27 @@ +--- +title: isNaN 函數 +slug: conflicting/Web/JavaScript/Guide/Functions_925b2d10050621507a9c990cb803dcca +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isNaN_Function +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/isNaN_函數 +--- +<p> </p> +<div class="onlyinclude"> +<h4 id="isNaN_函數">isNaN 函數</h4> +<p><code>isNaN</code> 函數對參數求值，來判斷是不是〝NaN〞（不是數字，not a number）。<code>isNaN</code> 的語句如下︰</p> +<pre>isNaN(testValue) +</pre> +<p>此處的 <code>testValue</code> 就是你想要求值的值。</p> +<p><code>parseFloat</code> 和 <code>parseInt</code> 函數會在求出來的值不是數字的時候返回〝NaN〞<span style="font-family: monospace;">。</span>如果傳入的是〝NaN〞，<code>isNaN</code> 返回 true，否則為 false。</p> +<p>以下的代碼會對 <code>floatValue</code> 求值，來判斷這是不是數字，然後呼叫相應的程序︰</p> +<pre>floatValue=parseFloat(toFloat) + +if (isNaN(floatValue)) { + notFloat() +} else { + isFloat() +} +</pre> +</div> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:isFinite_函數", "Core_JavaScript_1.5_教學:預先定義的函數:parseInt_和_parseFloat_函數") }}</p> +<p>{{ 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" } ) }}</p> 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..17ab662b6a --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_b2cd05cbfe188215dc2e3f972d293ed6/index.html @@ -0,0 +1,25 @@ +--- +title: isFinite 函數 +slug: conflicting/Web/JavaScript/Guide/Functions_b2cd05cbfe188215dc2e3f972d293ed6 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isFinite_Function +original_slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/isFinite_函數 +--- +<p> </p> +<div class="onlyinclude"> +<h4 id="isFinite_函數">isFinite 函數</h4> +<p><code>isFinite</code> 函數會對參數求值，來判斷是否是有限的數字。<code>isFinite</code> 的語法如下︰</p> +<pre>isFinite(number) +</pre> +<p>此處的 number 就是要求值的數字。</p> +<p>如果參數是 <code>NaN</code>、正無限大、負無限大，這個方法就會返回 <code>false</code>，否則就會返回 <code>true</code>。</p> +<p>以下的代碼會檢查客戶端的輸入，來判斷是否是有限的數字。</p> +<pre>if(isFinite(ClientInput)) +{ + /* 適當的處理 */ +} +</pre> +</div> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:eval_函數", "Core_JavaScript_1.5_教學:預先定義的函數:isNaN_函數") }}</p> +<p>{{ 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" } ) }}</p> 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..5fdc5ab320 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_ceaa4b2a55bb67388c2728af1ff890f5/index.html @@ -0,0 +1,22 @@ +--- +title: escape 和 unescape 函數 +slug: conflicting/Web/JavaScript/Guide/Functions_ceaa4b2a55bb67388c2728af1ff890f5 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/escape_and_unescape_Functions +original_slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/escape_和_unescape_函數 +--- +<p> </p> +<div class="onlyinclude"> +<h4 id="escape_和_unescape_函數">escape 和 unescape 函數</h4> +<p><code>escape</code> 和 <code>unescape</code> 函數可讓你把字串編碼或解碼。<code>escape</code> 函數會返回以 ISO Latin 字元集來表示參數的十六進制編碼。<code>unescape</code> 函數會對指定的十六進制編碼值返回 ASCII 字串。</p> +<p>這些函數的語句是︰</p> +<pre>escape(string) +unescape(string) +</pre> +<p>這些函數主要是在伺服端的 JavaScript 用來編碼或解碼 URL 裡的名稱和值的配對。</p> +<p><code>escape</code> 和 <code>unescape</code> 函數在非 ASCII 字元下無法正確運作，也已被廢棄。在 JavaScript 1.5 及其後版本中，可以改用 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E5%87%BD%E6%95%B8/encodeURI" title="zh tw/Core JavaScript 1.5 參考/全域函數/encodeURI">encodeURI</a></code>、<code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E5%87%BD%E6%95%B8/decodeURI" title="zh tw/Core JavaScript 1.5 參考/全域函數/decodeURI">decodeURI</a></code>、<code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E5%87%BD%E6%95%B8/encodeURIComponent" title="zh tw/Core JavaScript 1.5 參考/全域函數/encodeURIComponent">encodeURIComponent</a></code>、<code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E5%87%BD%E6%95%B8/decodeURIComponent" title="zh tw/Core JavaScript 1.5 參考/全域函數/decodeURIComponent">decodeURIComponent</a></code>。</p> +</div> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:Number_和_String_函數", "Core_JavaScript_1.5_教學:閉鎖的運用") }}</p> +<p>{{ 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" } ) }}</p> 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..129d1ceaff --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/functions_effb9b1bcc102a5f6df7f1785ce89033/index.html @@ -0,0 +1,18 @@ +--- +title: eval 函數 +slug: conflicting/Web/JavaScript/Guide/Functions_effb9b1bcc102a5f6df7f1785ce89033 +translation_of: Web/JavaScript/Guide/Functions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/eval_Function +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/eval_函數 +--- +<p> </p> +<div class="onlyinclude"> +<h4 id="eval_函數" name="eval_函數">eval 函數</h4> +<p><code>eval</code> 函數無須參考實際的物件，就可以對 JavaScript 代碼的字串直接求值。eval 語法如下︰</p> +<pre>eval(expr) +</pre> +<p>此處 <code>expr</code> 就是要被求值的字串。</p> +<p>如果字串表示成表達式，<code>eval</code> 就會對表達式求值。如果參數（<code>expr</code>）表示成一個以上的 JavaScript 語句，eval 就會對語句求值。<code>eval</code> 代碼的作用域等同於呼叫端代碼的作用域。不要用 <code>eval</code> 來對算術表達式求值，JavaScript 會自動的對算術表達式來求值。</p> +</div> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數", "Core_JavaScript_1.5_教學:預先定義的函數:isFinite_函數") }}</p> +<p>{{ 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" } ) }}</p> 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..d8c6b9697c --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types/index.html @@ -0,0 +1,34 @@ +--- +title: Unicode +slug: conflicting/Web/JavaScript/Guide/Grammar_and_types +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Unicode +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/Unicode +--- +<p> </p> +<h3 id="Unicode" name="Unicode">Unicode</h3> +<p>Unicode 是一種全球通用的字元編碼標準，用於交換並顯示主要的書寫語言。Unicode 涵括了美國、歐洲、中東、非洲、印度、亞洲以及太平洋地區的語系，但不包括歷史手稿和專門符號。Unicode 可用於交換、處理並顯示多國語系的文書，除了一般的專門符號和數學符號以外。Unicode 期望能夠解決對於不同國家的字元標準的多國語言處理等國際化問題。但目前並未完整支援所有的現代或古代的文字。</p> +<p>Unicode 字元集可以使用所有已知編碼的字元。Unicode 是繼 ASCII（American Standard Code for Information Interchange；美國資訊交換標準碼）字元集之後的字元集模型。Unicode 為每一個字元分配一個數字和名稱。字元編碼規範了字元的識別資訊及其數值（編碼位置），但未指明數值的位元表示法。16 位元數值（編碼值）是以十六進制數並加上前綴 U 來定義的，例如，U+0041 表示 A。這個數值的專用名稱是 LATIN CAPITAL LETTER A。</p> +<p><strong>JavaScript 1.3 以前的版本並不支援 </strong><strong>Unicode。</strong></p> +<h4 id="Unicode_與_ASCII_和_ISO_的相容性" name="Unicode_與_ASCII_和_ISO_的相容性">Unicode 與 ASCII 和 ISO 的相容性</h4> +<p>Unicode 完全相容於國際標準 ISO/IEC 10646-1; 1993，屬於 ISO 10646 的子集。</p> +<p>若干編碼標準（包括 UTF-8、UTF-16、ISO UCS-2）是用來把 Unicode 表示為實際的位元。</p> +<p>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 個位元組。</p> +<p>JavaScript 和 Navigator 支援 UTF-8/Unicode，意味著你只需在 JavaScript 程式中加上特別的技術，就可以使用非拉丁文、國際性、地域性的文字。Unicode 為多國文字的編碼提供了標準方法。由於 Unicode 的 UTF-8 編碼可相容於 ASCII，程式可以使用 ASCII 字元。你可以在 JavaScript 的註解、字串的字面表達、識別子、正則表達式中使用非 ASCII 的 Unicode 字元。</p> +<h4 id="Unicode_的跳脫序列" name="Unicode_的跳脫序列">Unicode 的跳脫序列</h4> +<p>你可以在字串的字面表達、正則表達式、識別子中使用 Unicode 跳脫序列。跳脫序列是由 6 個 ASCII 字元所構成︰\u 和 4 個十六進制數。例如，\u00A9 表示版權符號。在 JavaScript 中，所有的 Unicode 跳脫序列都會被解譯為單一字元。</p> +<p>以下代碼返回版權符號和字串 "Netscape Communications"。</p> +<pre>x="\u00A9 Netscape Communications"</pre> +<p>下表列出最常用的特殊字元及其 Unicode 值。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>分類</th> <th>Unicode 值</th> <th>名稱</th> <th>格式名稱</th> </tr> <tr> <td>空白的值</td> <td>\u0009</td> <td>Tab</td> <td><TAB></td> </tr> <tr> <td> </td> <td>\u000B</td> <td>Vertical Tab</td> <td><VT></td> </tr> <tr> <td> </td> <td>\u000C</td> <td>Form Feed</td> <td><FF></td> </tr> <tr> <td> </td> <td>\u0020</td> <td>Space</td> <td><SP></td> </tr> <tr> <td>行終止的值</td> <td>\u000A</td> <td>Line Feed</td> <td><LF></td> </tr> <tr> <td> </td> <td>\u000D</td> <td>Carriage Return</td> <td><CR></td> </tr> <tr> <td>額外的 Unicode 跳脫序列的值</td> <td>\u0008</td> <td>Backspace</td> <td><BS></td> </tr> <tr> <td> </td> <td>\u0009</td> <td>Horizontal Tab</td> <td><HT></td> </tr> <tr> <td> </td> <td>\u0022</td> <td>Double Quote</td> <td>"</td> </tr> <tr> <td> </td> <td>\u0027</td> <td>Single Quote</td> <td>'</td> </tr> <tr> <td> </td> <td>\u005C</td> <td>Backslash</td> <td>\</td> </tr> </tbody> +</table> +<p><small><strong>表 2.2: 特殊字元的 Unicode 值</strong></small></p> +<p>JavaScript 使用的 Unicode 跳脫序列與 Java 不同。在 JavaScript 中，跳脫序列一開始不會被解譯為特殊字元。例如，字串裡的換行的跳脫序列，在給函數解譯以前，並不會使字串換行。JavaScript 會忽略所有使用在註解裡的跳脫序列。在 Java 中，如果跳脫序列使用在單行註解裡，就會被解譯為 Unicode 字元。對於字串的字面表達而言，Java 編譯器將首先解譯跳脫序列。例如，如果在 Java 中使用換行的跳脫字元（即 \u000A），就會使字串的字面表達換行。這在 Java 中會引起錯誤，因為換行不可以用在字串的字面表達。你必須給字串的字面表達的換行替換成 \n。在 JavaScript 中，也同樣使用 \n 作為跳脫序列。</p> +<h4 id="在_JavaScript_檔案裡的_Unicode_字元" name="在_JavaScript_檔案裡的_Unicode_字元">在 JavaScript 檔案裡的 Unicode 字元</h4> +<p><a class="internal" href="/zh_tw/Gecko" title="zh tw/Gecko">Gecko</a> 的早期版本假設從 XUL 載入的 JavaScript 檔案使用的是 Latin-1 字元編碼。從 Gecko 1.8 開始，就從 XUL 檔案的編碼來推斷字元編碼。請參閱 <a class="internal" href="/zh_tw/%E5%9C%A8_XUL_JavaScript_%E4%B8%AD%E7%9A%84%E5%9C%8B%E9%9A%9B%E5%8C%96%E5%AD%97%E5%85%83" title="zh tw/在 XUL JavaScript 中的國際化字元">在 XUL JavaScript 中的國際化字元</a> 取得進一步資訊。</p> +<h4 id="使用_Unicode_顯示字元" name="使用_Unicode_顯示字元">使用 Unicode 顯示字元</h4> +<p>你可以使用 Unicode 顯示不同語言或專門符號的字元。為使字元正確的顯示，像 Mozilla Firefox 或 Netscape 這類客戶端也需要支援 Unicode。此外，客戶端也必須有可用的 Unicode 字型，客戶端平台也必須支援 Unicode。通常，Unicode 字型並不會顯示所有的 Unicode 字元。部分平台，如 Windows 95，只提供對 Unicode 的一部分支援。</p> +<p>要接收非 ASCII 字元的輸入，客戶端需要把傳送進來的輸入視為 Unicode。使用標準的增強式鍵盤，客戶端無法簡單的輸入由 Unicode 支援的額外字元。在某些時候，使用 Unicode 跳脫序列輸入 Unicode 字元是唯一的輸入方法。</p> +<p>有關 Unicode 的詳細資訊，參閱 <a class="external" href="http://www.unicode.org/">Unicode 首頁</a> 以及 1996 年由 Addison-Wesley 出版的 Unicode Standard, Version 2.0。</p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:字面表達", "Core_JavaScript_1.5_教學:表達式") }}</p> +<p>{{ 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" } ) }}</p> 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..c2a24450e8 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_5c6f30ff8e011c45a011b9c8f3b5bcea/index.html @@ -0,0 +1,32 @@ +--- +title: 值 +slug: >- + conflicting/Web/JavaScript/Guide/Grammar_and_types_5c6f30ff8e011c45a011b9c8f3b5bcea +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Values +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/值 +--- +<p> </p> +<h3 id="值" name="值">值</h3> +<p>JavaScript 識別下列值的類型︰</p> +<ul> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/%E6%95%B8%E5%80%BC" title="zh tw/Core JavaScript 1.5 參考/全域物件/數值">數值</a>，如 42 或 3.14159</li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/%E5%B8%83%E6%9E%97" title="zh tw/Core JavaScript 1.5 參考/全域物件/布林">邏輯值（布林）</a>，<code>true</code> 或 <code>false</code></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/%E5%AD%97%E4%B8%B2" title="zh tw/Core JavaScript 1.5 參考/全域物件/字串">字串</a>，如 "Howdy!"</li> <li><code>null</code>，用來表示空值的特殊關鍵字；<code>null</code> 也是一個原始值。由於 JavaScript 區分大小寫，<code>null</code> 與 <code>Null</code>、<code>NULL</code> 等變體並不相同</li> <li><code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E5%B1%AC%E6%80%A7/undefined" title="zh tw/Core JavaScript 1.5 參考/全域屬性/undefined">undefined</a></code>，一個值為未定義的頂級屬性；<code>undefined</code> 也是一個原始值。</li> +</ul> +<p>這是相對來說比較小的一組值的類型，也就是<em>資料類型</em>，可讓你的應用程式發揮出有用的功能。整數和實數之間並沒有明顯的區別。在 JavaScript 中也沒有明確的日期資料類型。不過你還是可以使用 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/%E6%97%A5%E6%9C%9F" title="zh tw/Core JavaScript 1.5 參考/全域物件/日期">Date</a></code> 物件及其方法來處理日期。<a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/%E7%89%A9%E4%BB%B6" title="zh tw/Core JavaScript 1.5 參考/全域物件/物件">物件</a> 和 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/%E5%87%BD%E6%95%B8" title="zh tw/Core JavaScript 1.5 參考/全域物件/函數">函數</a> 也是語言的基礎元素。你可以把物件想成已命名的值的容器，而函數是使程式可以執行的處理程序。</p> +<h4 id="資料類型的轉換" name="資料類型的轉換">資料類型的轉換</h4> +<p>JavaScript 是動態類型的語言。這表示當你宣告變數時，你不必指定變數的資料類型，而且資料類型會在 Script 執行過程中按需要自動的轉換。所以，舉例如下，你可以如下定義變數︰</p> +<pre class="brush: js">var answer = 42; +</pre> +<p>然後，你可以把字串值代入給值，如下︰</p> +<pre>answer = "Thanks for all the fish..."; +</pre> +<p>因為 JavaScript 的類型是動態的，這個代入的代碼不會引起錯誤訊息。</p> +<p>在含有數值和字串值並介以 + 運算子的表達式中，JavaScript 把數值轉換為字串。例如，考慮下面的語句︰</p> +<pre class="eval">x = "The answer is " + 42 // 返回 "The answer is 42" +y = 42 + " is the answer" // 返回 "42 is the answer" +</pre> +<p>在含有其他運算子的語句裡，JavaScript 不會把數值轉換為字串。例如︰</p> +<pre class="eval">"37" - 7 // 返回 30 +"37" + 7 // 返回 "377" +</pre> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:JavaScript_概要", "Core_JavaScript_1.5_教學:變數") }}</p> +<p>{{ 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" } ) }}</p> 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..625bc12ba3 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_d57082c2207b466127d8dc34a980addf/index.html @@ -0,0 +1,120 @@ +--- +title: 字面表達 +slug: >- + conflicting/Web/JavaScript/Guide/Grammar_and_types_d57082c2207b466127d8dc34a980addf +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Literals +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/字面表達 +--- +<p> </p> +<h3 id="字面表達" name="字面表達">字面表達</h3> +<p>你在 JavaScript 使用字面表達來表示值。這是由你在 Script 中<em>直接寫下</em>的固定值，這些不是變數。本節說明下列各類型的字面表達︰</p> +<ul> <li>{{ Anch("陣列的字面表達") }}</li> <li>{{ Anch("布林的字面表達") }}</li> <li>{{ Anch("整數") }}</li> <li>{{ Anch("浮點數的字面表達") }}</li> <li>{{ Anch("物件的字面表達") }}</li> <li>{{ Anch("字串的字面表達") }}</li> +</ul> +<h4 id="陣列的字面表達" name="陣列的字面表達">陣列的字面表達</h4> +<p>陣列的字面表達是以零個以上的表達式所構成的列表，列表的每一項代表陣列的元素，以方括號 ([]) 包夾。當你使用陣列的字面表達建立陣列時，陣列會以指定的值作為元素來初始化，也會以指定的參數個數來設定陣列的長度。</p> +<p>以下範例以三個元素和長度建立 <code>coffees</code> 陣列︰</p> +<pre class="eval">var coffees = ["French Roast", "Colombian", "Kona"]; +</pre> +<p><strong>附註:</strong> 陣列的字面表達是物件初始化子的一種類型。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%BB%BA%E7%AB%8B%E6%96%B0%E7%9A%84%E7%89%A9%E4%BB%B6/%E7%89%A9%E4%BB%B6%E5%88%9D%E5%A7%8B%E5%8C%96%E5%AD%90%E7%9A%84%E4%BD%BF%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學/建立新的物件/物件初始化子的使用">物件初始化子的使用</a>。</p> +<p>如果在頂層 Script 裡使用字面表達建立陣列，每一次對含有陣列的字面表達的表達式求值時，JavaScript 就會解譯這些陣列。此外，每一次呼叫函數時，在函數中使用的字面表達就會被建立。</p> +<p>陣列的字面表達也是 Array 物件。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E6%A0%B8%E5%BF%83%E7%89%A9%E4%BB%B6/Array_%E7%89%A9%E4%BB%B6" title="zh tw/Core JavaScript 1.5 教學/預先定義的核心物件/Array 物件">Array 物件</a> 取得有關 Array 物件的細節。</p> +<p><strong>陣列的字面表達的額外的逗號</strong></p> +<p>你不必在陣列的字面表達中指定所有的元素。如果你放上兩個連續的逗號，就會為未指定的元素預留空間來建立陣列。以下範例建立 <code>fish</code> 陣列︰</p> +<pre class="eval">var fish = ["Lion", , "Angel"]; +</pre> +<p>這個陣列含有兩個附有值的元素和一個空的元素（<code>fish{{ mediawiki.external(0) }}</code> 是“Lion”，<code>fish{{ mediawiki.external(1) }}</code> 是 <code>undefined</code>，<code>fish{{ mediawiki.external(2) }}</code> 是“Angel”）。</p> +<p>如果你在元表列表的尾部附帶逗號，這個逗號會被忽略。在下面的範例中，陣列的長度是 3，這裡不存在 <code>myList{{ mediawiki.external(3) }}</code>。所在位於列表裡面的逗號指的都是新的元素。</p> +<pre class="eval">var myList = ['home', , 'school', ]; +</pre> +<p>在下面的範例中，陣列的長度是 4，<code>myList{{ mediawiki.external(0) }}</code> 和 <code>myList{{ mediawiki.external(2) }}</code> 是空的。</p> +<pre class="eval">var myList = [ , 'home', , 'school']; +</pre> +<p>在下面的範例中，陣列的長度是 4，<code>myList{{ mediawiki.external(1) }}</code> 和 <code>myList{{ mediawiki.external(3) }}</code> 是空的。只有最後面的逗號被忽略。</p> +<pre class="eval">var myList = ['home', , 'school', , ]; +</pre><h4 id="布林的字面表達" name="布林的字面表達">布林的字面表達</h4> +<p>布林類型有兩種字面表達︰<code>true</code> 和 <code>false</code>。</p> +<p>別被原始布林值的 <code>true</code>、<code>false</code> 和 Boolean 物件的 true、false 的值混淆了。Boolean 物件是以原始布林資料類型包裝起來的。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E6%A0%B8%E5%BF%83%E7%89%A9%E4%BB%B6/Boolean_%E7%89%A9%E4%BB%B6" title="zh tw/Core JavaScript 1.5 教學/預先定義的核心物件/Boolean 物件">Boolean 物件</a> 取得更多資訊。</p><h4 id="整數" name="整數">整數</h4> +<p>整數可以表示為十進制、十六進制、八進制。十進制整數的字面表達由一系列不以 0 開頭的數字組成。以 0 開頭的整數的字面表達表示他是八進制，以 0x（或 0X）開頭表示十六進制。十六進制整數可以包含數字 (0-9) 和 a-f 和 A-F 的字母。八進制整數只可以包含 0-7 的數字。</p> +<p>八進制整數的字面表達在 ECMA-262 第三版的標準中已不被推薦。JavaScript 1.5 為了向後相容，仍然繼續支援。</p> +<p>整數的字面表達的一些範例︰</p> +<pre class="eval">0、117、-345（十進制） +015、0001、-077（八進制） +0x1123、0x00111、-0xF1A7（十六進制） +</pre> +<h4 id="浮點數的字面表達" name="浮點數的字面表達">浮點數的字面表達</h4> +<p>浮點數的字面表達可分為以下部分︰</p> +<ul> <li>可帶正負號的十進制整數（在前面加上“+”或“-”），</li> <li>小數點（“.”），</li> <li>小數部分（十進制數），</li> <li>指數部分。</li> +</ul> +<p>指數部分是以一個“e”或“E”後接數字所組成，可帶正負符號（在前面加上“+”或“-”）。浮點數的字面表達至少必須要有一個數字和一個小數點或“e”（或“E”）。</p> +<p>浮點數的字面表達的一些範例有 3.1415、-3.1E12、.1e12、2E-12。</p> +<p>表示成更精簡的語法結構是︰</p> +<pre class="eval">[digits][.digits][(E|e)[(+|-)]digits] +</pre> +<p>例如︰</p> +<pre class="eval">3.14 +2345.789 +.3333333333333333333 +</pre> +<h4 id="物件的字面表達" name="物件的字面表達">物件的字面表達</h4> +<p>物件的字面表達是以零個以上的 屬性名稱-關聯值 的配對所構成，以花括號 ({}) 包夾。你不應該在語句的開始處使用物件的字面表達。這會導致錯誤，或出現非預期的行為，因為 { 會被解譯成區塊的開始處。</p> +<p>以下是物件的字面表達的範例。<code>car</code> 物件的第一個元素定義了 <code>myCar</code> 屬性；第二個元素，<code>getCar</code> 屬性，含有函數 <code>(CarTypes("Honda"));</code>；第三個元素，<code>special</code> 屬性，使用了現存的變數（<code>Sales</code>）。</p> +<pre class="eval">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 +</pre> +<p>此外，你可以使用數值或字串的字面表達作為屬性的名稱，或者嵌入其他的物件。以下是上述的範例。</p> +<pre class="eval">var car = { manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda" }; + +document.write(car.manyCars.b); // Jeep +document.write(car[7]); // Mazda +</pre> +<p>請注意︰</p> +<pre class="eval">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 +</pre><h4 id="字串的字面表達" name="字串的字面表達">字串的字面表達</h4> +<p>字串的字面表達是以零個以上的字元所構成，並以雙引號 (") 或單引號 (') 包夾。字串必須以相同的引號包夾，也就是成對的單、雙引號。以下是字串的字面表達的範例︰</p> +<ul> <li>"blah"</li> <li>'blah'</li> <li>"1234"</li> <li>"one line \n another line"</li> <li>"John's cat"</li> +</ul> +<p>你可以在字串的字面表達的值上呼叫 String 物件的所有方法—JavaScript 會自動的把字串的字面表達轉換成臨時的 String 物件，呼叫方法，然後丟棄臨時的 String 物件。你也可以使用 <code>String.length</code> 屬性︰</p> +<ul> <li>"John's cat".length</li> +</ul> +<p>除非你特別使用 String 物件，否則就應該使用字串的字面表達。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%A0%90%E5%85%88%E5%AE%9A%E7%BE%A9%E7%9A%84%E6%A0%B8%E5%BF%83%E7%89%A9%E4%BB%B6/String_%E7%89%A9%E4%BB%B6" title="zh tw/Core JavaScript 1.5 教學/預先定義的核心物件/String 物件">String 物件</a> 取得有關 String 物件的細節。</p> +<h5 id="在字串中使用特殊字元" name="在字串中使用特殊字元">在字串中使用特殊字元</h5> +<p>除了普通的字元以外，你也可以在字串中包含特殊字元，如下範例︰</p> +<pre class="eval">"one line \n another line" +</pre> +<p>下表列出了你可以使用於 JavaScript 字串中的特殊字元。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>字元</th> <th>意義</th> </tr> <tr> <td>\b</td> <td>後退一格</td> </tr> <tr> <td>\f</td> <td>換頁</td> </tr> <tr> <td>\n</td> <td>換行</td> </tr> <tr> <td>\r</td> <td>歸位</td> </tr> <tr> <td>\t</td> <td>Tab</td> </tr> <tr> <td>\v</td> <td>垂直 Tab</td> </tr> <tr> <td>\'</td> <td>單引號</td> </tr> <tr> <td>\"</td> <td>雙引號</td> </tr> <tr> <td>\\</td> <td>反斜線 (\)。</td> </tr> <tr> <td>\<em>XXX</em></td> <td>使用介於 0 至 377 之間的三個八進制數 <em>XXX</em> 來表示以 Latin-1 編碼的字元。例如，\251 是版權符號的八進制內碼序列。</td> </tr> <tr> <td>\x<em>XX</em></td> <td>使用介於 00 至 FF 之間的兩個十六進制數 <em>XX</em> 來表示以 Latin-1 編碼的字元。例如，\xA9 是版權符號的十六進制內碼序列。</td> </tr> <tr> <td>\u<em>XXXX</em></td> <td>使用四個十六進制數 <em>XXXX</em> 來表示 Unicode 字元。例如，\u00A9 是版權符號的 Unicode 內碼序列。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/Unicode#Unicode_%E7%9A%84%E8%B7%B3%E8%84%AB%E5%BA%8F%E5%88%97" title="zh tw/Core JavaScript 1.5 教學/Unicode#Unicode 的跳脫序列">Unicode 的跳脫序列</a>。</td> </tr> </tbody> +</table> +<p><small><strong>表 2.1: JavaScript 的特殊字元</strong></small></p> +<h5 id="字元的跳脫" name="字元的跳脫">字元的跳脫</h5> +<p>對於未列在表 2.1 的字元，加在前面的反斜線將會被忽略，但是這個作法已被建議廢除，應該要避免。</p> +<p>你可以在字串裡面的引號前面插入反斜線。這就是引號的<em>跳脫</em>。例如︰</p> +<pre class="eval">var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service."; +document.write(quote); +</pre> +<p>結果會是︰</p> +<pre class="eval">He read "The Cremation of Sam McGee" by R.W. Service. +</pre> +<p>要在字串裡包含反斜線，你必須跳脫反斜線字元。例如，要把檔案路徑 <code>c:\temp</code> 代入成字串，方法如下︰</p> +<pre class="eval">var home = "c:\\temp"; +</pre> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:常數", "Core_JavaScript_1.5_教學:Unicode") }}</p> +<p>{{ 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" } ) }}</p> 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..c4f601c524 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_e5a53691c318855e3342ad91feb78f2e/index.html @@ -0,0 +1,30 @@ +--- +title: 常數 +slug: >- + conflicting/Web/JavaScript/Guide/Grammar_and_types_e5a53691c318855e3342ad91feb78f2e +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Constants +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/常數 +--- +<p> </p> +<h3 id="常數" name="常數">常數</h3> +<p>你可以使用 <code><a href="/en/Core_JavaScript_1.5_Reference/Statements/const" title="en/Core_JavaScript_1.5_Reference/Statements/const">const</a></code> 關鍵字建立唯讀的常數。常數識別子的語法和變數識別子的相同︰以字母或底線開頭，可以包含字母、數值、底線字元。</p> +<pre class="eval">const prefix = '212'; +</pre> +<p>在 Script 執行時，常數不可以藉由代入或重新宣告來改變值。</p> +<p>常數的作用域規則和變數一樣，除了 <code>const</code> 關鍵字即使是全域常數也一直是必要的。如果省略了關鍵字，識別子就會被認定為變數。</p> +<p>你不可以在同一個作用域裡，使用和函數或變數的同樣的名稱來宣告常數。例如︰</p> +<pre class="eval">// 這會引起錯誤 +function f() {}; +const f = 5; + +// 這也會引起錯誤 +function f() { + const g = 5; + var g; + + //其他語句 +} +</pre> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:變數", "Core_JavaScript_1.5_教學:字面表達") }}</p> +<p>{{ 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" } ) }}</p> 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..d98470d4ea --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/grammar_and_types_ef6fc79abc28f5eadd6c126341df5e49/index.html @@ -0,0 +1,59 @@ +--- +title: 變數 +slug: >- + conflicting/Web/JavaScript/Guide/Grammar_and_types_ef6fc79abc28f5eadd6c126341df5e49 +translation_of: Web/JavaScript/Guide/Grammar_and_types +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Variables +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/變數 +--- +<p> </p> +<h3 id="變數" name="變數">變數</h3> +<p>你會在你的應用程式中使用變數作為值的名稱。變數的名稱稱為<em>識別子</em>，並遵守以下規則。</p> +<p>JavaScript 識別子必須以字母、底線 (_)、美金符號 ($) 開頭；之後的字元就可以使用數字 (0-9)。因為 JavaScript 區分大小寫，字母包括從“A”到“Z”的字元（大寫）和從“a”到“z”的字元（小寫）。</p> +<p>從 JavaScript 1.5 開始，你可以在識別子中使用 ISO 8859-1 或 Unicode 字母，如 å、ü。你也可以使用表列於 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/Unicode#Unicode_%E8%B7%B3%E8%84%AB%E5%BA%8F%E5%88%97" title="zh tw/Core JavaScript 1.5 教學/Unicode#Unicode 跳脫序列">Unicode 跳脫序列</a> 頁面的 \uXXXX 的 Unicode 跳脫序列作為識別子。</p> +<p>合規則的名稱例子有 <code>Number_hits</code>、<code>temp99</code> 和 <code>_name</code>。</p> +<h4 id="變數的宣告" name="變數的宣告">變數的宣告</h4> +<p>你可以使用兩個方法宣告變數︰</p> +<ul> <li>使用關鍵字 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/var" title="zh tw/Core JavaScript 1.5 參考/語法/var">var</a>。例如，<code>var x = 42</code>。這個語法也可用於宣告 <a class="internal" href="/#%E8%AE%8A%E6%95%B8%E7%9A%84%E4%BD%9C%E7%94%A8%E5%9F%9F" title="#變數的作用域">局域和全域</a> 變數。</li> <li>只需簡單的把值代給他。例如，<code>x = 42</code>。這只能宣告 <a class="internal" href="/#%E5%85%A8%E5%9F%9F%E8%AE%8A%E6%95%B8" title="#全域變數">全域變數</a>，並引起嚴格的 JavaScript 警告。你不應該使用這個方法。</li> +</ul> +<h4 id="變數的求值" name="變數的求值">變數的求值</h4> +<p>使用 <code>var</code> 語法宣告、且沒有初始值的變數，這個變數的值是 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E5%B1%AC%E6%80%A7/undefined" title="zh tw/Core JavaScript 1.5 參考/全域屬性/undefined">undefined</a>。</p> +<p>企圖存取未宣告的變數，將導致 ReferenceError 例外的拋出︰</p> +<pre class="eval">var a; +print("The value of a is " + a); // 輸出 "a 的值是 undefined" +print("The value of b is " + b); // 拋出 ReferenceError 例外 +</pre> +<p>你可以使用 <code>undefined</code> 確認變數是否有值。在下列代碼中，變數 <code>input</code> 尚未代入值，所以 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/if...else" title="zh tw/Core JavaScript 1.5 參考/語法/if...else">if</a></code> 語法求出的是 <code>true</code>。</p> +<pre class="eval">var input; +if(input === undefined){ + doThis(); +} else { + doThat(); +} +</pre> +<p>在用於布林邏輯時，<code>undefined</code> 值會被視為 <code>false</code>。例如，下面的代碼會執行函數 <code>myFunction</code>，因為 <code>myArray</code> 元素尚未定義︰</p> +<pre class="eval">var myArray = new Array(); +if (!myArray[0]) myFunction(); +</pre> +<p>當你對 null 變數求值時，null 值在用於數值時會被視為 0，而在用於布林邏輯時則視為 false。例如︰</p> +<pre class="eval">var n = null; +print(n * 32); // 輸出 0 +</pre><h4 id="變數的作用域" name="變數的作用域">變數的作用域</h4> +<p>當你在任何函數之外宣告變數時，這個變數就稱為<em>全域</em>變數，因為這個變數可以在整份文件中的任何代碼裡使用。當你在函數之內宣告變數時，這個變數就稱為<em>局域</em>變數，因為這個變數只能在函數之內使用。</p> +<p>JavaScript 的 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%8D%80%E5%A1%8A%E8%AA%9E%E6%B3%95#%E5%8D%80%E5%A1%8A%E8%AA%9E%E6%B3%95" title="zh tw/Core JavaScript 1.5 教學/區塊語法#區塊語法">區塊語法</a> 並沒有作用域；在區塊之內的代碼不會是局域的。例如在下面的代碼中，如果 <code>condition</code> 是 <code>false</code>，結果會輸出 <code>0</code>，而不是拋出例外︰</p> +<pre class="eval">if (condition) { + var x = 5; +} +print(x ? x : 0); +</pre> +<p>另一個在 JavaScript 中關於變數的獨特行為是，你可以參考稍後才會宣告的變數，而不會引起例外︰</p> +<pre class="eval">print(x === undefined); // 輸出 "true" +var x = 3; +</pre> +<h4 id="全域變數" name="全域變數">全域變數</h4> +<p>全域變數其實就是<em>全域物件</em>的屬性。在 Web 頁面中，全域物件是 <a class="internal" href="/zh_tw/DOM/window" title="zh tw/DOM/window">window</a>，所以你可以使用 <code>window.<em>variable</em></code> 語法設定並存取全域變數。</p> +<p>因此，你可以從另一個視窗或框架，藉由指定視窗或框架的名稱，來存取宣告在視窗或框架裡的全域變數。例如，如果有一個稱為 <code>phoneNumber</code> 的變數是在 <code>FRAMESET</code> 文件中宣告，你可以從名為 <code>parent.phoneNumber</code> 的子框架參考這個變數。</p> +<h4 id="參閱" name="參閱">參閱</h4> +<p><a href="/en/Sharp_variables_in_JavaScript" title="en/Sharp_variables_in_JavaScript"> JavaScript 的 Sharp 變數</a></p> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:值", "Core_JavaScript_1.5_教學:常數") }}</p> +<p>{{ 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" } ) }}</p> 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..486b4540ff --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/index.html @@ -0,0 +1,453 @@ +--- +title: 陣列的運用 +slug: conflicting/Web/JavaScript/Guide +translation_of: Web/JavaScript/Guide +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Working_with_Arrays +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/陣列的運用 +--- +<p>陣列是值的有序序列。有別於其他的語言，JavaScript 並沒有明確的陣列資料類型。取而代之，提供了 <code>Array</code> 物件，可以直接實體化或使用陣列的字面表達記法。</p> + +<p>Array 物件有以各種方式操作陣列的方法，如合併、反轉、排序。他有一個用來指定陣列長度的屬性。JavaScript 也提供有用的陣列的字面表達語法，用來建立這些物件。</p> + +<h3 id="陣列的建立" name="陣列的建立">陣列的建立</h3> + +<p>陣列可以使用字面表達語法（通常是首選）或使用 Array 的建構子（也可以稱作函數，兩者行為完全相同）來建立︰</p> + +<pre class="eval">var colors = ["Red", "Green", "Blue"]; +var colors = new Array("Red", "Green", "Blue"); +var colors = Array("Red", "Green", "Blue"); +</pre> + +<p>陣列具有 length 屬性，提供來存取陣列的長度。如果你使用上述其中一個例子來初始化陣列，陣列的長度將會是 3︰</p> + +<pre class="eval">print(colors.length); // 3 +</pre> + +<p>在建立陣列的時候，如果你知道你的陣列的預期長度，你可以給 Array 的建構子傳入長度︰</p> + +<pre class="eval">var fiveItems = new Array(5); +</pre> + +<p>明確定義長度並不會影響陣列的實際容量；這樣只會影響新陣列的 <code>length</code> 屬性。（陣列本身並沒有小於指定值的索引的屬性。）構建子的變體極少使用到。</p> + +<p>JavaScript 1.7 引入陣列的簡約式作為建立新陣列的捷徑；<a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E9%99%A3%E5%88%97%E7%9A%84%E9%81%8B%E7%94%A8#%E9%99%A3%E5%88%97%E7%9A%84%E7%B0%A1%E7%B4%84%E5%BC%8F" title="zh tw/Core JavaScript 1.5 教學/陣列的運用#陣列的簡約式">下面</a> 會討論。</p> + +<h3 id="陣列元素的運用" name="陣列元素的運用">陣列元素的運用</h3> + +<p>你可以透過把值代入給陣列元素的方式儲存陣列。下面是我們的範例 <code>colors</code> 陣列更為完整的實例︰</p> + +<pre class="eval">var colors = []; // 空陣列 +print(colors.length); // 0 + +colors[0] = 'Red'; +colors[1] = 'Green'; +colors[2] = 'Blue'; +print(colors.length); // 3 +</pre> + +<p>附加元素至陣列的末端的常見習慣是使用 <code>array.length</code> 作為索引︰</p> + +<pre class="eval">colors[colors.length] = 'Orange'; +</pre> + +<p>可以使用 <code>array.push()</code> 方法達到同樣效果︰</p> + +<pre class="eval">colors.push('Purple'); +</pre> + +<p>陣列的元素使用元素的索引來存取。陣列是以 0 開始索引，因此陣列中的第一個元素是 0︰</p> + +<pre class="eval">var red = colors[0]; +</pre> + +<p>可以使用各式各樣的陣列方法來存取陣列的元素。例如，<code>pop()</code> 方法移除並返回陣列的最後一個元素︰</p> + +<pre class="eval">var lastElement = colors.pop(); /* colors 的最後一個元素也被移除 */ +</pre> + +<h3 id="理解_length" name="理解_length">理解 length</h3> + +<p>以實作的層級來說，JavaScript 的陣列實際上把元素存放成標準的物件屬性，並使用陣列的索引作為屬性的名稱。<code>length</code> 屬性很特別；他永遠會返回比保存在陣列中的最高索引值再高一的值︰</p> + +<pre class="eval">var cats = []; +cats[30] = ['Dusty']; +print(cats.length); // 31 +</pre> + +<p>你也可以把值代入給 <code>length</code> 屬性。寫下小於陣列中已存放的項目的數目，就會截掉其餘的項目；寫下 0 就完全清空陣列︰</p> + +<pre class="eval">var cats = ['Dusty', 'Misty', 'Twiggy']; +print(cats.length); // 3 + +cats.length = 2; +print(cats); // 輸出 "Dusty,Misty" - Twiggy 被移除了 + +cats.length = 0; +print(cats); // 什麼也沒輸出；cats 陣列是空的 +</pre> + +<h3 id="迭代整個陣列" name="迭代整個陣列">迭代整個陣列</h3> + +<p>常見的操作就是迭代所有陣列的值，並以同樣方式處理每一個值。做到這一點的最簡單的方式如下︰</p> + +<pre class="eval">var colors = ['red', 'green', 'blue']; +for (var i = 0; i < colors.length; i++) { + alert(colors[i]); +} +</pre> + +<p>如果你知道陣列中沒有一個元素會在布林的求值結果中為 false - 如果你的陣列只以 DOM 的結點組成，例如，你可以使用更有效率的習慣︰</p> + +<pre class="eval">var divs = document.getElementsByTagName('div'); +for (var i = 0, div; div = divs[i]; i++) { + /* 以同樣方式處理 div */ +} +</pre> + +<p>這樣可以避免檢查陣列長度的開支，並且確保 div 變數被重新指定到每一次循環的使用中項目，以方便加入。</p> + +<p> <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/Array/forEach" title="zh tw/Core JavaScript 1.5 參考/全域物件/Array/forEach"><code>forEach</code></a> 方法是在 JavaScript 1.6 引入的，提供了另一種迭代陣列的方式︰</p> + +<pre class="eval">var colors = ['red', 'green', 'blue']; +colors.forEach(function(color) { + alert(color); +}); +</pre> + +<p>傳給 <code>forEach</code> 的函數會在陣列中的每一個項目中執行一次，並把陣列的項目傳給函數作為參數。</p> + +<h3 id="Array_的方法" name="Array_的方法">Array 的方法</h3> + +<p><code>Array</code> 物件有以下的方法︰</p> + +<ul> + <li><code>concat</code> 合併兩個陣列，並把新的陣列返回。</li> +</ul> + +<pre class="eval">var a1 = [1, 2, 3]; +var a2 = a1.concat(['a', 'b', 'c']); +print(a2); // 1,2,3,a,b,c +</pre> + +<ul> + <li><code>join(deliminator = ",")</code> 把所有的陣列元素合併成字串。</li> +</ul> + +<pre class="eval">var a = ['Wind', 'Rain', 'Fire']; +print(a.join(' - ')); // "Wind - Rain - Fire" +</pre> + +<ul> + <li><code>pop</code> 移除掉陣列的最後一個元素，並把這個元素返回。</li> +</ul> + +<pre class="eval">var a = [1, 2, 3]; +var last = a.pop(); +print(a); // 1,2 +print(last); // 3 +</pre> + +<ul> + <li><code>push</code> 在陣列的末端加入一個以上的元素，並返回新的陣列長度。</li> +</ul> + +<pre class="eval">var a = [1, 2]; +a.push(3); +print(a); // 1,2,3 +</pre> + +<ul> + <li><code>reverse</code> 反轉陣列元素的順序至適當的位置。</li> +</ul> + +<pre class="eval">var a = [1, 2, 3, 4]; +a.reverse(); +print(a); // 4,3,2,1 +</pre> + +<ul> + <li><code>shift</code> 移除並返回陣列的第一個元素。</li> +</ul> + +<pre class="eval">var a = [1, 2, 3]; +var first = a.shift(); +print(a); // 2,3 +print(first); // 警報 1 +</pre> + +<ul> + <li><code>unshift</code> 在陣列的開頭處加入一個以上的元素，並返回新的陣列長度。</li> +</ul> + +<pre class="eval">var a1 = [1, 2, 3]; +a1.unshift(4); +print(a1); // 4,1,2,3 +</pre> + +<ul> + <li><code>slice (start_index, upto_index)</code> 返回陣列的片斷。</li> +</ul> + +<pre class="eval">var a1 = ['a', 'b', 'c', 'd', 'e']; +var a2 = a1.slice(1, 4); +print(a2); // 警報 b,c,d +</pre> + +<ul> + <li><code>splice(index, count_to_remove, addelement1, addelement2, ...)</code> 加入 和/或 移除陣列的元素，在適當的位置修改。</li> +</ul> + +<pre class="eval">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 +</pre> + +<ul> + <li><code>sort</code> 在適當的位置排序陣列的元素。</li> +</ul> + +<pre class="eval">var a = ['Wind', 'Rain', 'Fire']; +a.sort(); +print(a); // Fire,Rain,Wind +</pre> + +<p><code>sort</code> 也可以接受 Callback 函數來決定如何排序陣列的內容。這個函數會對兩個值做比較，並返回下列三個值其中之一︰</p> + +<ul> + <li>如果 a 在排序系統中小於 b，返回 -1（或任意的負數）</li> + <li>如果 a 在排序系統中大於 b，返回 1（或任意的正數）</li> + <li>如果 a 和 b 被認為是相等的，返回 0。</li> +</ul> + +<p>例如，下面的例子會以字串的最後一個字母來排序︰</p> + +<pre class="eval">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 +</pre> + +<h4 id="於_JavaScript_1.6_引入" name="於_JavaScript_1.6_引入">於 JavaScript 1.6 引入</h4> + +<ul> + <li><code>indexOf(searchElement[, fromIndex)</code> 在陣列中搜尋 <code>searchElement</code> 並返回第一個符合項的索引。</li> +</ul> + +<p> </p> + +<pre class="eval"> var a = ['a', 'b', 'a', 'b', 'a']; + alert(a.indexOf('b')); // 警報 1 + // 現在再試一次，從最後的符合項之後的索引開始 + alert(a.indexOf('b', 2)); // 警報 3 + alert(a.indexOf('z')); // 警報 -1，因為找不到 'z' +</pre> + +<p> </p> + +<ul> + <li><code>lastIndexOf(searchElement[, fromIndex)</code> 類似 <code>indexOf</code>，但是最後面開始往回搜尋。</li> +</ul> + +<p> </p> + +<pre class="eval"> var a = ['a', 'b', 'c', 'd', 'a', 'b']; + alert(a.lastIndexOf('b')); // 警報 5 + // 現在再試一次，從最後的符合項之前的索引開始 + alert(a.lastIndexOf('b', 4)); // 警報 1 + alert(a.lastIndexOf('z')); // 警報 -1 +</pre> + +<p> </p> + +<ul> + <li><code>forEach(callback{{ mediawiki.external(', thisObject') }})</code> 在每一個項目上執行 <code>callback</code>。</li> +</ul> + +<p> </p> + +<pre class="eval"> var a = ['a', 'b', 'c']; + a.forEach(alert); // 依序警報每一個項目 +</pre> + +<p> </p> + +<ul> + <li><code>map(callback{{ mediawiki.external(', thisObject') }})</code> 返回在每一個陣列的項目上執行 <code>callback</code> 所返回的值的新陣列。</li> +</ul> + +<p> </p> + +<pre class="eval"> var a1 = ['a', 'b', 'c']; + var a2 = a1.map(function(item) { return item.toUpperCase(); }); + alert(a2); // 警報 A,B,C +</pre> + +<p> </p> + +<ul> + <li><code>filter(callback{{ mediawiki.external(', thisObject') }})</code> 返回內含在 Callback 中返回為 true 的項目的新陣列。</li> +</ul> + +<p> </p> + +<pre class="eval"> var a1 = ['a', 10, 'b', 20, 'c', 30]; + var a2 = a1.filter(function(item) { return typeof item == 'number'; }); + alert(a2); // 警報 10,20,30 +</pre> + +<p> </p> + +<ul> + <li><code>every(callback{{ mediawiki.external(', thisObject') }})</code> 返回 true，如果 <code>callback</code> 在陣列中的每一項上都返回 true。</li> +</ul> + +<p> </p> + +<pre class="eval"> 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 +</pre> + +<p> </p> + +<ul> + <li><code>some(callback{{ mediawiki.external(', thisObject') }})</code> 返回 true，如果 <code>callback</code> 在陣列中至少有一個項目返回為 true。</li> +</ul> + +<p> </p> + +<pre class="eval"> 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 +</pre> + +<p> </p> + +<p>上面接受 Callback 的方法又稱為<em>迭代方法</em>，因為他們會以同樣的方式迭代整個陣列。其中第二個選用性的參數稱為 <code>thisObject</code>。如果有提供的話，<code>thisObject</code> 會變成 Callback 函數的本體內部的 <code>this</code> 關鍵字的值。</p> + +<p>實際上 Callback 函數會以三個參數來呼叫。第一個是使用中項目的值，第二個是他的陣列索引，第三個是陣列本身的參考。JavaScript 函數會忽略任何沒有在參數列表中命名的參數，因此提供只接受單一參數的 Callback 函數也很安全，如 <code>alert</code>。</p> + +<h4 id="於_JavaScript_1.8_引入" name="於_JavaScript_1.8_引入">於 JavaScript 1.8 引入</h4> + +<ul> + <li><code>reduce(callback[, initialValue)</code> 使用 <code>callback(firstValue, secondValue)</code> 把項目的列表合併成單一的值。</li> +</ul> + +<p> </p> + +<pre class="eval"> var a = [10, 20, 30]; + var total = a.reduce(function(first, second) { return first + second; }, 0); + alert(total) // 警報 60 +</pre> + +<p> </p> + +<ul> + <li><code>reduceRight(callback[, initialValue)</code> 類似 <code>reduce</code>，但是從最後一個元素開始。</li> +</ul> + +<p><code>reduce</code> 和 <code>reduceRight</code> 明顯是迭代陣列的方法中最少的。為了把序列降至單一的值，應該把他們用於遞歸合併兩個值的演算法。</p> + +<h3 id="近似陣列的物件的運用" name="近似陣列的物件的運用">近似陣列的物件的運用</h3> + +<p> 某些 JavaScript 物件，如 <code>document.getElementsByTagName</code> 返回的 NodeList，或者在函數本體內部可以利用的 <code>arguments</code> 物件，表面上看來外觀和行為和陣列很類似，但並未共用所有的方法。例如，<code>arguments</code> 物件提供 <code>length</code> 屬性，但並未實作 <code>forEach</code> 方法。</p> + +<p>在 JavaScript 1.6 中引入的通用陣列，為其他類似陣列的物件提供執行 <code>Array</code> 方法的途徑。每一個標準的陣列方法在 <code>Array</code> 物件本身都有相對應的方法；例如︰</p> + +<pre class="eval"> function alertArguments() { + Array.forEach(arguments, function(item) { + alert(item); + }); + } +</pre> + +<p>這些通用方法可以在舊版本的 JavaScript 中，使用由 JavaScript 函數物件所提供的 call 方法，以更冗長的形式模擬。</p> + +<pre class="eval"> Array.prototype.forEach.call(arguments, function(item) { + alert(item); + }); +</pre> + +<p>陣列的通用方法也可以使用在字串上，因為字串提供的對字元循序存取的方式，和陣列的很類似︰</p> + +<pre class="eval"> Array.forEach("a string", function(char) { + alert(char); + }); +</pre> + +<h3 id="二維陣列" name="二維陣列">二維陣列</h3> + +<p>下面的代碼建立二維陣列。</p> + +<pre>var a = []; +for (i = 0; i < 4; i++) { + a[i] = []; + for (j = 0; j < 4; j++) { + a[i][j] = "[" + i + ", " + j + "]"; + } +} +</pre> + +<p>本例以如下的行來建立陣列︰</p> + +<pre>行 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] +</pre> + +<h3 id="陣列的簡約式" name="陣列的簡約式">陣列的簡約式</h3> + +<p>在 JavaScript 1.7 中引入的陣列簡約式（array comprehension），對於以其他內容為基礎來建構新陣列提供了很有用的捷徑。簡約式通常可以用在 <code>map()</code> 和 <code>filter()</code> 呼叫的地方，或是結合這兩者的方式。</p> + +<p>下面的簡約式接收數字的陣列，並建立每一個數字的雙倍的新陣列。</p> + +<pre>var numbers = [1, 2, 3, 4]; +var doubled = [i * 2 for each (i in numbers)]; +alert(doubled); // 警報 2,4,6,8 +</pre> + +<p>這等同於下面的 <code>map()</code> 操作︰</p> + +<pre>var doubled = numbers.map(function(i) { return i * 2; }); +</pre> + +<p>簡約式也可以用於選取符合特定表達式的項目。這是只選取偶數的簡約式︰</p> + +<pre>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 +</pre> + +<p><code>filter()</code> 也可以用於同樣的用途︰</p> + +<pre>var evens = numbers.filter(function(i) { return i % 2 == 0; }); +</pre> + +<p><code>map()</code> 和 <code>filter()</code> 這類型的操作可以合併至單一的陣列簡約式。這是只篩出偶數的簡約式，然後建立內含雙倍數值的新陣列。</p> + +<pre>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 +</pre> + +<p>陣列簡約式的方括號導入了默許的作用域區塊。新的變數（如範例中的 i）會被視為已經使用 <code>let</code> 宣告過了。其意義是不能在簡約式的外部使用這些變數。</p> + +<p>輸入到陣列的簡約式本身並不需要是陣列；也可以使用 <a class="internal" href="/zh_tw/JavaScript_1.7_%E6%96%B0%E9%AE%AE%E4%BA%8B#%E8%BF%AD%E4%BB%A3%E5%99%A8%E5%92%8C%E7%94%A2%E7%94%9F%E5%99%A8" title="zh tw/JavaScript 1.7 新鮮事#迭代器和產生器">迭代器和產生器</a>。</p> + +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:繼承", "Core_JavaScript_1.5_教學:迭代器和產生器") }}</p> + +<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Working_with_Arrays" } ) }}</p> 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..d3d624f8f1 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions/index.html @@ -0,0 +1,60 @@ +--- +title: 正規表達式的運用 +slug: conflicting/Web/JavaScript/Guide/Regular_Expressions +translation_of: Web/JavaScript/Guide/Regular_Expressions +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用 +--- +<ul> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%AD%A3%E8%A6%8F%E8%A1%A8%E9%81%94%E5%BC%8F%E7%9A%84%E9%81%8B%E7%94%A8/%E4%BD%BF%E7%94%A8%E6%A8%99%E8%AA%8C%E7%9A%84%E9%80%B2%E9%9A%8E%E6%90%9C%E5%B0%8B" title="zh tw/Core JavaScript 1.5 教學/正則表達式的運用/使用標誌的進階搜尋">使用標誌的進階搜尋</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%AD%A3%E8%A6%8F%E8%A1%A8%E9%81%94%E5%BC%8F%E7%9A%84%E9%81%8B%E7%94%A8/%E6%8B%AC%E5%BC%A7%E5%AD%90%E5%AD%97%E4%B8%B2%E7%9A%84%E6%AF%94%E5%B0%8D%E7%B5%90%E6%9E%9C%E7%9A%84%E9%81%8B%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學/正則表達式的運用/括弧子字串的比對結果的運用">括弧子字串的比對結果的運用</a></li> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%AD%A3%E8%A6%8F%E8%A1%A8%E9%81%94%E5%BC%8F%E7%9A%84%E9%81%8B%E7%94%A8/%E6%AD%A3%E8%A6%8F%E8%A1%A8%E9%81%94%E5%BC%8F%E7%9A%84%E7%AF%84%E4%BE%8B" title="zh tw/Core JavaScript 1.5 教學/正規表達式的運用/正規表達式的範例">正規表達式的範例</a></li> +</ul> +<h3 id="正則表達式的運用" name="正則表達式的運用">正規表達式的運用</h3> +<p>RegExp 的 <code>test</code> 和 <code>exec</code> 方法，還有 String 的 <code>match</code>、<code>replace</code>、<code>search</code>、<code>split</code> 方法都有使用到正規表達式。這些方法在 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83" title="zh tw/Core JavaScript 1.5 參考">Core JavaScript 參考</a> 中已有詳細說明。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>方法</th> <th>說明</th> </tr> <tr> <td><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/RegExp/exec" title="zh tw/Core JavaScript 1.5 參考/全域物件/RegExp/exec">exec</a></td> <td>RegExp 的方法，在字串中比對以執行搜尋。他會返回搜尋資訊的陣列。</td> </tr> <tr> <td><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/RegExp/test" title="zh tw/Core JavaScript 1.5 參考/全域物件/RegExp/test">test</a></td> <td>RegExp 的方法，在字串中比對以進行測試。他會返回 true 或 false。</td> </tr> <tr> <td><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/String/match" title="zh tw/Core JavaScript 1.5 參考/全域物件/String/match">match</a></td> <td>String 的方法，在字串中比對以執行搜尋。他會返回搜尋資訊的陣列，或在比對不出時返回 null。</td> </tr> <tr> <td><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/String/search" title="zh tw/Core JavaScript 1.5 參考/全域物件/String/search">search</a></td> <td>String 的方法，在字串中比對以進行測試。他會返回符合比對的索引，或在搜尋失敗時返回 -1。</td> </tr> <tr> <td><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/String/replace" title="zh tw/Core JavaScript 1.5 參考/全域物件/String/replace">replace</a></td> <td>String 的方法，在字串中比對以執行搜尋，並以其他子字串取代符合比對的子字串。</td> </tr> <tr> <td><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E5%85%A8%E5%9F%9F%E7%89%A9%E4%BB%B6/String/split" title="zh tw/Core JavaScript 1.5 參考/全域物件/String/split">split</a></td> <td>String 的方法，使用正規表達式或固定的字串，把字串分割為子字串的陣列。</td> </tr> </tbody> +</table> +<p><small><strong>表 4.2: 使用了正規表達式的方法</strong></small></p> +<p>當你想知道是否可以在字串裡找出某個模式，可以使用 <code>test</code> 或 <code>search</code> 方法。要更詳細的資訊（不過執行速度也慢）可以使用 <code>exec</code> 或 <code>match</code> 方法。如果你使用 <code>exec</code> 或 <code>match</code> 並且比對成功，這些方法會返回陣列，並更新相關聯的正規表達式物件包括預先定義的 <code>RegExp</code> 的屬性，如果比對失敗，<code>exec</code> 方法返回 <code>null</code>（可轉換為 false）。</p> +<p>在以下的範例中，Script 使用了 <code>exec</code> 方法來在字串裡尋找符合的字串。</p> +<pre><SCRIPT type="text/javascript"> + myRe = /d(b+)d/g; + myArray = myRe.exec("cdbbdbsbz"); +</SCRIPT> +</pre> +<p>如果你不需要存取正規表達式的屬性，另一個建立 <code>myArray</code> 的方式如下 Script︰</p> +<pre><SCRIPT type="text/javascript"> + myArray = /d(b+)d/g.exec("cdbbdbsbz"); +</SCRIPT> +</pre> +<p>如果你想要從字串來建構正規表達式，還有其他選擇如下 Script︰</p> +<pre><SCRIPT type="text/javascript"> + myRe = new RegExp ("d(b+)d", "g"); + myArray = myRe.exec("cdbbdbsbz"); +</SCRIPT> +</pre> +<p>這些 Script 比對成功並返回陣列，並更新顯示在下表中的屬性。</p> +<table class="fullwidth-table"> <tbody> <tr> <th>物件</th> <th>屬性或索引</th> <th>說明</th> <th>上面的範例</th> </tr> <tr> <td>myArray</td> <td> </td> <td>比對符合的字串和所有已記憶的子字串。</td> <td>{{ mediawiki.external('\"dbbd\", \"bb\"') }}</td> </tr> <tr> <td> </td> <td>index</td> <td>在輸入的字串中比對符合的索引位置。索引從 0 開始。</td> <td>1</td> </tr> <tr> <td> </td> <td>input</td> <td>原始的字串。</td> <td>"cdbbdbsbz"</td> </tr> <tr> <td> </td> <td>{{ mediawiki.external(0) }}</td> <td>最後一次比對符合的字元。</td> <td>"dbbd"</td> </tr> <tr> <td>myRe</td> <td>lastIndex</td> <td>下一個符合項的開始處的索引位置。（這個屬性只在正規表達式使用 g 選項時設定，選項的說明在 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%AD%A3%E8%A6%8F%E8%A1%A8%E9%81%94%E5%BC%8F%E7%9A%84%E9%81%8B%E7%94%A8/%E4%BD%BF%E7%94%A8%E6%A8%99%E8%AA%8C%E7%9A%84%E9%80%B2%E9%9A%8E%E6%90%9C%E5%B0%8B" title="zh tw/Core JavaScript 1.5 教學/正則表達式的運用/使用標誌的進階搜尋">使用標誌的進階搜尋</a>。）</td> <td>5</td> </tr> <tr> <td> </td> <td>source</td> <td>模式的文字。在正規表達式建立時更新，而非執行時。</td> <td>"d(b+)d"</td> </tr> </tbody> +</table> +<p><small><strong>表 4.3: 正規表達式的執行結果。</strong></small></p> +<p>如上第二個範例所示，你可以藉由物件的初始化子使用正規表達式，而無需代入到變數裡。然而，如果你這樣做的話，每一次使用的都會是新的正規表達式。因此，如果你使用這個形式而不代入到變數，之後你就沒辦法存取正規表達式的屬性。舉例來說，假設你有這個 Script︰</p> +<pre><SCRIPT type="text/javascript"> + myRe = /d(b+)d/g; + myArray = myRe.exec("cdbbdbsbz"); + document.writeln("The value of lastIndex is " + myRe.lastIndex); +</SCRIPT> +</pre> +<p>Script 顯示︰</p> +<pre>The value of lastIndex is 5 +</pre> +<p>然而，如果你有這個 Script︰</p> +<pre><SCRIPT type="text/javascript"> + myArray = /d(b+)d/g.exec("cdbbdbsbz"); + document.writeln("The value of lastIndex is " + /d(b+)d/g.lastIndex); +</SCRIPT> +</pre> +<p>他會顯示︰</p> +<pre>The value of lastIndex is 0 +</pre> +<p><code>/d(b+)d/g</code> 在兩個語句中是不同的正規表達式物件，也因此各自對 <code>lastIndex</code> 屬性有著不同的變數。如果你需要存取以物件初始化子所建立的正規表達式的屬性，你應該先把他代入到變數裡。</p> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式模式的編寫", "Core_JavaScript_1.5_教學:正規表達式的運用:括弧子字串的比對結果的運用") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..b8317583d4 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_24eb6498b86da57e7fb5337fd8fa04a6/index.html @@ -0,0 +1,46 @@ +--- +title: 括弧子字串的比對結果的運用 +slug: >- + conflicting/Web/JavaScript/Guide/Regular_Expressions_24eb6498b86da57e7fb5337fd8fa04a6 +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 +original_slug: >- + Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用/括弧子字串的比對結果的運用 +--- +<h4 id="括弧子字串的比對結果的運用" name="括弧子字串的比對結果的運用">括弧子字串的比對結果的運用</h4> +<p>在正規表達式的模式中包含括弧，對應的子比對結果就會被記憶。舉例來說，<code>/a(b)c/</code> 比對字元 'abc' 並把 'b' 記憶起來。若要取回括弧子字串的比對結果，就使用 Array 元素 {{ mediawiki.external(1) }}, ..., {{ mediawiki.external('n') }}。</p> +<p>括弧子字串的可能數目並沒有限制。返回的陣列保留了所有找到的子字串。以下範例解說如何使用括弧子字串的比對結果。</p> +<p><strong>範例 1</strong><br> +以下 Script 使用 <code>replace</code> 方法來置換字串裡的文字。對於那些替換用的文字，Script 使用了 <code>$1</code> 和 <code>$2</code> 來表示第一個和第二個括弧子字串的比對結果。</p> +<pre><script type="text/javascript"> + re = /(\w+)\s(\w+)/; + str = "John Smith"; + newstr = str.replace(re, "$2, $1"); + document.write(newstr); +</script> +</pre> +<p>本例輸出 "Smith, John"。</p> +<p><strong>範例 2</strong><br> +附註: 在 <code>getInfo</code> 函數中，<code>exec</code> 方法是以 () 省略記法所呼叫的，這個記法在 Firefox 可以運作，其他瀏覽器則不一定。</p> +<pre><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> +</pre> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的運用", "Core_JavaScript_1.5_教學:正規表達式的運用:使用標誌的進階搜尋") }}</p> +</div> +<p>{{ 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" } ) }}</p> 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..40723757f7 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/regular_expressions_38b32725e0e3217a5542b1b4ee122407/index.html @@ -0,0 +1,39 @@ +--- +title: 使用標誌的進階搜尋 +slug: >- + conflicting/Web/JavaScript/Guide/Regular_Expressions_38b32725e0e3217a5542b1b4ee122407 +translation_of: Web/JavaScript/Guide/Regular_Expressions +translation_of_original: >- + Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions/Advanced_Searching_With_Flags +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用/使用標誌的進階搜尋 +--- +<h3 id="使用標誌的進階搜尋" name="使用標誌的進階搜尋">使用標誌的進階搜尋</h3> +<p>正規表達式有四個選用的標誌，這些標誌可用於全域或不分大小寫等的搜尋。若要指明為全域搜尋，就使用 <code>g</code> 標誌。若要指明為區分大小寫來搜尋，就使用 <code>i</code> 標誌。若要指明為在多行中搜尋，就使用 <code>m</code> 標誌。若要進行“定點”搜尋，也就是以目標字串的目前位置為開始點來搜尋，那就使用 <code>y</code> 標誌。這些標誌可以單獨或不分順序混合使用，並作為正規表達式的一部分。</p> +<p>{{ Fx_minversion_note(3, "Firefox 3 新增了對 <code>y</code> 標誌的支援。如果在目標字串的目前位置上比對不成功，<code>y</code> 標誌就會失敗。") }}</p> +<p>要在正規表達式中包含標誌，使用以下語法︰</p> +<pre>re = /pattern/flags +re = new RegExp("pattern", ["flags"]) +</pre> +<p>注意，標誌也是正規表達式整體的一部分。之後就不能新增或移除標誌。</p> +<p>舉例來說，<code>re = /\w+\s/g</code> 建立了可尋找 1 個以上的字元並且後接空白的正規表達式，並找出整個字串的組合部分。</p> +<pre><script type="text/javascript"> + re = /\w+\s/g; + str = "fee fi fo fum"; + myArray = str.match(re); + document.write(myArray); +</script> +</pre> +<p>顯示出 {{ mediawiki.external('\"fee \", \"fi \", \"fo \"') }}。在這個範例中，你可以取代一整行︰</p> +<pre>re = /\w+\s/g; +</pre> +<p>改用︰</p> +<pre>re = new RegExp("\\w+\\s", "g"); +</pre> +<p>得到同樣的結果。</p> +<p><code>m</code> 標誌用來指明輸入的多行字串應該視為多行。如果使用 <code>m</code> 標誌，^ 和 $ 就會在輸入字串裡比對每一行的開始處和結尾處，而非整個字串的開始處和結尾處。</p> +<div class="noinclude"> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的運用:括弧子字串的比對結果的運用", "Core_JavaScript_1.5_教學:正規表達式的運用:正規表達式的範例") }}</p> +</div> +<p> </p> +<p> </p> +<p>{{ 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" } ) }}</p> 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..2c71c4d735 --- /dev/null +++ b/files/zh-tw/conflicting/web/javascript/guide/working_with_objects/index.html @@ -0,0 +1,44 @@ +--- +title: 物件和屬性 +slug: conflicting/Web/JavaScript/Guide/Working_with_Objects +translation_of: Web/JavaScript/Guide/Working_with_Objects +translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Objects_and_Properties +original_slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/物件和屬性 +--- +<p> </p> +<h3 id="物件和屬性" name="物件和屬性">物件和屬性</h3> +<p>JavaScript 的物件連結有屬性。你只需要使用簡單的記法就能存取物件的屬性︰</p> +<pre>objectName.propertyName +</pre> +<p>物件的名稱和屬性的名稱兩者都區分大小寫。你可藉由給他代入值來定義屬性。例如，假設有名為 <code>myCar</code> 的物件（假設物件已經存在）。你可以把他的屬性命名為 <code>make</code>、<code>model</code>、<code>year</code> 如下所示︰</p> +<pre>myCar.make = "Ford"; +myCar.model = "Mustang"; +myCar.year = 1969; +</pre> +<p>JavaScript 物件的屬性也可以使用方括號記法來存取或設定。物件有時又稱為<em>關聯陣列</em>，因為每一個屬性都和字串值連繫在一起，且可以用這些字串值來存取屬性。然後，舉例來說，你可以存取 <code>myCar</code> 物件的屬性如下所示︰</p> +<pre>myCar["make"] = "Ford"; +myCar["model"] = "Mustang"; +myCar["year"] = 1969; +</pre> +<p>你也可以使用儲存在變數裡的字串值來存取屬性︰</p> +<pre>var propertyName = "make"; +myCar[propertyName] = "Ford"; + +propertyName = "model"; +myCar[propertyName] = "Mustang"; +</pre> +<p>你也可以使用括弧和 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E7%89%A9%E4%BB%B6%E7%9A%84%E6%93%8D%E4%BD%9C%E8%AA%9E%E6%B3%95#for...in_%E8%AA%9E%E6%B3%95" title="zh tw/Core JavaScript 1.5 教學/物件的操作語法#for...in 語法">for...in</a> 來迭代物件所有的屬性。為解說這是如何運作的，以下函數用來顯示物件的屬性，當你把物件和物件的名稱作為參數傳給這個函數的時候︰</p> +<pre>function show_props(obj, obj_name) { + var result = ""; + for (var i in obj) + result += obj_name + "." + i + " = " + obj[i] + "\n"; + return result; +} +</pre> +<p>然後，呼叫函數 <code>show_props(myCar, "myCar")</code> 就會返回以下內容︰</p> +<pre>myCar.make = Ford +myCar.model = Mustang +myCar.year = 1969 +</pre> +<p>{{ PreviousNext("Core_JavaScript_1.5_教學:閉包的運用", "Core_JavaScript_1.5_教學:建立新的物件") }}</p> +<p>{{ 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" } ) }}</p> |