unslug zh-tw: move

94 files changed, 0 insertions, 7645 deletions

diff --git a/files/zh-tw/web/javascript/introduction_to_object-oriented_javascript/index.html b/files/zh-tw/web/javascript/introduction_to_object-oriented_javascript/index.html
deleted file mode 100644
index 292229d00d..0000000000
--- a/files/zh-tw/web/javascript/introduction_to_object-oriented_javascript/index.html
+++ /dev/null
@@ -1,394 +0,0 @@
----
-title: JavaScript 物件導向介紹
-slug: Web/JavaScript/Introduction_to_Object-Oriented_JavaScript
-tags:
-  - 中階
-  - 命名空間
-  - 封裝
-  - 建構子
-  - 成員
-  - 物件
-  - 物件導向
-  - 物件導向程式設計
-translation_of: Learn/JavaScript/Objects
-translation_of_original: Web/JavaScript/Introduction_to_Object-Oriented_JavaScript
----
-<div>{{jsSidebar("Introductory")}}</div>
-
-<p>深入淺出物件導向，JavaScript 支援強大、彈性的物件導向程式設計 ({{Glossary("OOP")}})。本篇文章會先介紹物件導向程式設計，然後複習 JavaScript 物件模型，最後示範在 JavaScript 物件導向程式設計的概念。本篇文章並不會介紹 <a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Classes">在 ECMAScript 6 的物件導向程式設計</a> 的新語法。</p>
-
-<h2 id="複習_JavaScript">複習 JavaScript</h2>
-
-<p>若您對 JavaScript 變數、型態、函數及作用範圍的觀念並不是很有信心，您可以閱讀 <a href="/zh-TW/docs/Web/JavaScript/A_re-introduction_to_JavaScript">重新膫解 JavaScript</a> 中相關的主題。您也可以參考 <a href="/zh-TW/docs/Web/JavaScript/Guide">JavaScript 指南</a>。</p>
-
-<h2 id="物件導向程式設計">物件導向程式設計</h2>
-
-<p>物件導向程式設計 (Object-oriented programming, OOP) 是一種使用 {{glossary("abstraction")}} 概念表達現實世界的程式設計方式。物件導向程式設計運用數個先前所建立的技術所組成，包含模組化 ({{glossary("modularity")}})、多型 ({{glossary("polymorphism")}}) 以及封裝 ({{glossary("encapsulation")}}) 。直到今天許多主流的程式語言 (如 Java, JavaScript, C#, C++, Python, PHP, Ruby 與 Objective-C) 也都支援物件導向程式設計。</p>
-
-<p>物件導向程式設計是將軟體想像成由一群物件交互合作所組成，而非以往以函數 (Function) 或簡單的指令集交互合作所組成。在物件導向的架構中，每個物件都具有接收訊息，處理資料以及發送訊息給其他物件的能力。每個物件都可視為獨一無二的個體，他們扮演不同的角色並有不同的能力及責任。</p>
-
-<p>物作導向程式設計提出了一個一個更有彈性且易於維護的設計方法，且廣泛被許多大型軟體工程所採用。由於物件導向程式設計強調模組化，因為物件導向的程式碼變的較為容易開發且易於理解。與較少模組化的程式設計技術相比，物件導向的程式碼更能更直接分析、編寫、理解複雜的情況與程序。<a href="#cite-1"><sup>1</sup></a></p>
-
-<p>JavaScript 是一個以雛型為基礎 (Prototype-based) 的程式設計語言 (或更準確的說是以雛型為基礎的腳本語言)，它採用了複製的模式而非繼承。以雛型為基礎的程式設計語言是一種物件導向程式設計，使用了函數來當做類別 (Class) 的建構子 (Constructor)，儘管 JavaScript 擁有類別 (Class) 的關鍵字，但它沒有類別敘述，當要拿 JavaScript 與其他物件導向程式語言相比時，這是很重要的區別。</p>
-
-<h2 id="專門用語">專門用語</h2>
-
-<dl>
- <dt>{{Glossary("Namespace")}}</dt>
- <dd>可讓開發人員包裝所有功能到一個獨一無二、特定應用程式名稱的容器。</dd>
- <dt>{{Glossary("Class")}}</dt>
- <dd>用來定義物件的特徵，類別 (Class) 是物件屬性與方法的藍圖。</dd>
- <dt>{{Glossary("Object")}}</dt>
- <dd>類別 (Class) 的實際案例。</dd>
- <dt>{{Glossary("Property")}}</dt>
- <dd>物件 (Object) 的特徵，例如：顏色。</dd>
- <dt>{{Glossary("Method")}}</dt>
- <dd>物件 (Object) 的功能，例如：行走。它是與類別相關的子程序或函數。</dd>
- <dt>{{Glossary("Constructor")}}</dt>
- <dd>一個在物件產生時會被呼叫的方法。通常會使用與其所在類別 (Class) 相同的名稱。</dd>
- <dt>{{Glossary("Inheritance")}}</dt>
- <dd>一個類別 (Class) 可以繼承另一個類別的特徵與功能。</dd>
- <dt>{{Glossary("Encapsulation")}}</dt>
- <dd>可以將資料與方法包裝在一起使用的技術。</dd>
- <dt>{{Glossary("Abstraction")}}</dt>
- <dd>結合物件的複雜繼承關係、方法與屬性來充分反映現實的模型。</dd>
- <dt>{{Glossary("Polymorphism")}}</dt>
- <dd>Poly 指的是 "多" 而 Morphism 指的是 "<em>型</em>"。是指不同的類別可以定義相同的方法或屬性。</dd>
-</dl>
-
-<p>要了解物件導向程式設計更廣泛的說明，請參考維基百科的  {{interwiki("wikipedia", "Object-oriented programming")}}。</p>
-
-<h2 id="以雛型為基礎_Prototype-based_的程式設計">以雛型為基礎 (Prototype-based) 的程式設計</h2>
-
-<p>以雛型為基礎的程式設計是一種不使用類別的物件導向程式設計模式，但它是第一個透過修改 (或者擴充) 既有的 <em>prototype</em> 來達到類別的功能並可重複使用 (等同在以類別為基礎的程式語言中的繼承)。 又稱作無類別 (Classless)、雛型導向 (Prototype-oriented) 或以實例為基的程式語言 (Instance-based programming)。</p>
-
-<p>最早 (最典型) 以雛型為基礎的程式語言的典範是由 David Ungar 與 Randall Smith 所開發的 {{interwiki("wikipedia", "Self (programming language)", "Self")}}。近年來無類別 (Class-less) 的程式設計風格越來越流行，並且被 JavaScript, Cecil, NewtonScript, Io, MOO, REBOL, Kevo, Squeak (在使用 Viewer 框架來處理 Morphic 元件時)，還有許多其他程式語言所採用。<a href="#cite-2"><sup>2</sup></a></p>
-
-<h2 id="JavaScript_物件導向程式設計">JavaScript 物件導向程式設計</h2>
-
-<h3 id="命名空間">命名空間</h3>
-
-<p>命名空間是一個可讓開發人員包裝所有功能到一個獨一無二、特定應用程式名稱的容器。在<strong> JavaScript 中命名空間其實是另一個包含方法、屬性及物件的物件。</strong></p>
-
-<div class="note">
-<p>注意，在 JavaScript 中一般物件與命名空間並無語法上的差異，這於其他許多物件導向的語言並不相同，可能是初學 JavaScript 的程式設計師容易混淆的地方。</p>
-</div>
-
-<p>在 JavaScript 建立一個命名空間背後的概念非常的簡單：建立一個全域的物件，然後將所有的變數、方法及函數設為該物件的屬性。使用命名空間可以減少應用程式中名稱衝突發生的機率，由於每個應用程式的物件皆會是應用程式定義的全域物件的屬性。</p>
-
-<p>讓我們來建立一個叫做 MYAPP 全域物件：</p>
-
-<pre class="brush: js notranslate">// 全域命名空間
-var MYAPP = MYAPP || {};</pre>
-
-<p>在上述程式範例，我們會先檢查 <code>MYAPP</code> 是否已經定義過 (不論是定義在同一檔案或在其他檔案)。若已定義過，便會使用現有的 MYAPP 全域物件，否則會建一個稱作 <code>MYAPP</code> 的空物件來包裝方法、函數、變數及物件。</p>
-
-<p>我們也可以建立子命名空間 (要注意，全域物件必須已事先定義)：</p>
-
-<pre class="brush: js notranslate">// 子命名空間
-MYAPP.event = {};</pre>
-
-<p>以下的程式碼會建立一個命名空間並加入變數、函數以及一個方法：</p>
-
-<pre class="brush: js notranslate">// 建立一個稱作 MYAPP.commonMethod 的容器來存放常用方法與屬性
-MYAPP.commonMethod = {
-  regExForName: "", // define regex for name validation
-  regExForPhone: "", // define regex for phone no validation
-  validateName: function(name){
-    // Do something with name, you can access regExForName variable
-    // using "this.regExForName"
-  },
-
-  validatePhoneNo: function(phoneNo){
-    // do something with phone number
-  }
-}
-
-// 物件與方法宣告
-MYAPP.event = {
-    addListener: function(el, type, fn) {
-    // code stuff
-    },
-    removeListener: function(el, type, fn) {
-    // code stuff
-    },
-    getEvent: function(e) {
-    // code stuff
-    }
-
-    // 可以加入其他方法與屬性
-}
-
-// 使用 addListener 方法的語法：
-MYAPP.event.addListener("yourel", "type", callback);</pre>
-
-<h3 id="標準內建物件">標準內建物件</h3>
-
-<p> JavaScript 的核心內建了許多物件，例如有 {{jsxref("Math")}}, {{jsxref("Object")}}, {{jsxref("Array")}} 以及 {{jsxref("String")}}。以下範例將示範如何使用 Math 物件中的 <code>random()</code> <code>方法</code>來取得一個隨機的數字。</p>
-
-<pre class="brush: js notranslate">console.log(Math.random());
-</pre>
-
-<div class="note"><strong>注意：</strong>這個例子及之後的例子會假設全域已經有定義名稱為 {{domxref("console.log()")}} 的函數。<code>console.log()</code> 函數並不算是 JavaScript 的一部份，但是有許多瀏覽器會實作這個功能來協助除錯使用。</div>
-
-<p>請參考 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects" title="zh-TW/docs/Web/JavaScript/Reference/Global_Objects">JavaScript 參考: 標準內建物件</a> 來取得在 JavaScript 中所有核心物件的清單。</p>
-
-<p>每個在 JavaScript 中的物件均為物件 <code><a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Object">Object</a></code> <code>的</code>實例 (Instance)，因此會繼承其所有的屬性與方法。</p>
-
-<h3 id="自訂物件">自訂物件</h3>
-
-<h4 id="類別_Class">類別 (Class)</h4>
-
-<p>JavaScript 是以雛形為基礎的程式語言，並沒有像在 C++ 或 Java 中看以到的 <code>class</code> 敘述句，這有時會讓習慣使用有 <code>class</code> 敘述句的程式設計師混淆。JavaScript 使用函數來作為類別 (Class) 的建構子 (Constructor)，要定義一個類別 (Class) 如同定義一個函數 (Function)一樣簡單，以下例子中我們使用空的建構子來定義了一個新的 Person 類別。</p>
-
-<pre class="brush: js notranslate">var Person = function () {};
-</pre>
-
-<h4 id="物件_Object_-_類別的實例_Instance">物件 (Object) - 類別的實例 (Instance)</h4>
-
-<p>要建立物件 <code>obj</code> 的新實例，我們可以使用 <code>new obj</code> 敘述句，並將結果 (型態為 <code>obj</code>) 指派 (Assign) 到一個變數方便之後存取。</p>
-
-<p>在先前範例中我們定義了一個名稱為 <code>Person</code> 的類別 (Class)。在以下的例子我們會建立兩個實例 (<code>person1</code> 與 <code>person2</code>)。</p>
-
-<pre class="brush: js notranslate">var person1 = new Person();
-var person2 = new Person();
-</pre>
-
-<div class="note">
-<p>請參考 {{jsxref("Object.create()")}} 來了解建立未初始化實例的實例化新方法。</p>
-</div>
-
-<h4 id="建構子_Constructor">建構子 (Constructor)</h4>
-
-<p>建構子會在實例化 (Instantiation) 時被呼叫 (建立物件實例被建立時)。建構子是類別的一個方法，在 JavaScript 中會以函數來當做物件的建構子，因此無須明確的定義建構子方法，而每個在類別中宣告的動作均會在實例化時被執行。</p>
-
-<p>建構子會用來設定物件的屬性 (Property) 或是呼叫要準備讓物件可以使用的方法 (Method)。增加類別的方法及定義會使用另一種語法，在本文稍後會說明。</p>
-
-<p>在以下例之中，類別 <code>Person</code> 的建構子在 <code>Person </code>實例化時會記錄下一個訊息。</p>
-
-<pre class="brush: js notranslate">var Person = function () {
-  console.log('instance created');
-};
-
-var person1 = new Person(); // 會記錄 "instance created"
-var person2 = new Person(); // 會記錄 "instance created"
-</pre>
-
-<h4 id="屬性_Property_-_物件的屬性">屬性 (Property) - 物件的屬性</h4>
-
-<p>屬性即為在類別中的變數，每個物件的實例都會有同樣的屬性。屬性會在類別的建構子 (函數) 中設定，所以屬性在每個實例產生時才會產生。</p>
-
-<p>關鍵字 <code>this </code>可以引用目前的物件，讓您使用在該類別中的其他屬性。存取 (讀寫或寫入) 一個在類別之外的屬性可以用語法：<code>InstanceName.Property</code>，如同在 C++, Java 以及其他語言。 (在類別內會使用語法 <code>this.Property</code> 來取得或設定屬性的數值。)</p>
-
-<p>在以下例子中，我們會在實例化時定義 <code>Person</code> 類別的 <code>firstName</code> 屬性：</p>
-
-<pre class="brush: js notranslate">var Person = function (firstName) {
-  this.firstName = firstName;
-  console.log('Person instantiated');
-};
-
-var person1 = new Person('Alice'); // 會記錄 "Person instantiated"
-var person2 = new Person('Bob'); // 會記錄 "Person instantiated"
-
-// 顯示物件的 firstName 屬性
-console.log('person1 is ' + person1.firstName); // 會記錄 "person1 is Alice"
-console.log('person2 is ' + person2.firstName); // 會記錄 "person2 is Bob"
-</pre>
-
-<h4 id="方法_Method">方法 (Method)</h4>
-
-<p>方法即為函數 (也如同函數般定義)，但是依照屬性的邏輯來運作，呼叫一個方法如同存取一個屬性，但您需要在函數名稱後加上 <code>()</code> ，並有可能會有參數。要定義一個方法，只需將函數指定 (Assign) 給類別的 <code>prototype</code> 屬性中一個已命名的屬性，接著，您便可用剛指定的屬性名稱來呼叫該物件的方法。</p>
-
-<p>以下範例中，我們為 <code>Person</code>  類別定義了方法 <code>sayHello()</code> 並使用。</p>
-
-<pre class="brush: js notranslate">var Person = function (firstName) {
-  this.firstName = firstName;
-};
-
-Person.prototype.sayHello = function() {
-  console.log("Hello, I'm " + this.firstName);
-};
-
-var person1 = new Person("Alice");
-var person2 = new Person("Bob");
-
-// 呼叫 Person sayHello 方法。
-person1.sayHello(); // 會記錄 "Hello, I'm Alice"
-person2.sayHello(); // 會記錄 "Hello, I'm Bob"
-</pre>
-
-<p>在 JavaScript 中，方法其實是一般的函數物件 (Function object) 連結到一個物件的屬性，這意謂著您可以在  "物件之外" 呼叫方法。請看以下範例程式碼：</p>
-
-<pre class="brush: js notranslate">var Person = function (firstName) {
-  this.firstName = firstName;
-};
-
-Person.prototype.sayHello = function() {
-  console.log("Hello, I'm " + this.firstName);
-};
-
-var person1 = new Person("Alice");
-var person2 = new Person("Bob");
-var helloFunction = person1.sayHello;
-
-// 會記錄 "Hello, I'm Alice"
-person1.sayHello();
-
-// 會記錄 "Hello, I'm Bob"
-person2.sayHello();
-
-// 會記錄 "Hello, I'm undefined" (或在 Strict
-// 模式會出現 TypeError)
-helloFunction();
-
-// 會記錄 true
-console.log(helloFunction === person1.sayHello);
-
-// 會記錄 true
-console.log(helloFunction === Person.prototype.sayHello);
-
-// 會記錄 "Hello, I'm Alice"
-helloFunction.call(person1);</pre>
-
-<p>如範例中所示，我們讓所有的參考均指向 <code>sayHello</code> 函數 — 一個在 <code>person1、一個在 Person.prototype、另一個在 helloFunction</code> 變數 — 這些均參考<em>相同的函數</em>。在呼叫的過程中 <code>this</code> 的值會根據我們如何呼叫來決定，最常見的地方是：我們取得函數的物件屬性所在，在表示法中呼叫 <code>this</code> — <code>person1.sayHello()</code>— 會設定 <code>this</code> 為我們取得函數的地方 (<code>person1</code>)，這也是 <code>person1.sayHello() 顯示的名稱為 </code>"Alice" 以及 <code>person2.sayHello() 顯示的</code>名稱為 "Bob" 的原因。但如果我們以其他的方式來呼叫，那麼 <code>this</code> 結果將截然不同：在變數中呼叫 <code>this</code> — <code>helloFunction()</code>— 會設定 <code>this</code> 為所在的全域物件 (在瀏覽器即為 <code>window</code>)。由於物件 (可能) 並沒有 <code>firstName</code> 屬性，因此會得到 "Hello, I'm undefined" 這樣的結果 (在 Loose 模式才有這樣的結果，若在 <a href="/zh-TW/docs/Web/JavaScript/Reference/Strict_mode" title="/en/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">strict mode</a> 則會不同 [會出現錯誤]，為了避免混淆，此處將不會再詳述)。 或者我們可以像最後一個例子使用 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Function/call">call</a> (或 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Function/apply">apply</a>) 來明確的設定 <code>this。</code></p>
-
-<div class="note"><strong>注意：</strong>請參考 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Function/call" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/call">call</a> 及 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Function/apply" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/apply">apply</a> 來取得更多有關 <code>this</code> 的資訊</div>
-
-<h4 id="繼承">繼承</h4>
-
-<p>繼承是一種用一個或多個類別建立一個特殊版本類別的方式 (<em>JavaScript 僅支援單一繼承</em>)。這個特殊的類別通常稱做<em>子類別</em>，而其引用的類別則通常稱作<em>父類別</em>。在 JavaScript 您可以指定父類別的實例到子類別來做到這件事。在最近的瀏覽器中您也可以使用 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create" title="/zh-TW/docs/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create">Object.create</a> 來實作繼承。</p>
-
-<div class="note">
-<p><strong>注意：</strong>JavaScript 不會偵測子類別的 <code>prototype.constructor</code> (請參考 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype">Object.prototype</a>)，所以我們必須手動處理。請參考在 Stackoverflow 的問題 "<a href="https://stackoverflow.com/questions/8453887/why-is-it-necessary-to-set-the-prototype-constructor">為什麼一定要設定 prototype 的建構子?</a>"。</p>
-</div>
-
-<p>於以下範例，我們會定義類別 <code>Student</code> 做為 <code>Person</code> 的子類別。然後我們會重新定義 <code>sayHello()</code> 方法然後加入 <code>sayGoodBye()</code> 方法。</p>
-
-<pre class="brush: js notranslate">// 定義 Person 建構子
-var Person = function(firstName) {
-  this.firstName = firstName;
-};
-
-// 加入兩個方法到 Person.prototype
-Person.prototype.walk = function(){
-  console.log("I am walking!");
-};
-
-Person.prototype.sayHello = function(){
-  console.log("Hello, I'm " + this.firstName);
-};
-
-// 定義 Student 建構子
-function Student(firstName, subject) {
-  // Call the parent constructor, making sure (using call)
-  // that "this" is set correctly during the call
-  Person.call(this, firstName);
-
-  // Initialize our Student-specific properties
-  this.subject = subject;
-}
-
-// 建立 Student.prototype 物件來繼承 Person.prototype。
-// 注意: 在此處經常見的錯誤是使用 "new Person()" 來建立
-// Student.prototype。不正確的原因許多個，尤其是
-// 我們沒有給予 Person 任何 "firstName" 的參數。
-// 呼叫 Person 的正確位置在上方，也就是我們呼叫 Student
-// 的地方。
-Student.prototype = Object.create(Person.prototype); // 詳見以下說明
-
-// 設定 "constructor" 屬性參考 Student
-Student.prototype.constructor = Student;
-
-// 替換 "sayHello" 方法
-Student.prototype.sayHello = function(){
-  console.log("Hello, I'm " + this.firstName + ". I'm studying "
-              + this.subject + ".");
-};
-
-// 加入"sayGoodBye" 方法
-Student.prototype.sayGoodBye = function(){
-  console.log("Goodbye!");
-};
-
-// 範例用法:
-var student1 = new Student("Janet", "Applied Physics");
-student1.sayHello();   // "Hello, I'm Janet. I'm studying Applied Physics."
-student1.walk();       // "I am walking!"
-student1.sayGoodBye(); // "Goodbye!"
-
-// 檢查 instanceof 可正常運作
-console.log(student1 instanceof Person);  // true
-console.log(student1 instanceof Student); // true
-</pre>
-
-<p>於 <code>Student.prototype = Object.create(Person.prototype);</code> 一行：在舊版的 JavaScript 引擎沒有 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Object/create" title="Object.create"><code>Object.create</code></a>，可以使用 "polyfill" (又稱 "shim"，請參考以下文章連結) 或使用函數來達到同樣的效果，如：</p>
-
-<pre class="brush: js notranslate">function createObject(proto) {
-    function ctor() { }
-    ctor.prototype = proto;
-    return new ctor();
-}
-
-// 用法:
-Student.prototype = createObject(Person.prototype);
-</pre>
-
-<div class="note"><strong>注意：</strong> 請參考 <a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Object/create" title="Object.create">Object.create</a> 來了解其功能與舊引擎使用的 shim。</div>
-
-<p>要在不管物件如何實例化的情況下確保 <code>this</code> 指向正確的地方並不簡單，儘管如此，這裡仍有一個簡單的習慣用法讓這件事變的較簡單。</p>
-
-<pre class="brush: js notranslate">var Person = function(firstName) {
-  if (this instanceof Person) {
-    this.firstName = firstName;
-  } else {
-    return new Person(firstName);
-  }
-}
-</pre>
-
-<h4 id="封裝">封裝</h4>
-
-<p>於上述例子中 <code>Student</code> 並不需要知道 <code>Person</code> 類別的 <code>walk()</code> 方法實作的方式，但仍可以使用該方法，除非我們想要更改該函數，否則 <code>Student</code> 類別並不需要明確的定義該函數。這樣的概念稱就叫作<strong>封裝 (Encapsulation)</strong>，透過將每個類別的資料與方法包裝成一個單位。</p>
-
-<p>隱藏資訊在其他語言是常見的功能，通當會使用私有 (Private) 與保護 (Protected) 方法/屬性。既使如此，您仍可在 JavaScript 模擬類似的操作，這並不是物件導向程式設計必要的功能。<a href="#cite-3"><sup>3</sup></a></p>
-
-<h4 id="抽象化">抽象化</h4>
-
-<p>抽象化是一個機制能讓您將工作問題的目前部份進行建立模型，不論是用繼承 (特殊化) 或是組合的方式。JavaScript 可以透過繼承達到特殊化 (Specialization)，並可讓類別實例成為其他物件的屬性來達到組合 (Composition)。</p>
-
-<p>JavaScript 的 Function 類別繼承 Object 類別 (這示範了模型的特殊化) 而 {{jsxref("Function.prototype")}} 屬性是 {{jsxref("Object")}} 的實例 (這示範了組合)。</p>
-
-<pre class="brush: js notranslate">var foo = function () {};
-
-// 會記錄 "foo is a Function: true"
-console.log('foo is a Function: ' + (foo instanceof Function));
-
-// 會記錄 "foo.prototype is an Object: true"
-console.log('foo.prototype is an Object: ' + (foo.prototype instanceof Object));</pre>
-
-<h4 id="Polymorphism" name="Polymorphism">多型</h4>
-
-<p>如同所有方法與屬性會定義在 prototype 之中，不同的類別可以定義相同名稱的方法，而這些方法的有效範圍其所在的類別之中，除非兩個類別之間有父子關係 (例如，其中一個類別是繼承另一個類別而來)。</p>
-
-<h2 id="注意">注意</h2>
-
-<p>在 JavaScript 並不是只有這些方式可以實作物件導向程式設計，JavaScript 在這方面非常有彈性。另外，在此處示範的方法並沒有使用任何語言特殊技巧，也沒有模仿其他語言的物件理論來實作。</p>
-
-<p>在 JavaScript 也有其他的方式可以做更進階的物件導向程式設計，但已超出本篇簡介的範圍。</p>
-
-<h2 id="參考文獻">參考文獻</h2>
-
-<ol>
- <li><a href="https://en.wikipedia.org/wiki/Object-oriented_programming" id="cite-1">Wikipedia - Object-oriented programming</a></li>
- <li><a href="https://en.wikipedia.org/wiki/Prototype-based_programming" id="cite-2">Wikipedia - Prototype-based programming</a></li>
- <li><a href="http://en.wikipedia.org/wiki/Encapsulation_%28object-oriented_programming%29" id="cite-3">Wikipedia - Encapsulation (object-oriented programming)</a></li>
-</ol>
-
-<h2 id="相關資料">相關資料</h2>
-
-<ul>
- <li>{{jsxref("Function.prototype.call()")}}</li>
- <li>{{jsxref("Function.prototype.apply()")}}</li>
- <li>{{jsxref("Object.create()")}}</li>
- <li><a href="/zh-TW/docs/Web/JavaScript/Reference/Strict_mode">嚴謹模式 (Strict mode)</a></li>
-</ul>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/javascript_概要/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/javascript_概要/index.html
deleted file mode 100644
index 9c74f992c9..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/javascript_概要/index.html
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: JavaScript 概要
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/JavaScript_概要
----
-<p> </p>
-<h3 id="什麼是_JavaScript？" name="什麼是_JavaScript？">什麼是 JavaScript？</h3>
-<p>JavaScript 是跨平台、物件導向的 Script 語言。JavaScript 是小巧、輕量的語言，以單獨的語言來看 JavaScript 並不是很有用，不過 JavaScript 被設計成易於嵌入至其他產品和應用程式（如 Web 瀏覽器）。在宿主環境裡，JavaScript 可連接至由環境提供的可操控的物件。</p>
-<p>核心 JavaScript 包含 <code>Array</code>、<code>Date</code>、<code>Math</code> 等等的物件核心組件，以及運算子、控制結構、語法等等的語言元素的核心組件。核心 JavaScript 可藉由追加額外的物件而為各種用途來做擴充，例如︰</p>
-<ul> <li><em>客戶端 JavaScript</em> 藉由追加的物件擴充核心語言，以操控瀏覽器（Navigator 或其他 Web 瀏覽器）及其 Document Object Model (DOM)。例如，客戶端的擴充可讓應用程式在 HTML 表單上放置一些元素，並回應滑鼠點擊、表單輸入、頁面瀏覽等的使用者事件。</li> <li><em>伺服端 JavaScript</em> 藉由追加與執行在伺服器上的 JavaScript 有關的物件來擴充核心語言。例如，伺服端的擴充可讓應用程式與相關的資料庫通訊、提供從應用程式的一端發出至另一端的資訊的連續性、在伺服器上進行檔案管理。</li>
-</ul>
-<p>藉由 JavaScript 的 LiveConnect 的機能，還可讓 Java 和 JavaScript 的代碼互相通訊。你可以從 JavaScript 生成 Java 物件，並存取他們的公開方法和欄位。也可以從 Java 存取 JavaScript 的物件、屬性、方法。</p>
-<p>Netscape 發明 JavaScript，且 JavaScript 是初次用於 Netscape 瀏覽器。</p>
-<h3 id="JavaScript_和_Java" name="JavaScript_和_Java">JavaScript 和 Java</h3>
-<p>JavaScript 和 Java 在某些方面類似，但在很多方面完全不同。JavaScript 語言很像 Java，但沒有 Java 的靜態類型和強固的類型檢查。JavaScript 支援 Java 的表達結構和基本的流程控制結構。</p>
-<p>相對於 Java 藉由宣告來建構類別的編譯時期系統，JavaScript 支援的執行時期系統，是建立在表示為數值、布林、字串值的少數幾個資料類型。JavaScript 使用以原型為基礎的物件模型，以代替更常見的以類別為基礎的物件模型。以原型為基礎的模型可提供動態繼承，也就是可對個別的物件變更繼承。JavaScript 亦支援無須特別宣告的函數。函數可以是物件的屬性，以寬鬆的類型執行方法。</p>
-<p>JavaScript 與 Java 相比，是一種在形式上要自由很多的語言。你不必宣告所有的變數、類別或方法。你不必關心方法是不是公開、私有或保護，你也不必實作界面。變數、參數和函數返回的類型都不是明確的類型。</p>
-<p>Java 是為了快速執行和類型的安全性而設計的一種以類別為基礎的程式語言。類型的安全性的意義，舉例來說，你不能把 Java 的整數類型強制轉換為物件類型，或有意的誤用 Java 的位元碼來存取私有記憶體。Java 的以類別為基礎的模型的意義是程式完全以類別及其方法所組成。Java 的類別階層和強固的類型通常需要緊密結合的物件階層。這些要求使 Java 的程式設計比 JavaScript 編寫要複雜的多。</p>
-<p>相較之下，JavaScript 繼承了像 HyperTalk、dBASE 那樣的小型動態類型語言的精髓。這些 Script 語言提供工具給更廣大的使用者，因為他們的語法簡單、特殊的內建函數、對物件的建立的要求較少。</p>
-<table class="fullwidth-table"> <tbody> <tr> <th>JavaScript</th> <th>Java</th> </tr> <tr> <td>物件導向。物件的類型之間沒有區別。繼承是透過原型機制達成，屬性和方法可動態的加入至任何物件。</td> <td>以類別為基礎。物件可細分為類別和實體，所有的繼承是透過類別階層達成。類別和實體不可動態的加入屬性或方法。</td> </tr> <tr> <td>不必宣告變數的資料類型（動態類型）。</td> <td>必須宣告變數的資料類型（靜態類型）。</td> </tr> <tr> <td>不可自動的寫入硬碟。</td> <td>不可自動的寫入硬碟。</td> </tr> </tbody>
-</table>
-<p><small><strong>表 1.1: JavaScript 和 Java 的比較</strong></small><br>
-<br>
-JavaScript 和 Java 之間的不同的更進一步資訊，參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8#%E7%89%A9%E4%BB%B6%E6%A8%A1%E5%9E%8B%E7%9A%84%E7%B4%B0%E7%AF%80" title="zh tw/Core JavaScript 1.5 教學#物件模型的細節">物件模型的細節</a> 章節。</p>
-<h3 id="JavaScript_和_ECMAScript_規範" name="JavaScript_和_ECMAScript_規範">JavaScript 和 ECMAScript 規範</h3>
-<p>Netscape 發明 JavaScript，且 JavaScript 最先使用於 Netscape 瀏覽器。然而，Netscape 與 <a class="external" href="http://www.ecma-international.org/">Ecma International</a> - 把資訊和通訊系統標準化的歐洲協會（以前稱為 ECMA - European Computer Manufacturers Association；歐洲電腦製造商協會）合作發表一份以核心 JavaScript 為基礎的國際程式語言的標準化。JavaScript 的標準化版本，稱為ECMAScript，使所有支援標準的應用程式都能有同樣的行為。企業可以使用這份開放的語言標準開發他們的 JavaScript 實作產品。ECMAScript 標準的文件在 ECMA-262 規範中。</p>
-<p>ECMA-262 標準也受到 <a class="external" href="http://www.iso.ch/">ISO</a>（International Organization for Standardization；國際標準化組織）認可成為 ISO-16262。你可以在 Mozilla 網站上找到 <a class="external" href="http://www.mozilla.org/js/language/E262-3.pdf">ECMA-262 的 PDF 版本</a>。你也可以在 <a class="external" href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">Ecma International 網站</a> 上找到這份標準。ECMAScript 標準並未提到 Document Object Model (DOM)，DOM 是由 <a class="external" href="http://www.w3.org/">World Wide Web Consortium (W3C)</a> 所標準化。DOM 定義了在 Script 中處理 HTML 文件裡的物件的方法。</p>
-<h4 id="JavaScript_版本和_ECMAScript_修定版之間的關係" name="JavaScript_版本和_ECMAScript_修定版之間的關係">JavaScript 版本和 ECMAScript 修定版之間的關係</h4>
-<p>Netscape 與 Ecma International 緊密合作產生 ECMAScript 規範 (ECMA-262)。下表說明了 JavaScript 版本和 ECMAScript 版本間的關係。</p>
-<table class="fullwidth-table"> <tbody> <tr> <th>JavaScript 的版本</th> <th>與 ECMAScript 修定版之間的關係</th> </tr> <tr> <td>JavaScript 1.1</td> <td>ECMA-262 第一版是以 JavaScript 1.1 為基礎。</td> </tr> <tr> <td>JavaScript 1.2</td> <td>在 JavaScript 1.2 釋出時，ECMA-262 尚未完成。JavaScript 1.2 因為以下原因而不完全相容於 ECMA-262 第一版︰ <ul> <li>Netscape 在 JavaScript 1.2 中開發了未考慮到 ECMA-262 的額外機能。</li> <li>ECMA-262 加入兩個新的機能︰使用 Unicode 來國際化，統一所有平台的行為。JavaScript 1.2 的若干機能，如 Date 物件，依賴於平台，且使用平台規範的行為。</li> </ul> </td> </tr> <tr> <td> <p>JavaScript 1.3</p> </td> <td> <p>JavaScript 1.3 完全相容於 ECMA-262 第一版。</p> <p>JavaScript 1.3 解決了 JavaScript 1.2 和 ECMA-262 的不一致，除了 == 和 != 以外，保留 JavaScript 1.2 所有的額外機能，以符合 ECMA-262。</p> </td> </tr> <tr> <td> <p>JavaScript 1.4</p> </td> <td> <p>JavaScript 1.4 完全相容於 ECMA-262 第一版。</p> <p>在 JavaScript 1.4 釋出時，ECMAScript 規範的第三版仍尚未完成。</p> </td> </tr> <tr> <td>JavaScript 1.5</td> <td>JavaScript 1.5 完全相容於 ECMA-262 第三版。</td> </tr> </tbody>
-</table>
-<p><small><strong>表 1.2: JavaScript 版本和 ECMAScript 版本</strong></small></p>
-<div class="note"><strong>附註</strong>: ECMA-262 第二版由次要的編修和對第一版規範的錯誤修正所組成。Ecma International 的 TC39 工作群組目前正工作於 ECMAScript 第四版，第四版將會對應下一個  JavaScript 的釋出版 JavaScript 2.0。</div>
-<p><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> 指出哪些語言機能對應於 ECMAScript。</p>
-<p>JavaScript 將會不斷包含尚未成為 ECMAScript 規範的新機能；JavaScript 在提供額外機能時仍會相容於 ECMAScript。</p><h4 id="JavaScript_文件與_ECMAScript_規範" name="JavaScript_文件與_ECMAScript_規範">JavaScript 文件與 ECMAScript 規範</h4>
-<p>ECMAScript 規範是實作 ECMAScript 的必要條件的匯整；如果你想知道 JavaScript 機能 ECMAScript 規範是否支援，規範就會很有用。如果你有意只使用 ECMAScript 支援的機能來編寫 JavaScript 代碼，你會需要檢閱 ECMAScript 規範。</p>
-<p>ECMAScript 文件不是為了幫助 Script 程式員；應該使用 JavaScript 文件取得有關編寫 Script 的資訊。</p>
-<h4 id="JavaScript_和_ECMAScript_術語" name="JavaScript_和_ECMAScript_術語">JavaScript 和 ECMAScript 術語</h4>
-<p>ECMAScript 規範使用的術語和語法對 JavaScript 程式員來說可能會很陌生。儘管在 ECMAScript 裡的語言說明有所不同，語言本身仍然是一樣的。JavaScript 支援所有在 ECMAScript 規範中描述的機能。</p>
-<p>JavaScript 的文件為 JavaScript 程式員適當的描述語言的表面。例如︰</p>
-<ul> <li>在 JavaScript 文件中不會討論全域物件，因為你不能直接使用。你使用的是全域物件的方法和屬性，已在 JavaScript 文件中稱為頂層函數和屬性來描述。</li> <li>在 JavaScript 文件中不會討論到沒有參數（零參數）的 <code>Number</code> 和 <code>String</code> 物件的建構子，因為產生的東西沒什麼用。沒有參數的 <code>Number</code> 建構子返回 +0，沒有參數的 <code>String</code> 建構子返回 ""（空字串）。</li>
-</ul>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:關於", "Core_JavaScript_1.5_教學:值") }}</p>
-<p> </p> <p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/JavaScript_Overview", "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_de_JavaScript", "fr": "fr/Guide_JavaScript_1.5/Aper\u00e7u_de_JavaScript", "ja": "ja/Core_JavaScript_1.5_Guide/JavaScript_Overview", "ko": "ko/Core_JavaScript_1.5_Guide/JavaScript_Overview", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Przegl\u0105d_JavaScriptu", "zh-cn": "cn/Core_JavaScript_1.5_Guide/JavaScript\u603b\u89c8" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/liveconnect_概要/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/liveconnect_概要/index.html
deleted file mode 100644
index 985cfe5989..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/liveconnect_概要/index.html
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: LiveConnect 概要
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/LiveConnect_概要
----
-<p> </p>
-<h2 id="LiveConnect_概要" name="LiveConnect_概要">LiveConnect 概要</h2>
-<p><strong><a class="internal" href="/zh_tw/LiveConnect" title="zh tw/LiveConnect">LiveConnect</a></strong> 是應用程式介面的名稱，可提供 JavaScript 呼叫 Java 類別的方法的能力，反之亦然，也可以使用 Java 既有的基礎反向運用。</p>
-<dl> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/%E5%8C%85%E8%A3%9D%E5%99%A8%E7%9A%84%E9%81%8B%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/包裝器的運用">包裝器的運用</a></dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/JavaScript 向 Java 的通訊">JavaScript 向 Java 的通訊</a></dd> <dd> <dl> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A#Packages_%E7%89%A9%E4%BB%B6" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/JavaScript 向 Java 的通訊#Packages 物件">Packages 物件</a></dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A#Java_%E9%99%A3%E5%88%97%E7%9A%84%E9%81%8B%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/JavaScript 向 Java 的通訊#Java 陣列的運用">Java 陣列的運用</a></dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A#%E5%8C%85%E8%A3%9D%E5%92%8C%E9%A1%9E%E5%88%A5%E7%9A%84%E5%8F%83%E8%80%83" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/JavaScript 向 Java 的通訊#包裝和類別的參考">包裝和類別的參考</a></dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A#char_%E9%A1%9E%E5%9E%8B%E7%9A%84%E5%8F%83%E6%95%B8" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/JavaScript 向 Java 的通訊#char 類型的參數">char 類型的參數</a></dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A#%E5%9C%A8_JavaScript_%E4%B8%AD%E8%99%95%E7%90%86_Java_%E7%9A%84%E4%BE%8B%E5%A4%96" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/JavaScript 向 Java 的通訊#在 JavaScript 中處理 Java 的例外">在 JavaScript 中處理 Java 的例外</a></dd> </dl> </dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/Java_%E5%90%91_JavaScript_%E7%9A%84%E9%80%9A%E8%A8%8A" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/Java 向 JavaScript 的通訊">Java 向 JavaScript 的通訊</a></dd> <dd> <dl> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/Java_%E5%90%91_JavaScript_%E7%9A%84%E9%80%9A%E8%A8%8A/LiveConnect_%E9%A1%9E%E5%88%A5%E7%9A%84%E4%BD%BF%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/Java 向 JavaScript 的通訊/LiveConnect 類別的使用">LiveConnect 類別的使用</a></dd> </dl> </dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/%E8%B3%87%E6%96%99%E9%A1%9E%E5%9E%8B%E7%9A%84%E8%BD%89%E6%8F%9B" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/資料類型的轉換">資料類型的轉換</a></dd> <dd> <dl> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/%E8%B3%87%E6%96%99%E9%A1%9E%E5%9E%8B%E7%9A%84%E8%BD%89%E6%8F%9B/%E5%BE%9E_JavaScript_%E5%88%B0_Java_%E7%9A%84%E8%BD%89%E6%8F%9B" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/資料類型的轉換/從 JavaScript 到 Java 的轉換">從 JavaScript 到 Java 的轉換</a></dd> <dd><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/%E8%B3%87%E6%96%99%E9%A1%9E%E5%9E%8B%E7%9A%84%E8%BD%89%E6%8F%9B/%E5%BE%9E_Java_%E5%88%B0_JavaScript_%E7%9A%84%E8%BD%89%E6%8F%9B" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/資料類型的轉換/從 Java 到 JavaScript 的轉換">從 Java 到 JavaScript 的轉換</a></dd> </dl> </dd>
-</dl>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:再談屬性的繼承:沒有多重繼承", "Core_JavaScript_1.5_教學:LiveConnect_概要:包裝器的運用") }}</p>
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/LiveConnect_Overview", "es": "es/Gu\u00eda_JavaScript_1.5/Concepto_general_de_LiveConnect", "ja": "ja/Core_JavaScript_1.5_Guide/LiveConnect_Overview", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Podgl\u0105d_klas_LiveConnect" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/unicode/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/unicode/index.html
deleted file mode 100644
index 407d484a34..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/unicode/index.html
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Unicode
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/Unicode
-translation_of: Web/JavaScript/Guide/Grammar_and_types
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Unicode
----
-<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>&lt;TAB&gt;</td> </tr> <tr> <td> </td> <td>\u000B</td> <td>Vertical Tab</td> <td>&lt;VT&gt;</td> </tr> <tr> <td> </td> <td>\u000C</td> <td>Form Feed</td> <td>&lt;FF&gt;</td> </tr> <tr> <td> </td> <td>\u0020</td> <td>Space</td> <td>&lt;SP&gt;</td> </tr> <tr> <td>行終止的值</td> <td>\u000A</td> <td>Line Feed</td> <td>&lt;LF&gt;</td> </tr> <tr> <td> </td> <td>\u000D</td> <td>Carriage Return</td> <td>&lt;CR&gt;</td> </tr> <tr> <td>額外的 Unicode 跳脫序列的值</td> <td>\u0008</td> <td>Backspace</td> <td>&lt;BS&gt;</td> </tr> <tr> <td> </td> <td>\u0009</td> <td>Horizontal Tab</td> <td>&lt;HT&gt;</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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/以類別為基礎的語言_vs._以原型為基礎的語言/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/以類別為基礎的語言_vs._以原型為基礎的語言/index.html
deleted file mode 100644
index 45678e3bdb..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/以類別為基礎的語言_vs._以原型為基礎的語言/index.html
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: 以類別為基礎的語言 vs. 以原型為基礎的語言
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/以類別為基礎的語言_vs._以原型為基礎的語言
-translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Class-Based_vs._Prototype-Based_Languages
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/index.html
deleted file mode 100644
index 9f369cbcac..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/index.html
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: 例外處理語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/例外處理語法
----
-<h3 id="例外處理語法" name="例外處理語法">例外處理語法</h3>
-<p>你可以使用 <code>throw</code> 語法來拋出例外，並使用 <code>try...catch</code> 語法來處理例外。</p>
-<p>你也可以使用 <code>try...catch</code> 語法來處理 Java 的例外。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/%E5%BE%9E_JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A#%E5%9C%A8_JavaScript_%E4%B8%AD%E8%99%95%E7%90%86_Java_%E7%9A%84%E4%BE%8B%E5%A4%96" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/從 JavaScript 向 Java 的通訊#在 JavaScript 中處理 Java 的例外">在 JavaScript 中處理 Java 的例外</a> 和 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/LiveConnect_%E6%A6%82%E8%A6%81/%E5%BE%9E_JavaScript_%E5%90%91_Java_%E7%9A%84%E9%80%9A%E8%A8%8A" title="zh tw/Core JavaScript 1.5 教學/LiveConnect 概要/從 JavaScript 向 Java 的通訊">從 JavaScript 向 Java 的通訊</a> 取得資訊。</p>
-<ul>
- <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E4%BE%8B%E5%A4%96%E8%99%95%E7%90%86%E8%AA%9E%E6%B3%95/throw_%E8%AA%9E%E6%B3%95" title="zh tw/Core JavaScript 1.5 教學/例外處理語法/throw 語法">throw 語法</a></li>
- <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E4%BE%8B%E5%A4%96%E8%99%95%E7%90%86%E8%AA%9E%E6%B3%95/try...catch_%E8%AA%9E%E6%B3%95" title="zh tw/Core JavaScript 1.5 教學/例外處理語法/try...catch 語法">try...catch 語法</a></li>
-</ul>
-<h3 id="例外的類型" name="例外的類型">例外的類型</h3>
-<p>在此列出 JavaScript 中所有可以拋出的物件。不過並非所有的可拋出物件都以同樣方式產生。雖然只是非常普通的拋出數字或字串來表示錯誤，只使用其中幾個特別為某些用途而產生的例外的類型，往往會更加有效率︰</p>
-<ul>
- <li>ECMAScript 的例外︰
-  <ul>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/Error" title="zh tw/Core JavaScript 1.5 教學/Error">Error</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/EvalError" title="zh tw/Core JavaScript 1.5 教學/EvalError">EvalError</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/RangeError" title="zh tw/Core JavaScript 1.5 教學/RangeError">RangeError</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/ReferenceError" title="zh tw/Core JavaScript 1.5 教學/ReferenceError">ReferenceError</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/SyntaxError" title="zh tw/Core JavaScript 1.5 教學/SyntaxError">SyntaxError</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/TypeError" title="zh tw/Core JavaScript 1.5 教學/TypeError">TypeError</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/URIError" title="zh tw/Core JavaScript 1.5 教學/URIError">URIError</a></li>
-  </ul>
- </li>
- <li>DOM 的例外︰
-  <ul>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/DOMException" title="zh tw/Core JavaScript 1.5 教學/DOMException">DOMException</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/EventException" title="zh tw/Core JavaScript 1.5 教學/EventException">EventException</a></li>
-   <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/RangeException" title="zh tw/Core JavaScript 1.5 教學/RangeException">RangeException</a></li>
-   <li>... (?)</li>
-  </ul>
- </li>
- <li><a class="internal" href="/zh_tw/nsIXPCException" title="zh tw/nsIXPCException">nsIXPCException</a> (<a class="internal" href="/zh_tw/XPConnect" title="zh tw/XPConnect">XPConnect</a>)</li>
-</ul>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:註解", "Core_JavaScript_1.5_教學:例外處理語法:throw_語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/throw_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/throw_語法/index.html
deleted file mode 100644
index 83230830e6..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/throw_語法/index.html
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: throw 語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/例外處理語法/throw_語法
----
-<h3 id="throw_語法" name="throw_語法">throw 語法</h3>
-<p>使用 <code>throw</code> 語法來拋出例外。當你準備要拋出例外時，指定內含想要拋出的值的表達式︰</p>
-<pre class="eval">throw expression;
-</pre>
-<p>你可以拋出任何的表達式，而不只是特定類型的表達式。以下代碼拋出各式各樣的例外︰</p>
-<pre class="eval">throw "Error2";
-throw 42;
-throw true;
-throw {toString: function() { return "I'm an object!"; } };
-</pre>
-<div class="note">
- <strong>附註:</strong> 當拋出例外時，還可以指定物件。然後可以在 <code>catch</code> 區塊裡參考物件的屬性。以下範例建立 <code>UserException</code> 類型的物件 <code>myUserException</code>，並使用在拋出語法之中。</div>
-<pre class="eval">// 建立類型為 UserException 的物件
-function UserException (message)
-{
-  this.message=message;
-  this.name="UserException";
-}
-
-// 當用來當作字串時（例如，用於錯誤控制台），
-// 就把例外轉換成適當的字串。
-UserException.prototype.toString = function ()
-{
-  return this.name + ': "' + this.message + '"';
-}
-
-// 建立那一種物件類型的實體，並拋出
-throw new UserException("Value too high");
-</pre>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/try...catch_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/try...catch_語法/index.html
deleted file mode 100644
index 2bc150c6fc..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/例外處理語法/try...catch_語法/index.html
+++ /dev/null
@@ -1,162 +0,0 @@
----
-title: try...catch 語法
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/例外處理語法/try...catch_語法
----
-<h3 id="try...catch_語法" name="try...catch_語法">try...catch 語法</h3>
-
-<p><code>try...catch</code> 語法標記出一整塊需要測試的語句，並指定一個以上的回應方法，萬一有例外拋出時，<code>try...catch</code> 語句就會捕捉。</p>
-
-<p><code>try...catch</code> 語法由 <code>try</code> 區塊所組成，其中內含一個以上的語句，和零個以上的 <code>catch</code> 區塊，其中內含語句用來指明當例外在 try 區塊裡拋出時要做些什麼。也就是當你希望 <code>try</code> 區塊成功，但如果他不成功時，你會想要把控制權移交給 <code>catch</code> 區塊。如果任何在 <code>try</code> 區塊內部裡的語句（或者在 <code>try</code> 區塊內部呼叫的函數裡）拋出例外，控制權將立即轉移給 <code>catch</code> 區塊。如果沒有例外從 <code>try</code> 區塊裡拋出，就會跳過 <code>catch</code> 區塊。<code>finally</code> 區塊會在 <code>try</code> 或 <code>catch</code> 區塊執行之後才執行，但會在 <code>try...catch</code> 語法後面的語句之前執行。</p>
-
-<p>以下範例使用 <code>try...catch</code> 語法。本範例呼叫函數，這個函數是用來在陣列裡根據傳給函數的值來查詢月份的名稱。如果傳入的值不符合月份的數字 (1-12)，就會拋出值為 <code>InvalidMonthNo</code> 的例外，而且在 <code>catch</code> 區塊裡的語句會把 <code>monthName</code> 變數設定為 <code>unknown</code>。</p>
-
-<pre class="notranslate">function getMonthName (mo) {
-    mo=mo-1; // 針對陣列索引調整月份的數字 (1=Jan, 12=Dec)
-    var months=new Array("Jan","Feb","Mar","Apr","May","Jun","Jul",
-          "Aug","Sep","Oct","Nov","Dec");
-    if (months[mo] != null) {
-       return months[mo]
-    } else {
-       throw "InvalidMonthNo"
-    }
-}
-
-try {
-// 需要測試的語句
-    monthName=getMonthName(myMonth) // 可拋出例外的函數
-}
-catch (e) {
-    monthName="unknown"
-    logMyErrors(e) // 把例外物件傳給錯誤處理器
-}
-</pre>
-
-<h4 id="catch_區塊" name="catch_區塊">catch 區塊</h4>
-
-<p>你可以使用單一的 <code>catch</code> 區塊來處理所有在 <code>try</code> 區塊裡可能會產生的例外，或者你也可以使用分離的 <code>catch</code> 區塊，每一個皆各自處理特定的例外類型。</p>
-
-<p><strong>單一 catch 區塊</strong><br>
- 使用單一 <code>try...catch</code> 語法的 <code>catch</code> 區塊針對在 <code>try</code> 區塊裡拋出的所有例外來執行錯誤處理的代碼。</p>
-
-<p>單一的 <code>catch</code> 區塊語句如下︰</p>
-
-<pre class="notranslate">catch (catchID) {
-  statements
-}
-</pre>
-
-<p><code>catch</code> 區塊所指定的識別子（前面語句裡的 <code>catchID</code>）持有由 <code>throw</code> 語法所指定的值。你可以使用這個識別子來取得有關於被拋出的例外的資訊。當進入 <code>catch</code> 區塊時，JavaScript 就會建立這個識別子。識別子只能在 <code>catch</code> 區塊的期間內持續作用。<code>catch</code> 區塊執行結束以後，識別子就不再能使用。</p>
-
-<p>舉例來說，以下代碼會拋出例外。當例外出現的時候，控制權就轉移給 <code>catch</code> 區塊。</p>
-
-<pre class="notranslate">try {
-   throw "myException" // 產生例外
-}
-catch (e) {
-// 用來處理任何例外的語句
-   logMyErrors(e) // 把例外物件傳給錯誤處理器
-}
-</pre>
-
-<p><strong>多重 catch 區塊</strong><br>
- 單一的 <code>try</code> 語句可以對應複數個有前提條件的 <code>catch</code> 區塊，每一個皆可處理特定的例外的類型。於是，當指定的的例外被拋出時，就只會進入適當條件的 <code>catch</code> 區塊。你也可以針對所有未指定的例外，使用選用性的對應所有例外的 <code>catch</code> 區塊來作為語法裡最後一個的 catch 區塊。</p>
-
-<p>舉例來說，以下函數呼叫三個其他的函數（已在別處定義了）來檢驗自己的參數。如果檢驗函數判斷出他所要檢驗的元素是無效的話，他就返回 0，導致呼叫者拋出對應的例外。</p>
-
-<pre class="notranslate">function getCustInfo(name, id, email)
-{
-   var n, i, e;
-
-   if (!validate_name(name))
-       throw "InvalidNameException"
-   else
-       n = name;
-       if (!validate_id(id))
-          throw "InvalidIdException"
-       else
-          i = id;
-       if (!validate_email(email))
-          throw "InvalidEmailException"
-       else
-          e = email;
-       cust = (n + " " + i + " " + e);
-       return (cust);
-}
-</pre>
-
-<p>有各種條件的 <code>catch</code> 區塊會把控制權安排給適當的例外處理器。</p>
-
-<pre class="notranslate">try {
-// 可以拋出三個例外的函數
-   getCustInfo("Lee", 1234, "lee@netscape.com")
-}
-
-catch (e if e == "InvalidNameException") {
-// 針對無效的名稱呼叫處理器
-   bad_name_handler(e)
-}
-
-catch (e if e == "InvalidIdException") {
-// 針對無效的 ID 呼叫處理器
-   bad_id_handler(e)
-}
-
-catch (e if e == "InvalidEmailException") {
-// 針對無效的電子郵件位址呼叫處理器
-   bad_email_handler(e)
-}
-
-catch (e){
-// 不知道該做什麼，就記在日誌裡
-   logError(e)
-}
-</pre>
-
-<h4 id="finally_區塊" name="finally_區塊">finally 區塊</h4>
-
-<p><code>finally</code> 區塊內含的語句，會在 try 和 catch 區塊執行以後、並在 <code>try...catch</code> 語法後面的語句之前來執行。無論有沒有被拋出的例外，<code>finally</code> 區塊都會執行。如果有被拋出的例外，即使沒有 catch 區塊來處理這些例外，還是會執行 <code>finally</code> 區塊裡的語句。</p>
-
-<p>當出現例外時，你可以使用 <code>finally</code> 區塊來使你的 Script 優美的停止。舉例來說，你可能需要釋放 Script 所佔用的資源。以下範例開啟了檔案，並執行使用這個檔案（伺服端的 JavaScript 可讓你存取檔案）的語句。如果在開啟檔案時有例外被拋出，<code>finally</code> 區塊會在 Script 停止之前把檔案關閉。</p>
-
-<pre class="notranslate">openMyFile();
-try {
-   writeMyFile(theData); // 這裡有可能拋出錯誤
-}catch(e){
-   handleError(e); // 如果我們得到錯誤，就處理他
-}finally {
-   closeMyFile(); // 永遠會關閉這項資源
-}
-</pre>
-
-<h4 id="try...catch_語法的嵌套" name="try...catch_語法的嵌套">try...catch 語法的嵌套</h4>
-
-<p>你可以嵌套一個以上的 <code>try...catch</code> 語法。如果有一個內部的 <code>try...catch</code> 語法沒有 catch 區塊，圍住這些 <code>try...catch</code> 語法的 catch 區塊就會被用來比對。</p>
-
-<h4 id="Error_物件的用處" name="Error_物件的用處">Error 物件的用處</h4>
-
-<p>根據錯誤的類型，你有可能使用 “name” 和 “message” 屬性來取得更多明確的訊息。“name” 提供錯誤的一般類別（例如，“DOMException” 或 “Error”），“message” 通常提供更為簡練的訊息，如此就能把錯誤物件轉換為字串來取得訊息。</p>
-
-<p>如果你要拋出你自己的例外，以從這些屬性取得好處（例如，如果你的 catch 區塊不區分你自己的例外和系統的例外的話），你可以使用錯誤建構子。例如︰</p>
-
-<pre class="notranslate">function doSomethingErrorProne () {
-   if (ourCodeMakesAMistake()) {
-      throw (new Error('The message'));
-   }
-   else {
-      doSomethingToGetAJavascriptError();
-   }
-}
-....
-try {
-   doSomethingErrorProne();
-}
-catch (e) {
-   alert(e.name);// 警報 'Error'
-   alert(e.message); // 警報 'The message' 或 JavaScript 錯誤訊息
-}
-</pre>
-
-<div class="noinclude">
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:例外處理語法:throw_語法", "Core_JavaScript_1.5_教學:函數的定義") }}</p>
-</div>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/值/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/值/index.html
deleted file mode 100644
index bea630e438..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/值/index.html
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: 值
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/值
-translation_of: Web/JavaScript/Guide/Grammar_and_types
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Values
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/index.html
deleted file mode 100644
index 3bba16f786..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/index.html
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: 再談屬性的繼承
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承
-translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/實體關係的確定/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/實體關係的確定/index.html
deleted file mode 100644
index 451fa3036e..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/實體關係的確定/index.html
+++ /dev/null
@@ -1,46 +0,0 @@
----
-title: 實體關係的確定
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/實體關係的確定
-translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Determining_Instance_Relationships
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/局域值和繼承值/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/局域值和繼承值/index.html
deleted file mode 100644
index e042494b71..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/局域值和繼承值/index.html
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: 局域值和繼承值
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/局域值和繼承值
-translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Local_versus_Inherited_Values
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/建構子中的全域資訊/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/建構子中的全域資訊/index.html
deleted file mode 100644
index cece6b5a66..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/建構子中的全域資訊/index.html
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: 建構子中的全域資訊
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/建構子中的全域資訊
-translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/Global_Information_in_Constructors
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/沒有多重繼承/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/沒有多重繼承/index.html
deleted file mode 100644
index b787de8dd0..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/再談屬性的繼承/沒有多重繼承/index.html
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: 沒有多重繼承
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/再談屬性的繼承/沒有多重繼承
-translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Property_Inheritance_Revisited/No_Multiple_Inheritance
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/函數的呼叫/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/函數的呼叫/index.html
deleted file mode 100644
index 8999a04084..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/函數的呼叫/index.html
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: 函數的呼叫
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/函數的呼叫
-translation_of: Web/JavaScript/Guide/Functions
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Calling_Functions
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/函數的定義/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/函數的定義/index.html
deleted file mode 100644
index f56f796a03..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/函數的定義/index.html
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: 函數的定義
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/函數的定義
----
-<div class="onlyinclude"> <h3 id="函數的定義" name="函數的定義">函數的定義</h3> <p>函數的定義由以下的關鍵字所組成︰</p> <ul> <li>函數的名稱。</li> <li>傳給函數的參數的列表，以小括弧包夾、並以逗號分隔。</li> <li>用來定義函數的 JavaScript 語句，以大括弧包夾 { }。在函數裡的語句裡可含有在應用程式中已定義的其他函數的呼叫。</li> </ul> <h4 id="簡單的範例" name="簡單的範例">簡單的範例</h4> <p>舉例來說，以下代碼定義了一個簡單的函數，名為 square︰</p> <pre class="eval">function square(number) {
-  return number * number;
-}
-</pre> <p>函數 <code>square</code> 接收一個參數，稱為 <code>number</code>。函數由一個語句所組成，指示要求返回函數的參數的平方。<code>return</code> 語句用來指定函數返回的值。</p> <pre class="eval">return number * number
-</pre> <p>原始的參數是<em>以值</em>傳遞給函數。值是傳遞給函數，但是如果函數修改了參數的值，這項改變不會影響到全域或呼叫端函數裡的值。</p> <p>如果你以物件（例如，<a href="/en/JavaScript/Glossary" title="en/JS/Glossary">非原始值</a>，如陣列或使用者定義的物件）作為參數來傳遞，物件的參考會被傳遞給函數。這意味著如果函數修改了物件的屬性，函數之外也看得見這項改變，如以下範例所示︰</p> <pre class="eval">function myFunc(theObject) {
-  theObject.make="Toyota";
-}
-var mycar = {make:"Honda", model:"Accord", year:1998};
-var x=mycar.make;     // 返回 Honda
-myFunc(mycar);
-var y=mycar.make;     // 返回 Toyota（屬性已被函數修改）
-</pre> <p>注意，把新的物件代入給參數，在呼叫端將<em>不會</em>有任何的影響︰</p> <pre class="eval">function myFunc(theObject) {
-  theObject = {make:"Ford", model:"Focus", year:2006};
-}
-var mycar = {make:"Honda", model:"Accord", year:1998};
-var x=mycar.make;     // 返回 Honda
-myFunc(mycar);
-var y=mycar.make;     // 仍然返回 Honda
-</pre> <h4 id="Defining_functions_conditionally" name="Defining_functions_conditionally">有條件的函數的定義</h4> <p>函數可以根據條件來作定義。例如，給以下的函數定義︰</p> <pre class="eval">if (num == 0)
-{
-  function myFunc(theObject) {
-    theObject.make="Toyota"
-  }
-}
-</pre> <p><code>myFunc</code> 函數只會在變數 <code>num</code> 等於 0 時被定義。如果 <code>num</code> 不等於 0，函數就不會被定義，且任何企圖執行這個函數的嘗試都將會失敗。</p> <h4 id="函數的表達式" name="函數的表達式">函數的表達式</h4> <p>函數也可以在表達式裡來作定義。這稱為<strong>函數表達式</strong>。一般這類函數都是<em>無名的</em>，他沒有名稱也沒關係。例如，函數 <code>square</code> 可以定義成︰</p> <pre class="eval">var square = function(number) {return number * number};
-</pre> <p>當要傳遞函數作為參數給另一個函數時，這個作法會很方便。以下範例示範了 map 函數的定義，然後呼叫端使用無名函數作為第一個參數︰</p> <pre class="eval">function map(f,a) {
-  var result=new Array;
-  for (var i = 0; i != a.length; i++)
-    result[i] = f(a[i]);
-  return result;
-}
-</pre> <p>接著呼叫</p> <pre class="eval">map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);
-</pre> <p>返回 {{ mediawiki.external('0, 1, 8, 125, 1000') }}。</p>
-</div>
-<h4 id="參閱" name="參閱">參閱</h4>
-<p>除了如前所述定義函數以外，你也可以定義 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_教學/預先定義的核心物件/函數物件" title="zh tw/Core JavaScript 1.5 教學/預先定義的核心物件/函數物件">函數物件</a>。</p>
-<p>方法就是和物件相關聯的函數。你將會在 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_教學#%E7%89%A9%E4%BB%B6%E7%9A%84%E9%81%8B%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學#物件的運用">第 8 章，「物件的運用」</a> 中學到更多有關於物件和方法。{{ PreviousNext("Core_JavaScript_1.5_教學:例外處理語法:try...catch_語法", "Core_JavaScript_1.5_教學:函數的呼叫") }}</p>
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Defining_Functions", "fr": "fr/Guide_JavaScript_1.5/D\u00e9finition_de_fonctions", "ja": "ja/Core_JavaScript_1.5_Guide/Defining_Functions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Definiowanie_funkcji" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/區塊語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/區塊語法/index.html
deleted file mode 100644
index 24484bb5b3..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/區塊語法/index.html
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: 區塊語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/區塊語法
-translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Block_Statement
----
-<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 &lt; 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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/字面表達/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/字面表達/index.html
deleted file mode 100644
index 0c66b79359..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/字面表達/index.html
+++ /dev/null
@@ -1,118 +0,0 @@
----
-title: 字面表達
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/字面表達
-translation_of: Web/JavaScript/Guide/Grammar_and_types
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Literals
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/常數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/常數/index.html
deleted file mode 100644
index 9eedc7a21a..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/常數/index.html
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: 常數
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/常數
-translation_of: Web/JavaScript/Guide/Grammar_and_types
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Constants
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/建立新的物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/建立新的物件/index.html
deleted file mode 100644
index faadc10f07..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/建立新的物件/index.html
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: 建立新的物件
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/建立新的物件
----
-<p> </p>
-
-<p>This page was auto-generated because a user created a sub-page to this page.</p>
-
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/break_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/break_語法/index.html
deleted file mode 100644
index ea6551a851..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/break_語法/index.html
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: break 語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法/break_語法
----
-<h3 id="break_語法" name="break_語法">break 語法</h3>
-<p>使用 <code>break</code> 語法可以終止 <code>loop、switch、label</code> 語法。</p>
-<ul>
- <li>當你使用不加標籤的 <code>break</code> 時，他會立即終止最內層的 <code>while、do-while、for</code>、<code>switch</code> 的循環，並把控制權轉移給後面的語句。</li>
- <li>當你使用加上標籤的 <code>break</code> 時，他會終止被指定的標籤所標記的語句。</li>
-</ul>
-<p>break 語法如下︰</p>
-<ol>
- <li><code>break;</code></li>
- <li><code>break label;</code></li>
-</ol>
-<p>第一個語句形式會終止最內層的循環或 <code>switch</code>，第二個語句形式會終止指定標籤的語句。</p>
-<p><strong>範例</strong><br>
- 在以下的範例中，反覆操作陣列裡的元素，直到找到某個索引的元素的值等於 <code>theValue</code>︰</p>
-<pre>for (i = 0; i &lt; a.length; i++) {
-   if (a[i] == theValue)
-      break;
-}
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:循環語法:label_語法", "Core_JavaScript_1.5_教學:循環語法:continue_語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/continue_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/continue_語法/index.html
deleted file mode 100644
index 68f757d572..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/continue_語法/index.html
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: continue 語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法/continue_語法
----
-<h3 id="continue_語法" name="continue_語法">continue 語法</h3>
-<p><code>continue</code> 語法可用來重新開始 <code>while、do-while、for、</code><code>label</code> 語法。</p>
-<ul>
- <li>當你使用沒加標籤的 <code>continue</code> 時，他會終止這一次的最內層的 <code>while、do-while</code>、<code>for</code> 語法的反覆過程，並繼續執行下一次的反覆過程。與 <code>break</code> 語法相較之下，<code>continue</code> 不會終止整個循環的執行。在 <code>while</code> 循環中，他會跳回條件處。在 <code>for</code> 循環中，他會跳回遞增表達式。</li>
- <li>當你使用加上標籤的 <code>continue</code> 時，他會跳到以 <code>label</code> 標記的循環語句。</li>
-</ul>
-<p><code>continue</code> 語法如下︰</p>
-<ol>
- <li><code>continue</code></li>
- <li><code>continue label</code></li>
-</ol>
-<p><strong>範例 1</strong><br>
- 以下範例示範加上 <code>continue</code> 語法的 <code>while</code> 循環，<code>continue</code> 語法會在 <code>i</code> 值為 3 時執行。因此，<code>n</code> 的值依序為 1、3、7、12。</p>
-<pre class="eval">i = 0;
-n = 0;
-while (i &lt; 5) {
-   i++;
-   if (i == 3)
-      continue;
-   n += i;
-}
-</pre>
-<p><strong>範例 2</strong><br>
- 已加上標籤的語法 <code>checkiandj</code> 內含已加上標籤的語法 <code>checkj</code>。如果遇到 <code>continue</code>，程式會終止 <code>checkj</code> 這一次的反覆過程，並開始下一次的反覆過程。每當遇到 <code>continue</code>，就會反覆執行 <code>checkj</code> 直到他的條件返回 false 為止。當返回 false 時，<code>checkiandj</code> 語句完成了餘數的計算，且 <code>checkiandj</code> 會反覆執行，直到他的條件返回為 false 為止。當返回 false 時，程式繼續執行 <code>checkiandj</code> 後面的語句。</p>
-<p>如果 <code>continue</code> 有一個 <code>checkiandj</code> 標籤，程式就會從 <code>checkiandj</code> 語句的開始處繼續執行。</p>
-<pre>checkiandj :
-   while (i &lt; 4) {
-      document.write(i + "&lt;br/&gt;");
-      i += 1;
-      checkj :
-         while (j &gt; 4) {
-            document.write(j + "&lt;br/&gt;");
-            j -= 1;
-            if ((j % 2) == 0)
-               continue checkj;
-            document.write(j + " is odd.&lt;br/&gt;");
-         }
-      document.write("i = " + i + "&lt;br/&gt;");
-      document.write("j = " + j + "&lt;br/&gt;");
-   }
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:循環語法:break_語法", "Core_JavaScript_1.5_教學:物件的操作語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/do...while_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/do...while_語法/index.html
deleted file mode 100644
index 5091d476fd..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/do...while_語法/index.html
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: do...while 語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法/do...while_語法
----
-<h3 id="do...while_語法" name="do...while_語法">do...while 語法</h3>
-<p><code>do...while</code> 語法會反覆執行直到指定條件的求值結果為 false 為止。<code>do...while</code> 語法如下︰</p>
-<pre class="eval">do
-   statement
-while (condition);
-</pre>
-<p><code>statement</code> 會在檢測條件之前就先執行一次。若要執行多個語句，就使用區塊語法（<code>{ ... }</code>）把語句群組化。如果 <code>condition</code> 為 true，就會再執行一次語句。每回執行以後，就會檢測條件。當條件為 false 時，就停止執行並把控制權轉移給 <code>do...while</code> 後面的語句。</p>
-<p><strong>範例</strong><br>
- 在以下範例中，do 循環至少會反覆執行一次，並一直反覆到 i 不再小於 5 為止。</p>
-<pre class="eval">do {
-   i += 1;
-   document.write(i);
-} while (i &lt; 5);
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:循環語法:for_語法", "Core_JavaScript_1.5_教學:循環語法:while_語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/for_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/for_語法/index.html
deleted file mode 100644
index 8978b7ed27..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/for_語法/index.html
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: for 語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法/for_語法
----
-<h3 id="for_語法" name="for_語法">for 語法</h3>
-<p><code>for</code> 循環反覆執行直到指定的條件的求值為 false 為止。JavaScript 的 for 循環和 Java 和 C 的 for 循環很類似。<code>for</code> 語法如下︰</p>
-<pre class="eval">for ([initialExpression]; [condition]; [incrementExpression])
-   statement
-</pre>
-<p>執行 <code>for</code> 循環時，會執行以下步驟︰</p>
-<ol>
- <li>執行初始化表達式 <code>initialExpression</code>。這個表達式通常會初始化為 1 以上的計數器，不過也可以是任意複雜程度的表達式。也可以在表達式裡宣告變數。</li>
- <li>對 <code>condition</code> 表達式求值。如果 <code>condition</code> 的值為 true，就會執行循環語法。如果 <code>condition</code> 的值為 false，就終止 <code>for</code> 循環。如果完全省略 <code>condition</code> 表達式，條件就會被代入為 true。</li>
- <li>執行 <code>statement</code>。若要執行多個語句，就使用區塊語法（<code>{ ... }</code>）把這些語句群組化。</li>
- <li>執行更新表達式 <code>incrementExpression</code>，並回到第 2 步驟。</li>
-</ol>
-<p><strong>範例</strong><br>
- 以下函數內含 <code>for</code> 語法，計數至下拉式選單的已選擇選項的數目為止（Select 物件允許複選）。<code>for</code> 語法宣告變數 <code>i</code> 並以 0 初始化。他會檢驗 <code>i</code> 是否小於 <code>Select</code> 物件的選項數目，持續執行 <code>if</code> 語句，並在每一次循環之後以 1 遞增 <code>i</code>。</p>
-<pre>&lt;script type="text/javascript"&gt;//&lt;![CDATA[
-
-function howMany(selectObject) {
-   var numberSelected = 0;
-   for (var i = 0; i &lt; selectObject.options.length; i++) {
-      if (selectObject.options[i].selected)
-         numberSelected++;
-   }
-   return numberSelected;
-}
-
-//]]&gt;&lt;/script&gt;
-&lt;form name="selectForm"&gt;
-   &lt;p&gt;
-      &lt;strong&gt;Choose some music types, then click the button below:&lt;/strong&gt;
-      &lt;br/&gt;
-      &lt;select name="musicTypes" multiple="multiple"&gt;
-         &lt;option selected="selected"&gt;R&amp;B&lt;/option&gt;
-         &lt;option&gt;Jazz&lt;/option&gt;
-         &lt;option&gt;Blues&lt;/option&gt;
-         &lt;option&gt;New Age&lt;/option&gt;
-         &lt;option&gt;Classical&lt;/option&gt;
-         &lt;option&gt;Opera&lt;/option&gt;
-      &lt;/select&gt;
-   &lt;/p&gt;
-   &lt;p&gt;
-      &lt;input type="button" value="How many are selected?"
-         onclick="alert ('Number of options selected: ' + howMany(document.selectForm.musicTypes))"/&gt;
-   &lt;/p&gt;
-&lt;/form&gt;
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:循環語法", "Core_JavaScript_1.5_教學:循環語法:do...while_語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/index.html
deleted file mode 100644
index af67cbfa03..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/index.html
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: 循環語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法
-translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Loop_Statements
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/label_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/label_語法/index.html
deleted file mode 100644
index 8b63254ac1..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/label_語法/index.html
+++ /dev/null
@@ -1,22 +0,0 @@
----
-title: label 語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法/label_語法
----
-<h3 id="label_語法" name="label_語法">label 語法</h3>
-<p><code>label</code> 提供識別子作為語法，可讓你的程式的任何一處都能參考得到。舉例來說，你可以使用標籤來標識循環，然後使用 <code>break</code> 或 <code>continue</code> 語法來指示程式是否要中斷循環或繼續執行。</p>
-<p><code>label</code> 語法如下︰</p>
-<pre>label :
-   statement
-</pre>
-<p><code>label</code> 的值可以是任意的 JavaScript 識別子，只要不是保留字的話都可以使用。使用標籤來標識的 <code>statement</code> 可以是任意的語句。</p>
-<p><strong>範例</strong><br>
- 在以下範例中，標籤 <code>markLoop</code> 標識了 while 循環。</p>
-<pre>markLoop:
-while (theMark == true)
-   doSomething();
-}
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:循環語法:while_語法", "Core_JavaScript_1.5_教學:循環語法:break_語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/while_語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/while_語法/index.html
deleted file mode 100644
index 76beeaafeb..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/循環語法/while_語法/index.html
+++ /dev/null
@@ -1,38 +0,0 @@
----
-title: while 語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/循環語法/while_語法
----
-<h3 id="while_語法" name="while_語法">while 語法</h3>
-<p><code>while</code> 語法會執行他的語句，只要指定的條件的求值結果為 true。<code>while</code> 語法如下︰</p>
-<pre class="eval">while (condition)
-   statement
-</pre>
-<p>如果條件變成 false，就停止執行循環內部的 <code>statement</code>，並把控制權移交給循環後面的語句。</p>
-<p>條件的測試會發生在執行循環裡的 <code>statement</code> 之前。如果返回的條件為 true，就會執行 <code>statement</code>，並再次測試條件。如果返回的條件為 false，就停止執行並把控制權移交給 <code>while</code> 後面的語句。</p>
-<p>若要執行多個語句，就使用區塊語法（{ ... }）把這些語句群組化。</p>
-<p><strong>範例 1</strong><br>
- 以下 <code>while</code> 循環會一直反覆直到 <code>n</code> 小於 3 為止︰</p>
-<pre class="eval">n = 0;
-x = 0;
-while (n &lt; 3) {
-   n++;
-   x += n;
-}
-</pre>
-<p>每一次的反覆，循環便會遞增 <code>n</code> 並且把 <code>n</code> 的值代入給 <code>x</code>。因此，<code>x</code> 和 <code>n</code> 持有下列的值︰</p>
-<ul>
- <li>第一次循環以後︰<code>n</code> = 1、<code>x</code> = 1</li>
- <li>第二次循環以後︰<code>n</code> = 2、<code>x</code> = 3</li>
- <li>第三次循環以後︰<code>n</code> = 3、<code>x</code> = 6</li>
-</ul>
-<p>第三次的循環完成以後，條件 <code>n</code> &lt; 3 不再為 true，所以終止循環。</p>
-<p><strong>範例 2</strong><br>
- 應避免無限循環。確認循環裡的條件最終一定會變成 false。否則循環永遠不會終止。下面的 <code>while</code> 循環裡的語句將會永遠執行下去，因為條件永遠不會變成 false︰</p>
-<pre class="eval">while (true) {
-   alert("Hello, world");
-}
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:循環語法:do...while_語法", "Core_JavaScript_1.5_教學:循環語法:label_語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/getter_和_setter_的定義/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/getter_和_setter_的定義/index.html
deleted file mode 100644
index 222529aa18..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/getter_和_setter_的定義/index.html
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: Getter 和 Setter 的定義
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/Getter_和_Setter_的定義
----
-<p> </p>
-
-<h3 id="Getter_和_Setter_的定義" name="Getter_和_Setter_的定義">Getter 和 Setter 的定義</h3>
-
-<p>Getter 是用來取得指定屬性的值的方法。Setter 是用來設定指定屬性的值的方法。你可以在所有預先定義的核心物件或使用者定義的物件（這類可支援新屬性的附加）中定義 Getter 和 Setter。為了定義 Getter 和 Setter，需要使用物件的字面表達語法。</p>
-
-<p>自 JavaScript 1.8.1 起，在設定物件和陣列裡的初始化子的屬性時，不再可以呼叫 Setter。</p>
-
-<p>以下的 JS shell 會話說明了 Getter 和 Setter 是如何在使用者定義的物件 o 裡運作的。<a class="internal" href="/zh_tw/SpiderMonkey/JavaScript_shell_%E7%B0%A1%E4%BB%8B" title="zh tw/SpiderMonkey/JavaScript shell 簡介">JS shell</a> 是一種應用程式，可讓開發者在分批模式或互動性的測試 JavaScript 代碼。</p>
-
-<pre>js&gt; var o = {a:7, get b() {return this.a+1;}, set c(x) {this.a = x/2}};
-[object Object]
-js&gt; o.a;
-7
-js&gt; o.b;
-8
-js&gt; o.c = 50;
-js&gt; o.a;
-25
-</pre>
-
-<p><code>o</code> 物件的屬性為︰</p>
-
-<ul>
- <li>o.a - 數字</li>
- <li>o.b - 返回 o.a 加 1 的 Getter</li>
- <li>o.c - 把 o.a 的值設為所屬的 o.c 的值的一半的 Setter</li>
-</ul>
-
-<p>另一種（Mozilla 限定）表示成一行的方式，也支援在物件的屬性上（如 "foo<strong>-</strong>bar"）設定 Getter 和 Setter，其中物件需要加上引號。</p>
-
-<pre>var o = {a:7, 'b' getter:function () {return this.a + 1;}, c setter:function (x) {this.a = x / 2;}};</pre>
-
-<p>請注意定義在物件的字面表達中的 Getter 和 Setter 的函數名稱使用的〝[gs]et <em>property</em>()〞（有別於稍後介紹的 <code>__define[GS]etter__</code>）並不是 Getter 本身的名稱，即使 <code>[gs]et <em>propertyName</em>(){ }</code> 語法可能會使你把他誤解成別的事物。若要命名在 Getter 或 Setter 之中的函數的名稱，就使用〝[gs]et <em>property</em>()〞語法，把 Getter 的名稱放在 get 或 set 後面，然後在其後面放上函數的名稱。下面的範例示範如何在物件的字面表達中命名 Getter 函數︰</p>
-
-<pre>var objects = [{get a b(){return 1}},
-               {a getter:function b(){return 1}},
-               {"a" getter:function b(){return 1}}];
-
-for (var i=0; i&lt;objects.length; ++i)
-    print(objects[i].__lookupGetter__("a")) // 為每一個 Getter 輸出 "function b(){return 1}"。
-</pre>
-
-<p>這次 JavaScript shell 會話說明 Getter 和 Setter 如何擴充 Date 的原型，給所有預先定義的 <code>Date</code> 類別的實體加入 year 屬性。他使用了 <code>Date</code> 類別中既存的 <code>getFullYear</code> 以及 <code>setFullYear</code> 方法，以支援 year 屬性的 Getter 和 Setter。</p>
-
-<p>以下語句針對 year 屬性定義 Getter 和 Setter︰</p>
-
-<pre>js&gt; var d = Date.prototype;
-js&gt; d.__defineGetter__("year", function() { return this.getFullYear(); });
-js&gt; d.__defineSetter__("year", function(y) { this.setFullYear(y); });
-</pre>
-
-<p>以下語句在 <code>Date</code> 物件中使用 Getter 和 Setter︰</p>
-
-<pre>js&gt; var now = new Date;
-js&gt; print(now.year);
-2000
-js&gt; now.year = 2001;
-987617605170
-js&gt; print(now);
-Wed Apr 18 11:13:25 GMT-0700 (Pacific Daylight Time) 2001
-</pre>
-
-<div class="note">在 JavaScript 1.5 的開發期間，這些是內含用來在既存的物件上定義新的 Getter 或 Setter 的 <code>getter =</code> 或 <code>setter =</code> 表達式的摘要，這些語法現在已被廢棄，將會在目前的 JS 1.5 引擎中引發警告，在未來的版本中將會變成語法錯誤。這些都應該要避免。</div>
-
-<h3 id="Summary" name="Summary">概要</h3>
-
-<p>原則上，Getter 和 Setter 可以</p>
-
-<ul>
- <li>使用 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%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> 定義，或</li>
- <li>稍後在任意的時間點上對任意的物件使用 Getter 或 Setter 的添加方法來加入。</li>
-</ul>
-
-<p>當要使用 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%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> 定義 Getter 和 Setter 的時候，你所需要做的是在 Getter 方法的前面加上 <code>get</code> 以及在 Setter 方法的前面加上 <code>set</code>。當然，Getter 方法不可以接受參數，Setter 方法則只能有一個參數（用來設定的新值）。舉例如下︰</p>
-
-<pre class="eval">o = {
-  a:7,
-  <strong>get</strong> b() { return this.a+1; },
-  <strong>set</strong> c(x) { this.a = x/2; }
-};
-</pre>
-
-<p>也可以在物件建立之後的任何時間點上，使用兩個稱作 <code>__defineGetter__</code> 和 <code>__defineSetter__</code> 的特殊方法，把 Getter 和 Setter 加到物件裡。這兩個方法需要 Getter 或 Setter 的名稱以字串的形式作為第一個參數。第二個參數是用來呼叫的函數作為 Getter 或 Setter。舉例如下（延用之前的例子）：</p>
-
-<pre class="eval">o.__defineGetter__("b", function() { return this.a+1; });
-o.__defineSetter__("c", function(x) { this.a = x/2; });
-</pre>
-
-<p>這兩種形式的選擇，取決於你的程式設計風格以及手上的工作。如果你已經在定義原型的時候，使用了物件的初始化子，或許你在大多數時候都會選擇第一種形式。這種形式更加密集且自然。然而，如果你需要稍後加入 Getter 和 Setter – 因為你並未編寫原型或實際的物件 – 這時第二種形式就是唯一可行的形式。第二種形式或許是 JavaScript 的動態性質中最佳的表現 – 但這會使代碼難以閱讀和理解。</p>
-
-<div class="note">
-<p>在 Firefox 3.0 以前，Getter 和 Setter 並不支援 DOM 元素。舊版本的 Firefox 會默默的出錯。如果需要這些例外，修改 HTMLElement 的原型 <code>(HTMLElement.prototype.__define{{ mediawiki.external('SG') }}etter__)</code>，並且避免拋出例外。</p>
-在 Firefox 3.0 中，在已定義的原型上定義 Getter 或 Setter 將會拋出例外。必須事先刪除這些屬性。舊版本的 Firefox 則沒有這個問題。</div>
-
-<h3 id="參閱">參閱</h3>
-
-<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/%E7%89%A9%E4%BB%B6/defineGetter" title="zh tw/Core JavaScript 1.5 參考/全域物件/物件/defineGetter">__defineGetter__</a></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/%E7%89%A9%E4%BB%B6/defineSetter" title="zh tw/Core JavaScript 1.5 參考/全域物件/物件/defineSetter">__defineSetter__</a></li>
- <li><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/get_%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 參考/運算子/特殊運算子/get 運算子">get</a></li>
- <li><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/set_%E9%81%8B%E7%AE%97%E5%AD%90" title="zh tw/Core JavaScript 1.5 參考/運算子/特殊運算子/set 運算子">set</a></li>
-</ul>
-
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:使用_this_取得物件的參考", "Core_JavaScript_1.5_教學:新物件的建立:屬性的刪除") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/index.html
deleted file mode 100644
index 687b428275..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
----
-title: 新物件的建立
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立
----
-<p> </p>
-<h3 id="新物件的建立" name="新物件的建立">新物件的建立</h3>
-<p>JavaScript 具備許多預先定義的物件。此外，你也可以建立你自己的物件。在 JavaScript 1.2 以後的版本中，你可以使用物件的初始化子來建立物件。另一個選擇是，你可以先建立建構子函數，然後使用這個函數以及 new 運算子來實體化物件。</p>
-<ul>
- <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%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></li>
- <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%E5%BB%BA%E6%A7%8B%E5%AD%90%E5%87%BD%E6%95%B8%E7%9A%84%E4%BD%BF%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%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%E7%89%A9%E4%BB%B6%E5%B1%AC%E6%80%A7%E7%9A%84%E7%B4%A2%E5%BC%95" title="zh tw/Core JavaScript 1.5 教學/新物件的建立/物件屬性的索引">物件屬性的索引</a></li>
- <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%E9%87%9D%E5%B0%8D%E7%89%A9%E4%BB%B6%E7%9A%84%E9%A1%9E%E5%9E%8B%E5%AE%9A%E7%BE%A9%E5%B1%AC%E6%80%A7" title="zh_tw/Core_JavaScript_1.5_教學/新物件的建立/針對物件的類型定義屬性">針對物件的類型定義屬性</a></li>
- <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%E6%96%B9%E6%B3%95%E7%9A%84%E5%AE%9A%E7%BE%A9" title="zh_tw/Core_JavaScript_1.5_教學/新物件的建立/方法的定義">方法的定義</a></li>
- <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%E4%BD%BF%E7%94%A8_this_%E5%8F%96%E5%BE%97%E7%89%A9%E4%BB%B6%E7%9A%84%E5%8F%83%E8%80%83" title="zh_tw/Core_JavaScript_1.5_教學/新物件的建立/使用_this_取得物件的參考">使用 this 取得物件的參考</a></li>
- <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/Getter_%E5%92%8C_Setter_%E7%9A%84%E5%AE%9A%E7%BE%A9" title="zh_tw/Core_JavaScript_1.5_教學/新物件的建立/Getter_和_Setter_的定義">Getter 和 Setter 的定義</a></li>
- <li><a href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%96%B0%E7%89%A9%E4%BB%B6%E7%9A%84%E5%BB%BA%E7%AB%8B/%E5%B1%AC%E6%80%A7%E7%9A%84%E5%88%AA%E9%99%A4" title="zh_tw/Core_JavaScript_1.5_教學/新物件的建立/屬性的刪除">屬性的刪除</a></li>
-</ul>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:物件和屬性", "Core_JavaScript_1.5_教學:新物件的建立:物件初始化子的使用") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/使用_this_取得物件的參考/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/使用_this_取得物件的參考/index.html
deleted file mode 100644
index 6af61628b5..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/使用_this_取得物件的參考/index.html
+++ /dev/null
@@ -1,27 +0,0 @@
----
-title: 使用 this 取得物件的參考
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/使用_this_取得物件的參考
----
-<p> </p>
-<h3 id="使用_this_取得物件的參考" name="使用_this_取得物件的參考">使用 this 取得物件的參考</h3>
-<p>JavaScript 有特別的關鍵字，<code>this</code>，你可以在方法內部使用，用來參考使用中的物件。舉例來說，假設你有稱為 <code>validate</code> 的函數可以檢驗物件的 value 屬性，傳入的參數是物件和上限、下限值︰</p>
-<pre>function validate(obj, lowval, hival) {
-   if ((obj.value &lt; lowval) || (obj.value &gt; hival))
-      alert("Invalid Value!");
-}
-</pre>
-<p>然後，你可以在每一個表單的 <code>onchange 事件處理器</code>中呼叫 <code>validate</code>，使用 <code>this</code> 把 <code>form</code> 元素傳給函數，如下所示︰</p>
-<pre>&lt;input type="text" name="age" size="3"
-   onChange="validate(this, 18, 99)"&gt;
-</pre>
-<p>一般來說，<code>this</code> 會參考方法裡的呼叫端物件。</p>
-<p>如果和 <code>form</code> 的屬性結合使用<span style="font-family: monospace;">，</span><code>this</code> 可以參考使用中物件的親表單。在下面的範例中，表單 <code>myForm</code> 內含 <code>Text</code> 物件以及按鈕。當使用者按下按鈕，表單的名稱就會被設成 <code>Text</code> 物件裡的值。按鈕的 <code>onclick</code> 事件處理器使用 <code>this.form</code> 來參考親表單 <code>myForm</code>。</p>
-<pre>&lt;form name="myForm"&gt;
-&lt;p&gt;&lt;label&gt;Form name:&lt;input type="text" name="text1" value="Beluga"&gt;&lt;/label&gt;
-&lt;p&gt;&lt;input name="button1" type="button" value="Show Form Name"
-      onclick="this.form.text1.value=this.form.name"&gt;
-&lt;/p&gt;
-&lt;/form&gt;
-</pre>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:方法的定義", "Core_JavaScript_1.5_教學:新物件的建立:Getter 和 Setter 的定義") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/屬性的刪除/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/屬性的刪除/index.html
deleted file mode 100644
index ba099fa041..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/屬性的刪除/index.html
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: 屬性的刪除
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/屬性的刪除
----
-<p> </p>
-<h3 id="屬性的刪除" name="屬性的刪除">屬性的刪除</h3>
-<p>你可以使用 <code>delete</code> 運算子移除屬性。下面的代碼示範如何移除屬性︰</p>
-<pre>// 建立新的物件 myobj，以及兩個屬性 a 和 b。
-myobj = new Object;
-myobj.a = 5;
-myobj.b = 12;
-
-// 移除一個屬性，只剩 b 屬性留在 myobj 裡。
-delete myobj.a;
-</pre>
-<p>你也可以使用 <code>delete</code> 來刪除全域變數，只要這個變數不是使用 <code>var</code> 關鍵字宣告的話︰</p>
-<pre>g = 17;
-delete g;
-</pre>
-<p>參閱 <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#delete" title="zh tw/Core JavaScript 1.5 教學/運算子/特殊運算子#delete">delete</a> 取得更多資訊。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:Getter_和_Setter_的定義", "Core_JavaScript_1.5_教學:預先定義的核心物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/建構子函數的使用/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/建構子函數的使用/index.html
deleted file mode 100644
index b9832bf245..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/建構子函數的使用/index.html
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: 建構子函數的使用
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/建構子函數的使用
----
-<p> </p>
-<h3 id="建構子函數的使用" name="建構子函數的使用">建構子函數的使用</h3>
-<p>還有一個選擇，你可以按照這兩個步驟來建立物件︰</p>
-<ol>
- <li>編寫建構子函數以完成物件類型的定義。</li>
- <li>使用 new 建立物件的實體。</li>
-</ol>
-<p>若要定義物件類型，就指定物件類型的名稱、屬性、方法並建立函數。舉例來說，假設你想要給 car 建立物件類型。你希望這個物件的類型稱作<code> car</code>，而且你還希望他有 make、model、year 這些屬性。要做到這些，你需要編寫出以下的函數︰</p>
-<pre>function car(make, model, year) {
-   this.make = make;
-   this.model = model;
-   this.year = year;
-}
-</pre>
-<p>注意 <code>this</code> 是用來把傳送給函數的值代入給物件的屬性。</p>
-<p>現在你可以建立稱作 <code>mycar</code> 的物件如下所示︰</p>
-<pre>mycar = new car("Eagle", "Talon TSi", 1993);
-</pre>
-<p>這個語句建立 <code>mycar</code> 並且把指定的值代入給他自己的屬性。然後 <code>mycar.make</code> 的值是字串 "Eagle"，<code>mycar.year</code> 是整數 1993，依此類推。</p>
-<p>你可以藉由呼叫 <code>new</code> 來建立許多個 <code>car</code> 的物件。例如，</p>
-<pre>kenscar = new car("Nissan", "300ZX", 1992);
-vpgscar = new car("Mazda", "Miata", 1990);
-</pre>
-<p>物件可以有另一個物件本身的屬性。例如，假設你定義稱為 <code>person</code> 的物件如下︰</p>
-<pre>function person(name, age, sex) {
-   this.name = name;
-   this.age = age;
-   this.sex = sex;
-}
-</pre>
-<p>然後實體化兩個新的 person 物件如下︰</p>
-<pre>rand = new person("Rand McKinnon", 33, "M");
-ken = new person("Ken Jones", 39, "M");
-</pre>
-<p>然後你可以改寫 car 的定義，加入用來接受 <code>person</code> 物件的 owner 屬性，如下︰</p>
-<pre>function car(make, model, year, owner) {
-   this.make = make;
-   this.model = model;
-   this.year = year;
-   this.owner = owner;
-}
-</pre>
-<p>若要實體化新的物件，你可以如下使用︰</p>
-<pre>car1 = new car("Eagle", "Talon TSi", 1993, rand);
-car2 = new car("Nissan", "300ZX", 1992, ken);
-</pre>
-<p>注意，當建立新的物件的時候，傳入的並不是字面表達字串或整數值，上面的語句把 <code>rand</code> 和 <code>ken</code> 物件當作參數傳給 owners。然後如果你希望找出 car2 的 owner 的名稱，你可以如下存取屬性︰</p>
-<pre>car2.owner.name
-</pre>
-<p>注意，你永遠可以給之前定義的物件加入屬性。例如，語句</p>
-<pre>car1.color = "black"
-</pre>
-<p>把 <code>color</code> 屬性加入給 car1，並且把 "black" 的值代入給新加入的屬性。然而，這樣並不能影響到其他的任何物件。若要給所有同樣類型的物件加入新的屬性，你必須把新的屬性加入到 car 物件類型的定義。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:物件初始化子的使用", "Core_JavaScript_1.5_教學:新物件的建立:物件屬性的索引") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/方法的定義/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/方法的定義/index.html
deleted file mode 100644
index 67a9250b8e..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/方法的定義/index.html
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: 方法的定義
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/方法的定義
----
-<p> </p>
-<h3 id="方法的定義" name="方法的定義">方法的定義</h3>
-<p><em>方法</em>就是和物件連繫在一起的函數。定義方法和定義標準函數的方式皆相同。然後使用下面的語句把函數和現存的物件連繫在一起︰</p>
-<pre>object.methodname = function_name
-</pre>
-<p>此處的 <code>object</code> 就是現存的物件，<code>methodname</code> 就是分配給方法的名稱，<code>function_name</code> 就是函數的名稱。</p>
-<p>然後你可以呼叫物件中的方法如下︰</p>
-<pre>object.methodname(params);
-</pre>
-<p>你可以藉由含入物件的建構子函數裡的方法定義，針對物件的類型來定義方法。例如，你可以定義函數，用來格式化並顯示先前定義的 car 物件的屬性。例如，</p>
-<pre>function displayCar() {
-   var result = "A Beautiful " + this.year + " " + this.make
-      + " " + this.model;
-   pretty_print(result);
-}
-</pre>
-<p>此處的 <code>pretty_print</code> 是用來顯示水平格線和字串的函數。注意 <code>this</code> 是用來參考方法所屬的物件。</p>
-<p>你可以在物件的定義中加上如下語句，把這個函數作為 car 的方法。</p>
-<pre>this.displayCar = displayCar;
-</pre>
-<p>於是，<code>car</code> 的完整定義就會變成這樣</p>
-<pre>function car(make, model, year, owner) {
-   this.make = make;
-   this.model = model;
-   this.year = year;
-   this.owner = owner;
-   this.displayCar = displayCar;
-}
-</pre>
-<p>然後你可以給每一個物件呼叫 <code>displayCar</code> 方法如下︰</p>
-<pre>car1.displayCar()
-car2.displayCar()
-</pre>
-<p>產生的輸出顯示在下圖中。</p>
-<p><img alt="Image:obja.gif" class="internal" src="/@api/deki/files/786/=Obja.gif"> <span style="font-weight: bold;">圖</span><small><strong> 7.1: 方法的輸出的顯示</strong></small></p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:針對物件的類型定義屬性", "Core_JavaScript_1.5_教學:新物件的建立:使用_this_取得物件的參考") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/物件初始化子的使用/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/物件初始化子的使用/index.html
deleted file mode 100644
index 79b7e5041b..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/物件初始化子的使用/index.html
+++ /dev/null
@@ -1,23 +0,0 @@
----
-title: 物件初始化子的使用
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/物件初始化子的使用
----
-<p> </p>
-<h3 id="物件初始化子的使用" name="物件初始化子的使用">物件初始化子的使用</h3>
-<p>除了使用建構子函數來建立物件以外，你也可以使用物件的初始化子來建立物件。使用物件的初始化子，有時又被稱為以字面表達記法來建立物件。「物件初始化子」與 C++ 的術語一致。</p>
-<p>使用物件初始化子的語句如下︰</p>
-<pre class="eval">var obj = { property_1:   value_1,   // 通常以 property_# 代表識別子...
-            2:            value_2,   // 或者使用數字...
-            ...,
-            "property_n": value_n }; // 或者使用字串</pre>
-<p>此處的 <code>obj</code> 就是新物件的名稱，每一個 <code>property_<em>i</em></code> 都是識別子（可以是名稱、數字、字串的字面表達），而且每一個 <code>value_<em>i</em></code> 都是表達式，其值會代入給 <code>property_<em>i</em></code>。<code>obj</code> 和代入動作不是必要的；如果你不需要在其他地方參考這個物件，你就不需要把物件代入給變數。（注意，你也許需要以圓括弧代替花括弧來包裝物件的字面表達，如果預期物件出現的地方會有其他語句，就要避免和區塊語法相混淆。）</p>
-<p>如果物件是在最頂層的 Script 中以物件初始化子來建立的，每一次要對內含該物件的字面表達求值時，JavaScript 就會把他解譯成物件。此外，用在函數裡的初始化子，會在每一次呼叫函數的時候建立。</p>
-<p>以下的語句建立物件，並把他代入給變數 <code>x</code>，但只在表達式的條件為 true 時如此。</p>
-<pre class="eval">if (cond) x = {hi:"there"};
-</pre>
-<p>以下例子使用了三個屬性來建立 <code>myHonda</code>。注意，<code>engine</code> 屬性也是物件，並連結有自己的屬性。</p>
-<pre class="eval">var myHonda = {color:"red",wheels:4,engine:{cylinders:4,size:2.2}};
-</pre>
-<p>你也可以使用物件的初始化子來建立陣列。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%AD%97%E9%9D%A2%E8%A1%A8%E9%81%94#%E9%99%A3%E5%88%97%E7%9A%84%E5%AD%97%E9%9D%A2%E8%A1%A8%E9%81%94" title="zh tw/Core JavaScript 1.5 教學/字面表達#陣列的字面表達">陣列的字面表達</a>。</p>
-<p>在 JavaScript 1.1 以後的版本中，你無法再使用物件的初始化子。你只能使用他們的建構子函數或者使用由某些其他用途的物件所提供的函數來建立物件。參閱 <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/%E5%BB%BA%E6%A7%8B%E5%AD%90%E5%87%BD%E6%95%B8%E7%9A%84%E4%BD%BF%E7%94%A8" title="zh tw/Core JavaScript 1.5 教學/建立新的物件/建構子函數的使用">建構子函數的使用</a>。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立", "Core_JavaScript_1.5_教學:新物件的建立:建構子函數的使用") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/物件屬性的索引/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/物件屬性的索引/index.html
deleted file mode 100644
index 08e243c78b..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/物件屬性的索引/index.html
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: 物件屬性的索引
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/物件屬性的索引
----
-<p> </p>
-<h3 id="物件屬性的索引" name="物件屬性的索引">物件屬性的索引</h3>
-<p>在 JavaScript 1.0 中，你可以使用物件的屬性名稱或序號索引來參考物件的屬性。然而，在 JavaScript 1.1 以後的版本中，如果你最初使用名稱來定義屬性，你就必須永遠使用名稱來參考屬性，如果你最初使用索引來定義屬性，你就必須永遠使用索引來參考屬性。</p>
-<p>這些限制出現在，當你使用建構子函數來建立物件及其屬性的時候（例如我們之前的 Car 物件類型），以及當你明確的定義個別的屬性的時候（例如，<code>myCar.color = "red"</code>）。如果你最初使用索引來定義物件的屬性，如 <code>myCar{{ mediawiki.external(5) }} = "25 mpg"</code>，隨後你只能以 <code>myCar{{ mediawiki.external(5) }}</code> 來參考這個屬性。</p>
-<p>這個規則的例外是從 HTML 反映過來的物件，如 <code>forms</code> 陣列。你永遠可以使用序號（以在文件中出現的位置為基準）或他們的名稱（如果有定義的話）來參考這些陣列。舉例來說，如果在文件中的第二個 <code>&lt;FORM&gt;</code> 標記中有 "myForm" 的 <code>NAME</code> 屬性，你可以使用 <code>document.forms{{ mediawiki.external(1) }}</code> 或 <code>document.forms{{ mediawiki.external('\"myForm\"') }}</code> 或 <code>document.myForm</code> 來參考表單。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:建構子函數的使用", "Core_JavaScript_1.5_教學:新物件的建立:針對物件的類型定義屬性") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/針對物件的類型定義屬性/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/針對物件的類型定義屬性/index.html
deleted file mode 100644
index 0d1e55ac71..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/新物件的建立/針對物件的類型定義屬性/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: 針對物件的類型定義屬性
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/新物件的建立/針對物件的類型定義屬性
----
-<p> </p>
-<h3 id="針對物件的類型定義屬性" name="針對物件的類型定義屬性">針對物件的類型定義屬性</h3>
-<p>你可以透過 <code>prototype</code> 屬性的使用來給之前定義的物件加入新的屬性。這種屬性的定義方式可以共用給所有指定類型的物件，而不只是針對單一的物件實體。以下代碼給所有的 <code>car</code> 類型的物件加入 <code>color</code> 屬性，然後把值代入給 <code>car1</code> 物件的 <code>color</code> 屬性。</p>
-<pre>Car.prototype.color=null;
-car1.color="black";
-</pre>
-<p>參閱 <a href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83" title="zh_tw/Core_JavaScript_1.5_參考">Core JavaScript 參考</a>・函數物件・<a 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#%E5%B1%AC%E6%80%A7" title="zh_tw/Core_JavaScript_1.5_參考/全域物件/函數#屬性"><code>prototype</code> 屬性</a> 以取得更多資訊。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:物件屬性的索引", "Core_JavaScript_1.5_教學:新物件的建立:方法的定義") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/條件語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/條件語法/index.html
deleted file mode 100644
index c9f263afe1..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/條件語法/index.html
+++ /dev/null
@@ -1,104 +0,0 @@
----
-title: 條件語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/條件語法
-translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Conditional_Statements
----
-<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.&lt;br&gt;");
-      break;
-   case "Apples":
-      document.write("Apples are $0.32 a pound.&lt;br&gt;");
-      break;
-   case "Bananas":
-      document.write("Bananas are $0.48 a pound.&lt;br&gt;");
-      break;
-   case "Cherries":
-      document.write("Cherries are $3.00 a pound.&lt;br&gt;");
-      break;
-   case "Mangoes":
-   case "Papayas":
-      document.write("Mangoes and papayas are $2.79 a pound.&lt;br&gt;");
-      break;
-   default:
-      document.write("Sorry, we are out of " + fruittype + ".&lt;br&gt;");
-}
-document.write("Is there anything else you'd like?&lt;br&gt;");
-</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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式模式的編寫/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式模式的編寫/index.html
deleted file mode 100644
index e07b2f6aa4..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式模式的編寫/index.html
+++ /dev/null
@@ -1,184 +0,0 @@
----
-title: 正規表達式模式的編寫
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式模式的編寫
----
-<p>正規表達式的模式是由簡單的字元所組成，如 <code>/abc/</code>，或由簡單的和特殊的字元所組成，如 <code>/ab*c/</code> 或 <code>/Chapter (\d+)\.\d*/</code>。後者含有用來記憶的括弧。以模式的某一部分所產生的比對結果會被記憶起來以供稍後使用，已在 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%AD%A3%E5%89%87%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> 一文中解說。</p>
-<h2 id="簡單模式的使用" name="簡單模式的使用">簡單模式的使用</h2>
-<p>簡單的模式直接由想要尋找的字元所組成。例如，<code>/abc/</code> 的模式只在字元 'abc' 以同樣順序一起出現時，比對出字串裡的字元。在字串 "Hi, do you know your abc's?" 和 "The latest airplane designs evolved from slabcraft." 中將會比對成功。在兩個例子中，都比對出子字串 'abc'。在字串 "Grab crab" 中沒有比對結果，因為字串裡並未含有子字串 'abc'。</p>
-<h2 id="特殊字元的使用" name="特殊字元的使用">特殊字元的使用</h2>
-<p>當搜尋的需求遠遠超出直接比對的能力時，如尋找 1 個以上的全部的 b，或是尋找含有特殊字元的空白部分。舉例來說，<code>/ab*c/</code> 的模式可比對出所有以 'a' 後接 0 個以上的全部的 'b'（* 的意思是前項出現 0 個以上）並緊接者 'c' 的字元。在字串 "cbbabbbbcdebc" 裡，可以比對出子字串 'abbbbc'。</p>
-<p>下表提供完整的列表，並解說可用於正規表達式的特殊字元。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>字元</th>
-   <th>意義</th>
-  </tr>
-  <tr>
-   <td>\</td>
-   <td>可分為以下兩種︰
-    <ul>
-     <li>對於那些沒有特殊意義的字元，反斜線可指示下一個字元為特殊的、不照字面解譯。舉例來說，<code>/b/ </code> 比對字元 'b'。藉由在 b 前面放置反斜線，也就是使用 <code>/\b/</code>，這個字元的特殊意義就變成比對文字的邊界。</li>
-     <li>對於那些有特別意義的字元，就利用反斜線指示下一個字元並非特殊的、應該照字面解譯。舉例來說，* 是一個意義為前項出現 0 個以上的特殊字元。例如，<code>/a*/</code> 意思是比對 0 個以上的全部的 a。如果要照字面比對 *，就在前面加上反斜線。例如，<code>/a\*/</code> 比對出 'a*'。</li>
-    </ul>
-   </td>
-  </tr>
-  <tr>
-   <td>^</td>
-   <td>比對輸入的開頭處。如果把多行標誌設為 true，也會比對緊接在換行字元之後的字元。舉例來說，<code>/^A/</code> 不會在 "an A" 裡比對出 'A'，但會在 "An A" 裡比對出第一個 'A'。</td>
-  </tr>
-  <tr>
-   <td>$</td>
-   <td>比對輸入的末尾處。如果把多行標誌設為 true，也會比對緊接在換行字元之前的字元。舉例來說，<code>/t$/</code> 不會在 "eater" 裡比對出 't'，但會在 "eat" 裡比對出來。</td>
-  </tr>
-  <tr>
-   <td>*</td>
-   <td>比對前面的字元 0 次以上。舉例來說，<code>/bo*/</code> 在 "A ghost booooed" 比對出 'boooo'，並在 "A bird warbled" 比對出 'b'，但不會在 "A goat grunted" 比對出來。</td>
-  </tr>
-  <tr>
-   <td>+</td>
-   <td>比對前面的字元 1 次以上。等價於 {1,}。舉例來說，<code>/a+/</code> 在 "candy" 比對出 'a'，並在 "caaaaaaandy" 比對出所有的 a。</td>
-  </tr>
-  <tr>
-   <td>?</td>
-   <td>比對前面的字元 0 次或 1 次。
-    <p>舉例來說，<code>/e?le?/</code> 在 "angel" 比對出 'el'，並在 "angle" 比對出 'le'。</p>
-    <p>如果緊接在任何一個數量子 *、+、?、{} 之後來使用，將使數量子非貪婪（比對出最小的次數），而預設值是貪婪的（比對出最大的次數）。舉例來說，使用 <code>/\d+/</code> 比對 "123abc" 便返回 "123"，如果使用 <code>/\d+?/</code>，只有 "1" 會被比對出來。</p>
-    也用於表示預讀，在本表的 x(?=y) 和 x(?!y) 中有說明。</td>
-  </tr>
-  <tr>
-   <td>.</td>
-   <td>小數點比對任意的單一字元，除了換行字元以外。舉例來說，<code>/.n/</code> 在 "nay, an apple is on the tree" 比對出 'an' 和 'on'，而非 'nay'。</td>
-  </tr>
-  <tr>
-   <td>(x)</td>
-   <td>比對 'x' 並記憶此項比對結果。又稱為截取括弧（capturing parentheses）。舉例來說，<code>/(foo)/</code> 在 "foo bar" 裡比對出並記憶 'foo'。比對出來的子字串可以從比對結果的陣列的元素 <code>1</code>, ..., <code>n</code> 取回。</td>
-  </tr>
-  <tr>
-   <td>(?:x)</td>
-   <td>比對 'x' 但不記憶此項比對結果。又稱為非截取括弧。比對出來的子字串無法從比對結果的陣列的元素 <code>1</code>, ..., <code>n</code> 取回。</td>
-  </tr>
-  <tr>
-   <td>x(?=y)</td>
-   <td>比對 'x' 但只在 'x' 後面接續著 'y' 的時候。舉例來說，<code>/Jack(?=Sprat)/</code> 只在後面接續著 'Sprat' 的時候比對出 'Jack'。<code>/Jack(?=Sprat|Frost)/</code> 只在後面接續著 'Sprat' 或 'Frost' 的時候比對出 'Jack'。然而，'Sprat' 或 'Frost' 都不是比對結果的一部分。</td>
-  </tr>
-  <tr>
-   <td>x(?!y)</td>
-   <td>比對 'x' 但只在 'x' 後面沒有接續著 'y' 的時候。舉例來說，<code>/\d+(?!\.)/</code> 只在後面沒有接續著小數點的時候比對出數字。正規表達式 <code>/\d+(?!\.)/.exec("3.141")</code> 比對出 '141' 而非 '3.141'。</td>
-  </tr>
-  <tr>
-   <td>x|y</td>
-   <td>比對 'x' 或 'y'。舉例來說，<code>/green|red/</code> 在 "green apple" 比對出 'green'，並在 "red apple"比對出 'red'。</td>
-  </tr>
-  <tr>
-   <td>{n}</td>
-   <td>在此 n 是正整數。比對出恰好有 n 個的前面的字元。舉例來說，<code>/a{2}/</code> 不會在 "candy" 裡比對出 'a'，但在 "caandy" 裡比對出全部的 a，並在 "caaandy" 裡比對出前兩個 a。</td>
-  </tr>
-  <tr>
-   <td>{n,}</td>
-   <td>在此 n 是正整數。比對出至少 n 個的前面的字元。舉例來說，<code>/a{2,}/</code> 不會在 "candy" 裡比對出 'a'，但在 "caandy" 還有在 "caaaaaaandy" 裡比對出全部的 a。</td>
-  </tr>
-  <tr>
-   <td>{n,m}</td>
-   <td>在此 n 和 m 是正整數。比對出至少 n 個且至多 m 個的前面的字元。舉例來說，<code>/a{1,3}/</code> 在 "cndy" 裡比對不出來，但在 "candy" 比對出 'a'，在 "caandy" 比對出前兩個 a，並在 "caaaaaaandy" 比對出前三個 a，注意，當比對 "caaaaaaandy" 的時候，比對的是 "aaa"，即使字串裡有更多的 a。</td>
-  </tr>
-  <tr>
-   <td><code>xyz</code></td>
-   <td>字元集。比對出包含在括號裡的其中任何一個字元。你可以使用連接符號 (-) 指定字元的範圍。舉例來說，<code>abcd</code> 等於 <code>a-d</code>。這些都能在 "brisket" 裡比對 'b'，並在 "city" 裡比對 'c'。</td>
-  </tr>
-  <tr>
-   <td>^xyz</td>
-   <td>字元否定集、或字元補集。也就是比對出任何不包含在括號裡的一切。你可以使用連接符號 (-) 指定字元的範圍。舉例來說，<code>^abc</code> 等於 <code>^a-c</code>。這些都能在 "brisket" 裡比對出第一個字母 'r'，並在 "chop" 比對出 'h'。</td>
-  </tr>
-  <tr>
-   <td>\\b</td>
-   <td>比對退格。（別和 \b 混淆。）</td>
-  </tr>
-  <tr>
-   <td>\b</td>
-   <td>比對文字邊界，如空白或換行字元。（別和 <code>\\b</code> 混淆。）舉例來說，<code>/\bn\w/</code> 在 "noonday" 裡比對出 'no'，<code>/\wy\b/</code> 在 "possibly yesterday" 比對出 'ly'。</td>
-  </tr>
-  <tr>
-   <td>\B</td>
-   <td>比對非文字邊界。舉例來說，<code>/\w\Bn/</code> 在 "noonday" 裡比對出 'on'，<code>/y\B\w/</code> 在 "possibly yesterday" 裡比對出 'ye'。</td>
-  </tr>
-  <tr>
-   <td>\cX</td>
-   <td>在此 X 是控制字元。在字串中比對控制字元。舉例來說，<code>/\cM/</code> 在字串裡比對出 control-M。</td>
-  </tr>
-  <tr>
-   <td>\d</td>
-   <td>比對數字字元。等於 <code>0-9</code>。舉例來說，<code>/\d/</code> 或 <code>/0-9/</code> 都在 "B2 is the suite number" 比對出 '2'。</td>
-  </tr>
-  <tr>
-   <td>\D</td>
-   <td>比對非數字字元。等於 <code>^0-9</code>。舉例來說，<code>/\D/</code> 或 <code>/^0-9/</code> 都在 "B2 is the suite number" 比對出 'B'。</td>
-  </tr>
-  <tr>
-   <td>\f</td>
-   <td>比對換頁（form-feed）。</td>
-  </tr>
-  <tr>
-   <td>\n</td>
-   <td>比對換行。</td>
-  </tr>
-  <tr>
-   <td>\r</td>
-   <td>比對歸位。</td>
-  </tr>
-  <tr>
-   <td>\s</td>
-   <td>比對單一空白字元，包括空白、TAB、換頁、換行。等於
-    <p><code>\\f\\n\\r\\t\\v\\u00A0\\u2028\\u2029</code>。</p>
-    舉例來說，<code>/\s\w*/</code> 在 "foo bar" 裡比對出 ' bar'。</td>
-  </tr>
-  <tr>
-   <td>\S</td>
-   <td>比對除了空白字元以外的單一字元。等於
-    <p><code>^ \\f\\n\\r\\t\\v\\u00A0\\u2028\\u2029</code>。</p>
-    舉例來說，<code>/\S\w*/</code> 在 "foo bar" 裡比對出 'foo'。</td>
-  </tr>
-  <tr>
-   <td>\t</td>
-   <td>比對 TAB。</td>
-  </tr>
-  <tr>
-   <td>\v</td>
-   <td>比對垂直 TAB。</td>
-  </tr>
-  <tr>
-   <td>\w</td>
-   <td>比對任何字母和數字的字元，包括底線。等於 A-Za-z0-9_。舉例來說，<code>/\w/</code> 在 "apple" 裡比對出 'a'，在 "$5.28" 裡比對出 '5'，並在 "3D" 比對出 '3'。</td>
-  </tr>
-  <tr>
-   <td>\W</td>
-   <td>比對任何非字母和數字的字元。等於 {{ mediawiki.external('^A-Za-z0-9_') }}。舉例來說，<code>/\W/</code> 或 <code>/{{ mediawiki.external('^A-Za-z0-9_') }}/</code> 在 "50%" 裡比對出 '%'。</td>
-  </tr>
-  <tr>
-   <td>\n</td>
-   <td>在此 n 是正整數。回向參考在正規表達式中的第 n 個括弧中比對的最後的子字串（對左括弧計數）。舉例來說，<code>/apple(,)\sorange\1/</code> 在 "apple, orange, cherry, peach" 裡比對出 'apple, orange,'。</td>
-  </tr>
-  <tr>
-   <td>\0</td>
-   <td>比對 NUL 字元。後面不可以接續其他數字。</td>
-  </tr>
-  <tr>
-   <td>\xhh</td>
-   <td>比對內碼為 hh 的字元（兩個十六進位數）</td>
-  </tr>
-  <tr>
-   <td>\uhhhh</td>
-   <td>比對內碼為 hhhh 的字元（四個十六進位數）</td>
-  </tr>
- </tbody>
-</table>
-<p><small><strong>表 4.1: 正規表達式裡的特殊字元。</strong></small></p>
-<h2 id="括弧的使用" name="括弧的使用">括弧的使用</h2>
-<p>使用括弧把正規表達式的模式的某一部分括起來，就會記憶那部分被比對出來的子字串。一經記憶，就可以在其他地方取回並使用。可在 <a class="new internal" href="/../../../../zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%AD%A3%E5%89%87%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" rel="internal" title="../../../../zh tw/Core JavaScript 1.5 教學/正則表達式的運用/括弧子字串的比對結果的運用">括弧子字串的比對結果的運用</a> 一文中找到說明。</p>
-<p>舉例來說，以 <code>/Chapter (\d+)\.\d*/</code> 的模式來解說額外的跳脫和特殊字元，那些用來指示某一部分模式需要記憶的部分。他會比對恰好是 'Chapter ' 的字元，隨後是 1 個以上的數字（\d 的意思是任意數字字元，+ 的意思是 1 次以上），隨後是一個小數點（點本身是特殊字元，前面附上 \ 的點的意思是這個模式必須尋找字面為 '.' 的字元），隨後是任何 0 個以上的數字（\d 的意思是任意數字字元，* 的意思是 0 次以上）。此外，括弧被用來記憶第一次比對出來的數字字元。</p>
-<p>在 "Open Chapter 4.3, paragraph 6" 裡可以找出這個模式，且 '4' 會被記憶。在 "Chapter 3 and 4" 裡則找不出這個模式，因為字串裡的 '3' 後面沒有點。</p>
-<p>若要比對子字串，且不要記憶比對出來的那一部分，可在括弧裡面的最前面加上 <code>?:</code>。舉例來說，<code>(?:\d+)</code> 比對 1 個以上的數字字元，但不會記憶那些比對出來的字元。</p>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的建立", "Core_JavaScript_1.5_教學:正規表達式的運用") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的建立/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的建立/index.html
deleted file mode 100644
index ffeee0f5c7..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的建立/index.html
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: 正規表達式的建立
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的建立
----
-<h3 id="正則表達式的建立" name="正則表達式的建立">正規表達式的建立</h3>
-<p>正規表達式有兩種建構方式︰</p>
-<ul>
- <li>使用正規表達式的字面表達，如下︰</li>
-</ul>
-<pre> re = /ab+c/; </pre>
-<dl>
- <dd>
-  <dl>
-   <dd>
-    正規表達式的字面表達會在對 Script 求值時提供正規表達式的編譯產物。這時正規表達式將成為常數而遺留下來，採用這個方式可以得到較好的效能。</dd>
-  </dl>
- </dd>
-</dl>
-<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/RegExp" title="zh tw/Core JavaScript 1.5 參考/全域物件/RegExp">RegExp</a> 物件的建構子函數，如下︰</li>
-</ul>
-<pre> re = new RegExp("ab+c"); </pre>
-<dl>
- <dd>
-  <dl>
-   <dd>
-    使用建構子函數可在執行時期提供正規表達式的編譯產物。當你知道正規表達式的模式將會變更時，或者當你無法預知取自其他來源的模式（如使用者的輸入）時，就使用建構子函數。</dd>
-  </dl>
- </dd>
-</dl>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:運算子:特殊運算子", "Core_JavaScript_1.5_教學:正規表達式模式的編寫") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/index.html
deleted file mode 100644
index 792eec13b9..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/index.html
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: 正規表達式的運用
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用
-translation_of: Web/JavaScript/Guide/Regular_Expressions
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions
----
-<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>&lt;SCRIPT type="text/javascript"&gt;
-  myRe = /d(b+)d/g;
-  myArray = myRe.exec("cdbbdbsbz");
-&lt;/SCRIPT&gt;
-</pre>
-<p>如果你不需要存取正規表達式的屬性，另一個建立 <code>myArray</code> 的方式如下 Script︰</p>
-<pre>&lt;SCRIPT type="text/javascript"&gt;
-  myArray = /d(b+)d/g.exec("cdbbdbsbz");
-&lt;/SCRIPT&gt;
-</pre>
-<p>如果你想要從字串來建構正規表達式，還有其他選擇如下 Script︰</p>
-<pre>&lt;SCRIPT type="text/javascript"&gt;
-  myRe = new RegExp ("d(b+)d", "g");
-  myArray = myRe.exec("cdbbdbsbz");
-&lt;/SCRIPT&gt;
-</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>&lt;SCRIPT type="text/javascript"&gt;
-  myRe = /d(b+)d/g;
-  myArray = myRe.exec("cdbbdbsbz");
-  document.writeln("The value of lastIndex is " + myRe.lastIndex);
-&lt;/SCRIPT&gt;
-</pre>
-<p>Script 顯示︰</p>
-<pre>The value of lastIndex is 5
-</pre>
-<p>然而，如果你有這個 Script︰</p>
-<pre>&lt;SCRIPT type="text/javascript"&gt;
-  myArray = /d(b+)d/g.exec("cdbbdbsbz");
-  document.writeln("The value of lastIndex is " + /d(b+)d/g.lastIndex);
-&lt;/SCRIPT&gt;
-</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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/使用標誌的進階搜尋/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/使用標誌的進階搜尋/index.html
deleted file mode 100644
index 2dce68e5a9..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/使用標誌的進階搜尋/index.html
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: 使用標誌的進階搜尋
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用/使用標誌的進階搜尋
-translation_of: Web/JavaScript/Guide/Regular_Expressions
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions/Advanced_Searching_With_Flags
----
-<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>&lt;script type="text/javascript"&gt;
- re = /\w+\s/g;
- str = "fee fi fo fum";
- myArray = str.match(re);
- document.write(myArray);
-&lt;/script&gt;
-</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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/括弧子字串的比對結果的運用/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/括弧子字串的比對結果的運用/index.html
deleted file mode 100644
index 8abec68f16..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/括弧子字串的比對結果的運用/index.html
+++ /dev/null
@@ -1,44 +0,0 @@
----
-title: 括弧子字串的比對結果的運用
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用/括弧子字串的比對結果的運用
-translation_of: Web/JavaScript/Guide/Regular_Expressions#Using_Parenthesized_Substring_Matches
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Working_with_Regular_Expressions/Using_Parenthesized_Substring_Matches
----
-<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>&lt;script type="text/javascript"&gt;
- re = /(\w+)\s(\w+)/;
- str = "John Smith";
- newstr = str.replace(re, "$2, $1");
- document.write(newstr);
-&lt;/script&gt;
-</pre>
-<p>本例輸出 "Smith, John"。</p>
-<p><strong>範例 2</strong><br>
-附註: 在 <code>getInfo</code> 函數中，<code>exec</code> 方法是以 () 省略記法所呼叫的，這個記法在 Firefox 可以運作，其他瀏覽器則不一定。</p>
-<pre>&lt;html&gt;
-
-&lt;script type="text/javascript"&gt;
- function getInfo(field){
-   var a = /(\w+)\s(\d+)/(field.value);
-   window.alert(a[1] + ", your age is " + a[2]);
- }
-&lt;/script&gt;
-
-Enter your first name and your age, and then press Enter.
-
-&lt;form&gt;
-  &lt;input type="text" name="NameAge" onchange="getInfo(this);"&gt;
-&lt;/form&gt;
-
-&lt;/html&gt;
-</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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/正規表達式的範例/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/正規表達式的範例/index.html
deleted file mode 100644
index 0bd61d90e5..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/正規表達式的運用/正規表達式的範例/index.html
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: 正規表達式的範例
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/正規表達式的運用/正規表達式的範例
----
-<h3 id="範例" name="範例">範例</h3>
-<p>以下範例示範正規表達式的一些用法。</p>
-<h4 id="改變輸入字串的順序" name="改變輸入字串的順序">改變輸入字串的順序</h4>
-<p>以下範例解說了正規表達式的構造，以及 <code>string.split()</code> 和 <code>string.replace()</code> 的用法。他會整理凌亂的格式化輸入字串，字串中內含以空白、TAB、和唯一的分號所分割的姓名（名字在前）。最後，他會調換姓名的順序（姓氏在前）並重新排序列表。</p>
-<pre>&lt;script type="text/javascript"&gt;
-
-// 內含很多空白和 TAB 的 names 字串，
-// 在名字和姓氏之間也會有很多空白。
-var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ";
-
-var output = new Array(
-  "---------- Original String&lt;br&gt;&lt;br&gt;",
-  names + "&lt;br&gt;&lt;br&gt;");
-
-// 預備兩個正規表達式的模式和儲存用的陣列。
-// 把字串分割存入陣列元素裡。
-
-// 模式︰可能的空白，然後是分號，然後是可能的空白
-var pattern = /\s*;\s*/;
-
-// 使用上面的模式把字串分割成多個斷片，
-// 並且把斷片儲存至稱為 nameList 的陣列。
-var nameList = names.split(pattern);
-
-// 新的模式︰1 個以上的字元，然後是空白字元，然後是 1 個以上的字元。
-// 使用括弧來記憶模式的某一部分。
-// 已記憶的部分稍後會被參考。
-var pattern = /(\w+)\s+(\w+)/;
-
-// 用來保存已處理的姓名的新陣列。
-var bySurnameList = new Array();
-
-// 顯示 names 陣列，並移動以逗號分隔且姓氏在前的姓名到新的陣列。
-//
-// replace 方法除去符合模式的所有內容，並以已記憶的字串取代。
-// 字串是以第二個已記憶的部分、後接逗號和空格、後接第一個已記憶的部分所組成。
-//
-// 變數 $1 和 $2 參考了符合模式的已記憶的部分。
-
-output.push("---------- After Split by Regular Expression&lt;br&gt;");
-
-var i, len;
-for (i = 0, len = nameList.length; i &lt; len; i++)
-{
-  output.push(nameList[i] + "&lt;br&gt;");
-  bySurnameList[i] = nameList[i].replace(pattern, "$2, $1")
-}
-
-// 顯示新的陣列。
-output.push("---------- Names Reversed&lt;br&gt;");
-for (i = 0, len = bySurnameList.length; i &lt; len; i++)
-{
-  output.push(bySurnameList[i] + "&lt;br&gt;")
-}
-
-// 以姓氏來排序，然後顯示已排序的陣列。
-bySurnameList.sort();
-output.push("---------- Sorted&lt;br&gt;");
-for (i = 0, len = bySurnameList.length; i &lt; len; i++)
-{
-  output.push(bySurnameList[i] + "&lt;br&gt;")
-}
-
-output.push("---------- End&lt;br&gt;");
-
-document.write(output.join("\n"));
-
-&lt;/script&gt;
-</pre>
-<h4 id="使用特殊字元來對輸入進行驗證" name="使用特殊字元來對輸入進行驗證">使用特殊字元來對輸入進行驗證</h4>
-<p>在以下的範例中，有位使用者輸入電話號碼。當使用者按下 Enter 時，Script 就會檢查電話號碼的有效性。如果電話號碼有效（符合由正規表達式所指定的字元序列），Script 在視窗上表示感謝使用者，並確認了電話號碼。如果電話號碼無效，Script 在視窗上表示使用者的電話號碼有誤的資訊。</p>
-<p>正規表達式尋找 0 或 1 個左括弧 <code>\(?</code>，後接三個數字 <code>\d{3}</code>，後接 0 或 1 個右括弧 <code>\)?</code>，如果有的話，就後接橫線 (-) 或斜線 (\) 或小數點 (.)，並記憶字元 <code>(-\\/\\.)</code>，後接三個數字 <code>\d{3}</code>，後接已記憶的橫線、斜線、小數點的比對結果 <code>\1</code>，後接四個數字 <code>\d{4}</code>。</p>
-<p>當使用者按下 Enter 設定 <code>RegExp.input</code> 的值時，就會發動 <code>Change</code> 事件。</p>
-<pre>&lt;!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-  "http://www.w3.org/TR/html4/loose.dtd"&gt;
-&lt;html&gt;
-  &lt;head&gt;
-    &lt;meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"&gt;
-    &lt;meta http-equiv="Content-Script-Type" content="text/javascript"&gt;
-    &lt;script type="text/javascript"&gt;
-      var re = /\(?\d{3}\)?([-\/\.])\d{3}\1\d{4}/;
-
-      function testInfo(phoneInput)
-      {
-        var OK = re.exec(phoneInput.value);
-
-        if (!OK)
-        {
-          window.alert(RegExp.input + " isn't a phone number with area code!");
-        }
-        else
-        {
-          window.alert("Thanks, your phone number is " + OK[0]);
-        }
-      }
-    &lt;/script&gt;
-  &lt;/head&gt;
-
-  &lt;body&gt;
-    &lt;p&gt;Enter your phone number (with area code) and then press Enter.&lt;/p&gt;
-    &lt;form action=""&gt;
-      &lt;input name="phone" onchange="testInfo(this);"&gt;
-    &lt;/form&gt;
-  &lt;/body&gt;
-&lt;/html&gt;
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:正規表達式的運用:使用標誌的進階搜尋", "Core_JavaScript_1.5_教學:區塊語法") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/物件和屬性/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/物件和屬性/index.html
deleted file mode 100644
index fc10840076..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/物件和屬性/index.html
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: 物件和屬性
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/物件和屬性
-translation_of: Web/JavaScript/Guide/Working_with_Objects
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Objects_and_Properties
----
-<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>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/物件的操作語法/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/物件的操作語法/index.html
deleted file mode 100644
index f1e46206fe..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/物件的操作語法/index.html
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: 物件的操作語法
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/物件的操作語法
----
-<h3 id="物件的操作語法" name="物件的操作語法">物件的操作語法</h3>
-<p>JavaScript 使用 <code>for...in</code>、<code>for each...in</code>、<code>with</code> 語法來操作物件。</p>
-<h4 id="for...in_語法" name="for...in_語法">for...in 語法</h4>
-<p><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for...in" title="zh tw/Core JavaScript 1.5 參考/語法/for...in"><code>for...in</code></a> 語法可處理對應物件的所有屬性的指定變數。JavaScript 會對每一個對應的屬性來執行指定的語句。<code>for...in</code> 語句如下︰</p>
-<pre>for (variable in object) {
-   statements
-}
-</pre>
-<p><strong>範例</strong><br>
- 以下函數接受物件和物件的名稱作為自己的參數。然後函數反覆遍歷物件的屬性，並返回列出屬性名稱和值的字串。</p>
-<pre>function dump_props(obj, obj_name) {
-   var result = "";
-   for (var i in obj) {
-      result += obj_name + "." + i + " = " + obj[i] + "&lt;br&gt;";
-   }
-   result += "&lt;hr&gt;";
-   return result;
-}
-</pre>
-<p>以帶有屬性 <code>make</code> 和 <code>model</code> 的物件 <code>car</code> 為例，輸出結果如下︰</p>
-<pre class="eval">car.make = Ford
-car.model = Mustang
-</pre>
-<p><strong>陣列</strong><br>
- 雖然使用這個方法來處理所有的 <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" title="zh tw/Core JavaScript 1.5 參考/全域物件/Array">Array</a> 元素很是誘人，但如果你修改了 Array 物件，例如加入自訂的屬性或方法，<strong>for...in</strong> 語法就只會處理除了陣列元素以外的所有使用者定義的屬性，<strong>for...in</strong> 語法將會返回你的使用者定義的屬性的名稱，除了數字索引以外。因此在處理陣列時，最好還是使用傳統的 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for" title="zh tw/Core JavaScript 1.5 參考/語法/for">for</a> 循環，並配合數字索引。</p>
-<h4 id="for_each...in_語法" name="for_each...in_語法">for each...in 語法</h4>
-<p><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for_each...in" title="zh tw/Core JavaScript 1.5 參考/語法/for each...in"><code>for each...in</code></a> 是在 <a class="internal" href="/zh_tw/JavaScript_1.6_%E6%96%B0%E9%AE%AE%E4%BA%8B" title="zh tw/JavaScript 1.6 新鮮事">JavaScript 1.6</a> 中引入的循環語法，他很類似 <code>for...in</code>，但不是針對物件的屬性的名稱，而是物件的屬性的值。</p>
-<h4 id="with_語法" name="with_語法">with 語法</h4>
-<p><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/with" title="zh tw/Core JavaScript 1.5 參考/語法/with"><code>with</code></a> 語法為一整組的語句確立了預設的物件。JavaScript 會在一整組語法之內找出所有不合格的名稱，只要這個名稱是預設物件的屬性，就會將其確定。如果有一個不合格的名稱符合其中一個屬性，然後就會在語句中使用這個屬性。否則，就會被當成局域或全域的變數。</p>
-<p><code>with</code> 語法如下︰</p>
-<pre>with (object) {
-   statements
-}
-</pre>
-<p><strong>範例</strong><br>
- 以下 <code>with</code> 語法指定 <code>Math</code> 物件為預設的物件。<code>with</code> 語法裡面使用了 <code>PI</code> 屬性和 <code>cos</code>、<code>sin</code> 方法的語句，而無需指定物件。JavaScript 會假定他們參照的是 <code>Math</code> 物件。</p>
-<pre>var a, x, y;
-var r = 10;
-with (Math) {
-   a = PI * r * r;
-   x = r * cos(PI);
-   y = r * sin(PI/2);
-}
-</pre>
-<p>附註︰雖然使用 <code>with</code> 語句可以使你的程式更加簡潔，但不當使用 <code>with</code> 也會在一定程度上使你的程式速度變慢。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/with" title="zh tw/Core JavaScript 1.5 參考/語法/with">Core JavaScript 1.5 參考:語法:with</a>。</p>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:循環語法:continue_語法", "Core_JavaScript_1.5_教學:註解") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/繼承/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/繼承/index.html
deleted file mode 100644
index 4b1e65afce..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/繼承/index.html
+++ /dev/null
@@ -1,146 +0,0 @@
----
-title: 繼承
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/繼承
----
-<p> </p>
-
-<h3 id="繼承" name="繼承">繼承</h3>
-
-<p>這裡有很多有關如何在 JavaScript 中定義類型（類別）的困惑之處，包括繼承。這裡有很多方式和一些 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E7%B9%BC%E6%89%BF#%E9%98%BB%E7%A4%99" title="zh tw/Core JavaScript 1.5 教學/繼承#阻礙">次優的選擇</a>。這裡所展示的運作的最好，而且簡單。</p>
-
-<h2 id="範例" name="範例">範例</h2>
-
-<p>B 繼承 A︰</p>
-
-<pre class="brush: js">function A(a)
-{
-  this.varA = a;
-}
-
-A.prototype =
-{
-  varA : null,
-  doSomething : function()
-  {
-     ...
-  }
-}
-
-function B(a, b)
-{
-  A.call(this, a);
-  this.varB = b;
-}
-
-B.prototype =
-{
-  varB : null,
-  doSomething : function() // 覆寫
-  {
-     A.prototype.doSomething.apply(this, arguments); // 呼叫親類型
-     ...
-  }
-}
-
-extend(B, A);
-
-var b = new B();
-b.doSomething();
-</pre>
-
-<p>重點部分是︰</p>
-
-<ul>
- <li>類型是在 .prototype 裡定義的</li>
- <li>使用 extend() 來繼承</li>
-</ul>
-
-<p>此處的 extend() 並不是內建的函數，其定義如下︰</p>
-
-<pre class="eval">function extend(child, supertype)
-{
-   child.prototype.__proto__ = supertype.prototype;
-}
-</pre>
-
-<h2 id="prototype_和___proto__" name="prototype_和___proto__">prototype 和 __proto__</h2>
-
-<p>JavaScript 對於來自 Java 或 C++ 的開發者而言會感到一些困惑，因為他完全動態，完全執行時期，而且完全沒有類別。他完全只有實體（物件）。甚至〝類別〞也只是函數物件模擬出來的。</p>
-
-<p>你或許已經注意到前面我們的 <code>function A</code> 很特別，這並不是普通的函數，但可以和關鍵字 <code>new</code> 結合使用來實體化新的物件。他也可以有稱作 <code>prototype</code> 的特別的屬性（由 JS 標準所定義）。這個函數所做的不過是，當你呼叫 <code>new</code> 的時候，參考的 prototype 物件被複製到新的實體的屬性 <code>__proto__</code>。也就是當你這樣做 <code>var a1 = new A()</code> 的時候，JS（在記憶體中建立物件之後，並在使用 <code>this</code> 執行函數 A() 來定義他之前）只是簡單的這樣做 <code>a1.__proto__ = A.prototype</code>。然後當你存取實體的屬性的時候，JS 首先會檢查那些是否直接存在於物件上，如果不是的話，就從 <code>__proto__</code> 搜尋。這意思是所有你定義在 <code>prototype</code> 裡的東西，實際上會被所有的實體所共用，而且你甚至可以在稍後修改 <code>prototype</code> 的部分，並且在所有既存的實體上表現出這個改變，只要你想要的話。</p>
-
-<p><strong>舉例來說</strong>，當你在上面的範例中這樣做 <code>var a1 = new A(); var a2 = new A();</code>，然後 <code>a1.doSomething</code> 實際上會參考 <code>a1.__proto__.doSomething</code>，這些和你定義的 <code>A.prototype.doSomething</code> 相同，也就是 <code>a1.__proto__.doSomething == a2.__proto__.doSomething == A.prototype.doSomething</code>。</p>
-
-<p><strong>簡而言之</strong>，<code>prototype</code> 是對類型而言，而 <code>__proto__</code> 對實體而言都相同。</p>
-
-<p><code>__proto__</code> 是以<em>遞歸</em>的方式來看待的，也就是 <code>a1.doSomething</code>、<code>a1.__proto__.doSomething</code>、<code>a1.__proto__.__proto__.doSomething</code> 等等，直到找到或不存在 <code>__proto__ <span style="font-family: Verdana,Tahoma,sans-serif;">為止。</span></code></p>
-
-<p>所以，發生了什麼︰當你呼叫<br>
- <code>  var o = new Foo()</code><br>
- JS 實際上只是這樣做<br>
- <code>  var o = new Object();<br>
-   o.__proto__ = Foo.prototype;<br>
-   o.Foo();</code> （諸如此類）<br>
- <br>
- 以及當你隨後這樣做<br>
- <code>  o.someProp</code><br>
- 他會檢查 <code>o</code> 是否有屬性 <code>someProp</code>，如果沒有就檢查 <code>o.__proto__.someProp</code>，如果沒有就檢查 <code>o.__proto__.__proto__.someProp</code> 依此類推。這個最後的步驟就是 extend() 函數運作的原因。</p>
-
-<p> </p>
-
-<p>注意，<code>__proto__</code> 只能在 Mozilla 的 JS 引撉中存取。其他引撉的也有相同的運作，但不能存取 <code>__proto__</code>。參閱以下內容來補救。</p>
-
-<h2 id="extend()_的另一個選擇" name="extend()_的另一個選擇">extend() 的另一個選擇</h2>
-
-<p>還有另一個選擇，你也可以定義 extend() 如下︰</p>
-
-<pre class="eval">function extend(child, supertype)
-{
-   child.prototype.__proto__ = supertype.prototype;
-   child.prototype.__super = supertype;
-}
-</pre>
-
-<p>因此，當你想要在 <code>B</code> 中呼叫親函數的時候，你可以使用 <code>this.__super</code> 取代 <code>A</code>，例如 <code>this.__super.call(this, a)</code> 用於建構子，以及 <code>this.__super.prototype.doSomething.apply(this, arguments)</code> 用於覆載函數。</p>
-
-<p>注意，<code>__proto__</code> 在 Mozilla 以外的 JavaScript 版本中可能無法使用。還有另一個選擇，但不是 extend() 的最佳版本，這次應該到處都可以用︰</p>
-
-<pre class="eval">function extend(child, super)
-{
-  for (var property in super.prototype) {
-    if (typeof child.prototype[property] == "undefined")
-      child.prototype[property] = super.prototype[property];
-  }
-  return child;
-}
-</pre>
-
-<p>這次簡單的<em>直接</em>把親類型的 prototype 裡所有的屬性和函數，放入到子類型的 prototype 裡。這對多重繼承而言非常有用，但要小心使用，沒有親類別會把屬性或函數定義成同樣的，或者你需要明確的把那些覆載並定義那些該怎麼做。</p>
-
-<h2 id="阻礙" name="阻礙">阻礙</h2>
-
-<p>這裡有另一個方法用來定義類型，例如︰</p>
-
-<pre class="eval">function A()
-{
-  this.varA = "bla";
-  this.isNotSoGood = function()
-  {
-    ...
-  };
-}
-</pre>
-
-<p>這樣也可以運作，但只是次優的選擇，因為每次你建立這個類型的物件的時候，<code>isNotSoGood</code> 會在<strong>每一個實體</strong>中定義一次。如果是在 .prototype 定義這些的話，就只會定義一次。</p>
-
-<p><br>
- 你可以使用下面的方式來繼承︰</p>
-
-<pre class="eval">B.prototype = new A();
-</pre>
-
-<p>不在載入 JS 檔案的時候建立 A() 的實體。這是<strong>非常</strong>壞的點子，因為你可能需要在 A 的建構子裡做一些處理，這可能會耗費時間並因此大幅延遲載入，或嘗試存取尚未載入的東西（例如，在 utils.js 裡的函數）。</p>
-
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的物件:String_物件", "Core_JavaScript_1.5_教學:以類別為基礎的語言_vs._以原型為基礎的語言") }}</p>
-
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Inheritance" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/index.html
deleted file mode 100644
index a9a7200773..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/index.html
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: 職員的例子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子
----
-<h3 id="職員的例子" name="職員的例子">職員的例子</h3>
-<p>本章的剩餘部分會使用如下所示的職員的階層圖。</p>
-<p><img alt="Image:hier01.gif" class="internal" src="/@api/deki/files/708/=Hier01.gif"></p>
-<p><small><strong>圖 8.1: 簡單的物件的階層</strong></small></p>
-<p>本範例使用了下面的物件︰</p>
-<ul>
- <li>Employee 具有 name（其值預設為空字串）以及 dept（其值預設為 "general"）屬性。</li>
- <li>Manager 以 Employee 為基礎。他加入了 reports 屬性（其值預設為空的陣列，打算使用內含 Employee 物件的陣列作為他的值）。</li>
- <li>WorkerBee 也是 Employee 為基礎。他加入了 projects 屬性（其值預設為空的陣列，打算使用字串的陣列作為他的值）。</li>
- <li>SalesPerson 以 WorkerBee 為基礎。他加入了 quota 屬性（其值預設為 100）。他也使用 "sales" 值覆寫了 dept 屬性，指明所有的銷售員都從屬於同一部門。</li>
- <li>Engineer 以 WorkerBee 為基礎。他加入了 machine 屬性（其值預設為空字串），而且也使用 "engineering" 值覆寫了 dept 屬性。</li>
-</ul>
-<p>其餘的範例︰</p>
-<ul>
- <li><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/%E9%9A%8E%E5%B1%A4%E7%9A%84%E5%BB%BA%E7%AB%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/%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" title="zh tw/Core JavaScript 1.5 教學/職員的例子/物件的屬性">物件的屬性</a>
-  <ul>
-   <li><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></li>
-   <li><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%E5%8A%A0%E5%85%A5" title="zh tw/Core JavaScript 1.5 教學/職員的例子/物件的屬性/屬性的加入">屬性的加入</a></li>
-  </ul>
- </li>
- <li><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/%E6%9B%B4%E9%9D%88%E6%B4%BB%E7%9A%84%E5%BB%BA%E6%A7%8B%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/職員的例子/更靈活的建構子">更靈活的建構子</a></li>
-</ul>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:以類別為基礎的語言_vs._以原型為基礎的語言", "Core_JavaScript_1.5_教學:職員的例子:階層的建立") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/更靈活的建構子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/更靈活的建構子/index.html
deleted file mode 100644
index 5f071f0b00..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/更靈活的建構子/index.html
+++ /dev/null
@@ -1,145 +0,0 @@
----
-title: 更靈活的建構子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子/更靈活的建構子
-translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/The_Employee_Example/More_Flexible_Constructors
----
-<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&lt;String&gt; projects;
-   public WorkerBee () {
-      this(new ArrayList&lt;String&gt;());
-   }
-   public WorkerBee (List&lt;String&gt; 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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/index.html
deleted file mode 100644
index 01d23df274..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/index.html
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: 物件的屬性
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子/物件的屬性
----
-<h3 id="物件的屬性" name="物件的屬性">物件的屬性</h3>
-<p>本節討論物件如何從原型鏈上的其他物件來繼承屬性，以及當你在執行時期加入屬性的時候，發生了什麼事。</p>
-<ul>
- <li><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></li>
- <li><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%E5%8A%A0%E5%85%A5" 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> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/屬性的加入/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/屬性的加入/index.html
deleted file mode 100644
index 4d5a456ad4..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/屬性的加入/index.html
+++ /dev/null
@@ -1,19 +0,0 @@
----
-title: 屬性的加入
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子/物件的屬性/屬性的加入
----
-<h3 id="屬性的加入" name="屬性的加入">屬性的加入</h3>
-<p>在 JavaScript 中，你可以在執行時期把屬性加入到任何的物件。你不會受到只能使用由建構子函數提供屬性的限制。若要為特定的單一物件加入屬性，你可以把值代入給物件，如下︰</p>
-<pre>mark.bonus = 3000;
-</pre>
-<p>現在，<code>mark</code> 物件有了額外的屬性，而其他的 <code>WorkerBee</code> 不會有這個屬性。</p>
-<p>如果你把新的屬性加入到已經被用作建構子函數的原型物件裡的話，就會把新的屬性加入到從原型繼承屬性的所有物件裡。例如，你可以使用如下語句把 <code>specialty</code> 屬性加入到所有的職員︰</p>
-<pre>Employee.prototype.specialty = "none";
-</pre>
-<p>JavaScript 一執行這個語句，<code>mark</code> 物件也就會有這個值為 "<code>none</code>" 的 specialty 屬性。下面的圖解顯示出加入這個屬性給 Employee 原型的效果，以及從 <code>Engineer</code> 原型覆蓋這個屬性。</p>
-<p><img alt="Image:hier04.gif" class="internal" src="/@api/deki/files/711/=Hier04.gif"><br>
- <small><strong>圖 8.4: 加入屬性</strong></small></p>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:職員的例子:物件的屬性:屬性的繼承", "Core_JavaScript_1.5_教學:職員的例子:更靈活的建構子") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/屬性的繼承/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/屬性的繼承/index.html
deleted file mode 100644
index fa38245533..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/物件的屬性/屬性的繼承/index.html
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: 屬性的繼承
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子/物件的屬性/屬性的繼承
----
-<h3 id="屬性的繼承" name="屬性的繼承">屬性的繼承</h3>
-<p>假定你以如下語句建立了作為 <code>WorkerBee</code> 的 <code>mark</code> 物件（如同 <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/%E9%9A%8E%E5%B1%A4%E7%9A%84%E5%BB%BA%E7%AB%8B" title="zh tw/Core JavaScript 1.5 教學/職員的例子/階層的建立">圖 8.3</a> 所示）︰</p>
-<pre class="eval">mark = new WorkerBee;
-</pre>
-<p>當 JavaScript 看見 new 運算子的時候，他就會建立新的通用物件，並且把這個新物件當作 <code>this</code> 關鍵字的值傳給 WorkerBee 的建構子函數。建構子函數會明確的設定 <code>projects</code> 屬性的值，並且隱含的把 <code>__proto__</code> 屬性內部的值設定成 <code>WorkerBee.prototype</code> 的值。（這個屬性的名稱前後各有兩個底線字元。）<code>__proto__</code> 屬性決定了用來返回屬性值的原型鏈。這些屬性一經設定，JavaScript 返回新的物件，且代入語句會把變數 <code>mark</code> 設定給這個物件。</p>
-<p>這個過程並不會把 <code>mark</code> 從原型鏈上繼承下來的屬性明確的放置在 <code>mark</code> 物件裡的值（<em>局域</em>值）。當你需要某個屬性值的時候，JavaScript 首先檢查這個值是否存在於物件裡。如果存在，就直接返回這個值。如果這些變數不在局域區塊裡，JavaScript 就會檢查原型鏈（使用 <code>__proto__</code> 屬性）。如果在原型鏈上的物件有這個屬性的值，就會返回這個值。如果找不到這些屬性，JavaScript 會說這個物件並沒有這個屬性。以這種方式，<code>mark</code> 物件就有了如下屬性和值︰</p>
-<pre class="eval">mark.name = "";
-mark.dept = "general";
-mark.projects = [];
-</pre>
-<p><code>mark</code> 物件從 <code>mark.__proto__</code> 裡的原型物件繼承了 name 和 dept 屬性的值。他還藉由 WorkerBee 的建構子給 projects 屬性代入局域值。JavaScript 就這樣達成了屬性和值的繼承。這個過程的部分細節會在 <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" title="zh tw/Core JavaScript 1.5 教學/再談屬性的繼承">再談屬性的繼承</a> 裡討論。</p>
-<p>因為這些建構子並不能讓你傳入特定實體的值，這些資訊是通用的。這些屬性值預設會被所有從 WorkerBee 建立的新物件所共享。當然你也可以修改任何屬性的值。因此，你可以給 <code>mark</code> 特定的資訊如下︰</p>
-<pre class="eval">mark.name = "Doe, Mark";
-mark.dept = "admin";
-mark.projects = ["navigator"];
-</pre>
-<div class="noinclude">
- <p>{{ PreviousNext("Core JavaScript 1.5 教學:職員的例子:物件的屬性", "Core JavaScript 1.5 教學:職員的例子:物件的屬性:屬性的加入") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/階層的建立/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/階層的建立/index.html
deleted file mode 100644
index 3e7a144656..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/職員的例子/階層的建立/index.html
+++ /dev/null
@@ -1,135 +0,0 @@
----
-title: 階層的建立
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/職員的例子/階層的建立
----
-<h3 id="階層的建立" name="階層的建立">階層的建立</h3>
-<p>這裡有一些方式可以定義適當的建構子函數，以實現 Employee 的階層結構。該如何選擇定義這些的方式，主要取決於你希望你的應用程式能做什麼。</p>
-<p>本節展示如何使用非常簡單的（相對來說也比較沒有彈性）定義，以示範繼承是如何運作的。在這些定義中，當你建立物件的時候，你不能指定任何的屬性值。這些新建立的物件會簡單的取得預設值，稍後你就可以修改這些值。圖 8.2 以這些簡單的定義解說了階層結構。</p>
-<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/%E6%9B%B4%E9%9D%88%E6%B4%BB%E7%9A%84%E5%BB%BA%E6%A7%8B%E5%AD%90" title="zh tw/Core JavaScript 1.5 教學/職員的例子/更靈活的建構子">更靈活的建構子</a> 以取得資訊）。現在，這些簡單的定義示範繼承是如何發生的。</p>
-<p><img alt="Image:hier02.gif" class="internal" src="/@api/deki/files/709/=Hier02.gif"><br>
- <small><strong>圖 8.2: Employee 物件的定義</strong></small></p>
-<p>下面 Java 和 JavaScript 的 <code>Employee</code> 定義很類似。唯一的不同點是，在 Java 中，你需要為每一個屬性指定類型，但 JavaScript 不需要。而且你需要為 Java 類別建立明確的建構子方法。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>JavaScript</th>
-   <th>Java</th>
-  </tr>
-  <tr>
-   <td>
-    <pre>
-function Employee () {
-this.name = "";
-this.dept = "general";
-}
-</pre>
-   </td>
-   <td>
-    <pre>
-public class Employee {
-   public String name;
-   public String dept;
-   public Employee () {
-      this.name = "";
-      this.dept = "general";
-   }
-}
-</pre>
-   </td>
-  </tr>
- </tbody>
-</table>
-<p><code>Manager</code> 和 <code>WorkerBee</code> 的定義顯現出在如何指定高於繼承鏈的下一個物件時的不同點。在 JavaScript 中，你把原型實體作為建構子函數的 <code>prototype</code> 屬性的值加了上去。在你定義了建構子以後的任何時間點上，你都可以這麼做。在 Java 中，你只能在類別定義的內部指定親類別。你不能在類別定義的外部改變親類別。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>JavaScript</th>
-   <th>Java</th>
-  </tr>
-  <tr>
-   <td>
-    <pre>
-function Manager () {
-this.reports = [];
-}
-Manager.prototype = new Employee;
-
-function WorkerBee () {
-this.projects = [];
-}
-WorkerBee.prototype = new Employee;
-</pre>
-   </td>
-   <td>
-    <pre>
-public class Manager extends Employee {
-   public Employee[] reports;
-   public Manager () {
-      this.reports = new Employee[0];
-   }
-}
-
-public class WorkerBee extends Employee {
-   public String[] projects;
-   public WorkerBee () {
-      this.projects = new String[0];
-   }
-}
-</pre>
-   </td>
-  </tr>
- </tbody>
-</table>
-<p><code>Engineer</code> 和 <code>SalesPerson</code> 的定義所建立的物件是傳承自 <code>WorkerBee</code> 以及 <code>Employee</code>。這些類型的物件具有在鏈上比他高層的所有物件的屬性。此外，定義中還使用指定給這些物件的新值來覆蓋被繼承的 <code>dept</code> 屬性的值。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>JavaScript</th>
-   <th>Java</th>
-  </tr>
-  <tr>
-   <td>
-    <pre>
-function SalesPerson () {
-   this.dept = "sales";
-   this.quota = 100;
-}
-SalesPerson.prototype = new WorkerBee;
-
-function Engineer () {
-   this.dept = "engineering";
-   this.machine = "";
-}
-Engineer.prototype = new WorkerBee;
-</pre>
-   </td>
-   <td>
-    <pre>
-public class SalesPerson extends WorkerBee {
-   public double quota;
-   public SalesPerson () {
-      this.dept = "sales";
-      this.quota = 100.0;
-   }
-}
-
-public class Engineer extends WorkerBee {
-   public String machine;
-   public Engineer () {
-      this.dept = "engineering";
-      this.machine = "";
-   }
-}
-</pre>
-   </td>
-  </tr>
- </tbody>
-</table>
-<p>使用這些定義，你可以建立這些物件的實體，同時實體也為他們的屬性取得預設值。圖 8.3 解說使用這些 JavaScript 定義來建立新的物件，並顯示新物件的屬性值。</p>
-<p><strong>附註:</strong> 術語<em>實體（instance）</em>在以類別為基礎的語言中有特定的技術含義。在這些語言中，實體就是類別的獨立成員，而且在根本上就有別於類別。在 JavaScript 中，〝實體〞並沒有這些技術含義，因為 JavaScript 並沒有類別和實體的分別。然而，在談到 JavaScript 的時候，〝實體〞也可以在通俗上用來指，使用實際的建構子函數建立的物件。因此，在這些範例中，你也可以通俗的說 <code>jane</code> 是 <code>Engineer</code> 的實體。類似的，儘管術語 <em>親（parent）、子（child）、祖先（ancestor）</em>、<em>子孫（descendant）</em>在 JavaScript 中並沒有正式的含義；你也可以隨俗的使用這些術語，來談論在原型鏈中較高或較低的某個物件。</p>
-<p><img alt="Image:hier03.gif" class="internal" src="/@api/deki/files/710/=Hier03.gif"><br>
- <span style="font-weight: bold;">圖</span><small><strong> 8.3: 使用簡單的定義來建立物件</strong></small></p>
-<div class="noinclude">
- <p>{{ PreviousNext("Core_JavaScript_1.5_教學:職員的例子", "Core_JavaScript_1.5_教學:職員的例子:物件的屬性") }}</p>
-</div>
-<p> </p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/表達式/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/表達式/index.html
deleted file mode 100644
index 0d694e88f8..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/表達式/index.html
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: 表達式
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/表達式
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Expressions
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/註解/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/註解/index.html
deleted file mode 100644
index 1e922b72f2..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/註解/index.html
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: 註解
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/註解
-translation_of: Web/JavaScript/Guide/Control_flow_and_error_handling
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Comments
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/變數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/變數/index.html
deleted file mode 100644
index 151736f40c..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/變數/index.html
+++ /dev/null
@@ -1,57 +0,0 @@
----
-title: 變數
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/變數
-translation_of: Web/JavaScript/Guide/Grammar_and_types
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Variables
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/迭代器和產生器/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/迭代器和產生器/index.html
deleted file mode 100644
index 21029266db..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/迭代器和產生器/index.html
+++ /dev/null
@@ -1,293 +0,0 @@
----
-title: 迭代器和產生器
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/迭代器和產生器
----
-<h3 id="迭代器和產生器" name="迭代器和產生器">迭代器和產生器</h3>
-
-<p>處理集合中的每一項是很常見的操作。JavaScript 提供了許多迭代整個集合的方式，從簡單的 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for" title="zh tw/Core JavaScript 1.5 參考/語法/for">for</a></code> 和 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for_each...in" title="zh tw/Core JavaScript 1.5 參考/語法/for each...in">for each</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%E7%89%A9%E4%BB%B6/Array/map" title="zh tw/Core JavaScript 1.5 參考/全域物件/Array/map">map</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%E7%89%A9%E4%BB%B6/Array/filter" title="zh tw/Core JavaScript 1.5 參考/全域物件/Array/filter">filter</a>()</code> 以及 <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>。迭代器和產生器是在 JavaScript 1.7 引入的，帶來在核心語言中直接迭代的觀念，並提供自訂 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for...in" title="zh tw/Core JavaScript 1.5 參考/語法/for...in">for...in</a></code> 和 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for_each...in" title="zh tw/Core JavaScript 1.5 參考/語法/for each...in">for each</a></code> 循環的行為的機制。</p>
-
-<div class="note"><strong>附注:</strong> <code>yield</code> 關鍵字只能在 HTML 裡包有 <code>&lt;script type="application/javascript;version=1.7"&gt;</code> 區塊（或更高的版本）的代碼區塊中使用。 <a class="internal" href="/zh_tw/XUL" title="zh tw/XUL">XUL</a> Script 標記可以存取這些功能，無須這個特別的區塊。</div>
-
-<h4 id="迭代器" name="迭代器">迭代器</h4>
-
-<p>迭代器（Iterator）是一種知道如何從集合裡每次以同樣的方式存取項目的物件。並保持對自己序列內部的目前位置的追蹤。在 JavaScript 中，迭代器是一種提供有能夠返回序列中的下一項的 <code>next()</code> 方法的物件。這個方法可以在序列用盡時，選擇性的出現 <code>StopIteration</code> 例外。</p>
-
-<p>迭代器物件一經建立以後，可以明確的反覆呼叫 <code>next()</code> 來使用，或隱含的使用 JavaScript 的 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for...in" title="zh tw/Core JavaScript 1.5 參考/語法/for...in">for...in</a></code> 和 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for_each...in" title="zh tw/Core JavaScript 1.5 參考/語法/for each...in">for each</a></code> 結構。</p>
-
-<p>可以使用 <code>Iterator()</code> 函數來為物件和陣列建立簡單的迭代器︰</p>
-
-<pre class="eval">var lang = { name: 'JavaScript', birthYear: 1995 };
-var it = Iterator(lang);
-</pre>
-
-<p>一經初始化以後，就可以呼叫 <code>next()</code> 方法依序從物件中存取鍵值對（key-value pair）︰</p>
-
-<pre class="eval">var pair = it.next(); // 鍵值對是 ["name", "JavaScript"]
-pair = it.next(); // 鍵值對是 ["birthYear", 1995]
-pair = it.next(); // 拋出 StopIteration 例外
-</pre>
-
-<p>可以使用 <code><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E5%8F%83%E8%80%83/%E8%AA%9E%E6%B3%95/for...in" title="zh tw/Core JavaScript 1.5 參考/語法/for...in">for...in</a></code> 循環來取代直接呼叫 <code>next()</code> 方法。循環會在 <code>StopIteration</code> 例外出現的時候自動終止。</p>
-
-<pre class="eval">var it = Iterator(lang);
-for (var pair in it)
-  print(pair); // 依序輸出每一個 [key, value] 對
-</pre>
-
-<p>如果我們只想要迭代物件的鍵（key），我們可以把第二個參數 <code>true</code> 傳給 <code>Iterator()</code> 函數︰</p>
-
-<pre class="eval">var it = Iterator(lang, true);
-for (var key in it)
-  print(key); // 依序輸出每一個鍵
-</pre>
-
-<p>使用 <code>Iterator()</code> 存取物件內容的其中一個好處是已經加入到 <code>Object.prototype</code> 的自訂屬性不會被包含在序列裡。</p>
-
-<p><code>Iterator()</code> 也可以和陣列一起使用︰</p>
-
-<pre class="eval">var langs = ['JavaScript', 'Python', 'C++'];
-var it = Iterator(langs);
-for (var pair in it)
-  print(pair); // 依序輸出每一個 [index, language] 對
-</pre>
-
-<p>如同物件一般，傳入 <code>true</code> 作為第二個參數，將導致迭代出存在於陣列裡的索引︰</p>
-
-<pre class="eval">var langs = ['JavaScript', 'Python', 'C++'];
-var it = Iterator(langs, true);
-for (var i in it)
-  print(i); // 輸出 0，然後是 1，然後是 2
-</pre>
-
-<p>他也可以把 for 循環內部使用的 <code>let</code> 關鍵字的索引和值兩者，代入給區塊作用域的變數，並分割代入︰</p>
-
-<pre class="eval">var langs = ['JavaScript', 'Python', 'C++'];
-var it = Iterator(langs);
-for (let [i, lang] in it)
- print(i + ': ' + lang); // 輸出 "0: JavaScript" 等等。
-</pre>
-
-<h4 id="自訂的迭代器的定義" name="自訂的迭代器的定義">自訂的迭代器的定義</h4>
-
-<p>有一些物件所表示的集合項，應該以特定的方式來迭代。</p>
-
-<ul>
- <li>迭代物件的某一範圍，應該一個接著一個返回範圍內的數字。</li>
- <li>可以使用深度優先或廣度優先的遍歷法來遊覽樹裡的葉項。</li>
- <li>表示來自資料庫的查詢結果的物件的迭代，應該一行接著一行返回，即使整份結果尚未完全載入到單一的陣列。</li>
- <li>無限長的數學序列（如費伯納契數列）的迭代，應該要能夠一個接著一個返回，而無須建立無限長的資料結構。</li>
-</ul>
-
-<p>JavaScript 可讓你編寫表示自訂迭代器邏輯的代碼，並把他連結到物件上。</p>
-
-<p>我們將會建立簡單的 <code>Range</code> 物件，這個物件存放了 low 和 high 值。</p>
-
-<pre class="eval">function Range(low, high)
-{
-  this.low = low;
-  this.high = high;
-}
-</pre>
-
-<p>現在我們將會建立自訂的迭代器，使其返回包含在某一範圍內的整數序列。迭代器的界面必須要有由我們提供的 <code>next()</code> 方法，這個方法會返回來自序列的某一項，或拋出 <code>StopIteration</code> 例外。</p>
-
-<pre class="eval">function RangeIterator(range)
-{
-  this.range = range;
-  this.current = this.range.low;
-}
-RangeIterator.prototype.next = function()
-{
-  if (this.current &gt; this.range.high)
-    throw StopIteration;
-  var current = this.current;
-  this.current += 1;
-  return current;
-};
-</pre>
-
-<p>我們的 <code>RangeIterator</code> 就是有範圍限制的實體的實際例子，並維護他自己的 <code>current</code> 屬性用以追蹤他沿著序列已走了多遠。</p>
-
-<p>最後，把我們的 <code>RangeIterator</code> 和 <code>Range</code> 物件連繫在一起，我們需要加入特別的 <code>__iterator__</code> 方法給 <code>Range</code>。這個方法會在當我們試圖迭代 <code>Range</code> 實體的時候呼叫，而且應該會返回 <code>RangeIterator</code> 的實體，這個實體實裝了迭代器的邏輯。</p>
-
-<pre class="eval">Range.prototype.__iterator__ = function()
-{
-  return new RangeIterator(this);
-};
-</pre>
-
-<p>掛在我們自訂的迭代器以後，我們可以迭代實體的某一範圍內，如下︰</p>
-
-<pre class="eval">var range = new Range(3, 5);
-for (var i in range)
-  print(i); // 輸出序列中的 3，然後是 4，然後是 5
-</pre>
-
-<h4 id="產生器︰建構迭代器的較佳方式" name="產生器︰建構迭代器的較佳方式">產生器︰建構迭代器的較佳方式</h4>
-
-<p>儘管自訂的迭代器是很好用的工具，但在建立時的程式設計必須要很謹慎，因為需要明確的維護他們的內部狀態。產生器（Generator）提供另一種更強大的選擇︰可讓你編寫能夠維護自身狀態的單一函數來定義迭代器的演算法。</p>
-
-<p>產生器是一種特殊類型的函數，他的運作方式類似迭代器的生產廠房。只要函數內含有一個以上的 <code>yield</code> 語句，就會變成產生器。</p>
-
-<p>當產生器函數被呼叫的時候，並不會立即執行函數的本體；取而代之的是，他會返回產生器迭代器（generator-iterator）物件。每次呼叫產生器迭代器的 <code>next()</code> 方法，就會執行函數本體直到下一個 <code>yield</code> 語句，並返回他的結果。如果執行到函數的末端或到達 <code>return</code> 語句，就會拋出 <code>StopIteration</code> 例外。</p>
-
-<p>配合例子是最佳的說明︰</p>
-
-<pre class="eval">function simpleGenerator()
-{
-  yield "first";
-  yield "second";
-  yield "third";
-  for (var i = 0; i &lt; 3; i++)
-    yield i;
-}
-
-var g = simpleGenerator();
-print(g.next()); // 輸出 "first"
-print(g.next()); // 輸出 "second"
-print(g.next()); // 輸出 "third"
-print(g.next()); // 輸出 0
-print(g.next()); // 輸出 1
-print(g.next()); // 輸出 2
-print(g.next()); // 拋出 StopIteration
-</pre>
-
-<p>產生器函數可以像類別的 <code>__iterator__</code> 方法一般直接的使用，大幅減少建立自訂的迭代器的代碼量。這裡是我們的 <code>Range</code>，使用產生器重新編寫︰</p>
-
-<pre class="eval">function Range(low, high)
-{
-  this.low = low;
-  this.high = high;
-}
-Range.prototype.__iterator__ = function()
-{
-  for (var i = this.low; i &lt;= this.high; i++)
-    yield i;
-};
-var range = new Range(3, 5);
-for (var i in range)
-  print(i); // 輸出序列中的 3，然後是 4，然後是 5
-</pre>
-
-<p>並不是所有的產生器都會終止；有可能建立出表示無限序列的產生器。下面的產生器實裝了費伯納契數列，每一個元素都是前面兩個元素的合︰</p>
-
-<pre class="eval">function fibonacci()
-{
-  var fn1 = 1;
-  var fn2 = 1;
-  while (1)
-  {
-    var current = fn2;
-    fn2 = fn1;
-    fn1 = fn1 + current;
-    yield current;
-  }
-}
-
-var sequence = fibonacci();
-print(sequence.next()); // 1
-print(sequence.next()); // 1
-print(sequence.next()); // 2
-print(sequence.next()); // 3
-print(sequence.next()); // 5
-print(sequence.next()); // 8
-print(sequence.next()); // 13
-</pre>
-
-<p>產生器函數可以接受參數，這個參數是用來約束第一次被呼叫的函數。產生器可以使用 <code>return</code> 語句來終止（並導致 <code>StopIteration</code> 例外的出現）。下面的 <code>fibonacci()</code> 變體接受選用性的 limit 參數，一旦通過限制就會終止。</p>
-
-<pre class="eval">function fibonacci(limit)
-{
-  var fn1 = 1;
-  var fn2 = 1;
-  while (1)
-  {
-    var current = fn2;
-    fn2 = fn1;
-    fn1 = fn1 + current;
-    <strong>if (limit &amp;&amp; current &gt; limit)</strong>
-      <strong>return;</strong>
-    yield current;
-  }
-}
-</pre>
-
-<h4 id="高階的產生器" name="高階的產生器">高階的產生器</h4>
-
-<p>產生器會計算出要求他們產生的值，這可讓產生器更有效率的表示需要耗費大量計算的序列，甚至是上面示範的無窮數列。</p>
-
-<p>除了 <code>next()</code> 方法以外，產生器迭代器物件還有 <code>send()</code> 方法，可以用來修改產生器的內部狀態。傳遞給 <code>send()</code> 的值將會被視為中止產生器的最後一個 <code>yield</code> 語句的結果。在你可以使用 <code>send()</code> 來傳送指定的值之前，你必須至少呼叫一次 <code>next()</code> 來啟動產生器。</p>
-
-<p>這裡是使用 <code>send()</code> 來重新開始數列的費伯納契數產生器︰</p>
-
-<pre>function fibonacci()
-{
-  var fn1 = 1;
-  var fn2 = 1;
-  while (1)
-  {
-    var current = fn2;
-    fn2 = fn1;
-    fn1 = fn1 + current;
-    <strong>var reset = yield current;
-    if (reset){
-        fn1 = 1;
-        fn2 = 1;
-    }</strong>
-  }
-}
-
-var sequence = fibonacci();
-print(sequence.next());     // 1
-print(sequence.next());     // 1
-print(sequence.next());     // 2
-print(sequence.next());     // 3
-print(sequence.next());     // 5
-print(sequence.next());     // 8
-print(sequence.next());     // 13
-<strong>print(sequence.send(true)); // 1</strong>
-print(sequence.next());     // 1
-print(sequence.next());     // 2
-print(sequence.next());     // 3</pre>
-
-<div class="note"><strong>附注:</strong> 作為有趣的一點，呼叫 <code>send(undefined)</code> 就相當於呼叫 <code>next()</code>。然而，使用除了 undefined 以外的任意值啟動新生的產生器，在呼叫 <code>send()</code> 的時候，將會引起 <code>TypeError</code> 例外。</div>
-
-<p>你可以藉由呼叫產生器的 <code>throw()</code> 方法，並傳入他應該拋出的例外值，強迫產生器拋出例外。例外將會從目前被中止的產生器的位置拋出例外，就如同目前被中止的 <code>yield</code> 被替換成 <code>throw <em>value</em></code> 語句一樣。</p>
-
-<p>如果在拋出例外的處理期間沒有遇到 yield，然後例外將會不斷傳播直到呼叫 <code>throw()</code>，且隨後呼叫 <code>next()</code> 將導致 <code>StopIteration</code> 被拋出。</p>
-
-<p>產生器有可以強迫關閉他自己的 <code>close()</code> 方法。關閉產生器的效果是︰</p>
-
-<ol>
- <li>執行所有在產生器函數裡的 <code>finally</code> 子句。</li>
- <li>如果 <code>finally</code> 子句拋出除了 <code>StopIteration</code> 以外的任何例外，例外會被傳播到 <code>close()</code> 方法的呼叫者。</li>
- <li>產生器終止。</li>
-</ol>
-
-<h4 id="產生器的表達式" name="產生器的表達式">產生器的表達式</h4>
-
-<p>陣列簡約式主要的缺點是他們會造成在記憶體中建構出完整的新陣列。如果輸入的簡約式本身是小型的陣列其開銷還不明顯 - 但如果輸入的是大型的陣列或耗費資源（甚至是無限大）的產生器，新陣列的建立就會產生問題。</p>
-
-<p>產生器能夠延後計算他們要求的所需計算的項的序列。<em>產生器表達式</em>在語法上幾乎等同於 <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>
-
-<p>假設我們有一個迭代器 <code>it</code> 可以迭代出大型的整數序列。我們想要建立可以迭代出雙倍的新迭代器。陣列簡約式會在記憶體中建立含有雙倍值的完整的陣列︰</p>
-
-<pre class="eval">var doubles = [i * 2 for (i in it)];
-</pre>
-
-<p>產生器表達式一方面會建立新的迭代器，能夠建立他們所需的雙倍值︰</p>
-
-<pre class="eval">var it2 = (i * 2 for (i in it));
-print(it2.next()); // 來自 it 的第一個值，雙倍
-print(it2.next()); // 來自 it 的第二個值，雙倍</pre>
-
-<p>如果把產生器表達式當作參數傳給函數，函數呼叫所使用的圓括弧意味著可以省略外部的圓括弧︰</p>
-
-<pre class="eval">var result = doSomething(i * 2 for (i in it));
-</pre>
-
-<p> </p>
-
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:陣列的運用", "Core_JavaScript_1.5_教學:物件模型的細節") }}</p>
-
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Iterators_and_Generators" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/index.html
deleted file mode 100644
index 5c6eb2fb16..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/index.html
+++ /dev/null
@@ -1,30 +0,0 @@
----
-title: 運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators
----
-<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>&lt;&lt;  &gt;&gt;  &gt;&gt;&gt;</td> </tr> <tr> <td>關係</td> <td>&lt;  &lt;=  &gt;  &gt;=  in  instanceof</td> </tr> <tr> <td>等價</td> <td>==  !=  ===  !==</td> </tr> <tr> <td>位元 AND</td> <td>&amp;</td> </tr> <tr> <td>位元 XOR</td> <td>^</td> </tr> <tr> <td>位元 OR</td> <td>|</td> </tr> <tr> <td>邏輯 AND</td> <td>&amp;&amp;</td> </tr> <tr> <td>邏輯 OR</td> <td>||</td> </tr> <tr> <td>條件</td> <td>?:</td> </tr> <tr> <td>代入</td> <td>=  +=  -=  *=  /=  %=  &lt;&lt;=  &gt;&gt;=  &gt;&gt;&gt;=  &amp;=  ^=  |=</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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/代入運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/代入運算子/index.html
deleted file mode 100644
index 31b103c23f..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/代入運算子/index.html
+++ /dev/null
@@ -1,65 +0,0 @@
----
-title: 代入運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/代入運算子
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Comparison_Operators
----
-<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 &lt;&lt;= y</td>
-   <td>x = x &lt;&lt; y</td>
-  </tr>
-  <tr>
-   <td>x &gt;&gt;= y</td>
-   <td>x = x &gt;&gt; y</td>
-  </tr>
-  <tr>
-   <td>x &gt;&gt;&gt;= y</td>
-   <td>x = x &gt;&gt;&gt; y</td>
-  </tr>
-  <tr>
-   <td>x &amp;= y</td>
-   <td>x = x &amp; 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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/位元運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/位元運算子/index.html
deleted file mode 100644
index 6109b2d6e3..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/位元運算子/index.html
+++ /dev/null
@@ -1,31 +0,0 @@
----
-title: 位元運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/位元運算子
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Bitwise_Operators
----
-<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 &amp; 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 &lt;&lt; b</code></td> <td>往左移動 a 的二進制表示法 b 位元，從右邊補 0。</td> </tr> <tr> <td>維持符號右移</td> <td><code>a &gt;&gt; b</code></td> <td>往右移動 a 的二進制表示法 b 位元，丟棄移出的位元。</td> </tr> <tr> <td>填 0 右移</td> <td><code>a &gt;&gt;&gt; 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 &amp; 9 的結果是 9 (1111 &amp; 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>&lt;&lt;（左移）</td> <td>這個運算子把第一個運算元向左移動指定的位元數。丟棄向左移出的多餘位元。從右邊填補 0 的位元。</td> <td>9&lt;&lt;2 的結果是 36，因為 1001 向左移動 2 位元而變成 100100，此即 36。</td> </tr> <tr> <td>&gt;&gt;（維持符號右移）</td> <td>這個運算子把第一個運算元向右移動指定的位元數。丟棄向右移出的多餘位元。從左邊填補在最左邊複製的位元。</td> <td>9&gt;&gt;2 的結果是 2，因為 1001 向右移動 2 位元而變成 10，此即 2。同樣的，-9&gt;&gt;2 的結果是 -3，因為保留了正負號。</td> </tr> <tr> <td>&gt;&gt;&gt;（填 0 右移）</td> <td>這個運算子把第一個運算元向右移動指定的位元數。丟棄向右移出的多餘位元。從右邊填補 0 的位元。</td> <td>19&gt;&gt;&gt;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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/字串運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/字串運算子/index.html
deleted file mode 100644
index 0589aefd73..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/字串運算子/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: 字串運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/字串運算子
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/String_Operators
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/比較運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/比較運算子/index.html
deleted file mode 100644
index 2ce01c1501..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/比較運算子/index.html
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: 比較運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/比較運算子
----
-<p> </p>
-<h3 id="比較運算子" name="比較運算子">比較運算子</h3>
-<p><span class="comment">This seems to me kind of poorly explained, mostly the diference betwen "==" and "==="...</span>比較運算子比較他的運算元，並根據比較是否為真的結果返回邏輯值。運算元可以是數值、字串、邏輯或物件的值。字串是以 Unicode 的值作為標準的字典順序來比較。在大多數情況下，如果兩個運算元不是同樣的類型，JavaScript 會為了比較而嘗試把運算元轉換為適當的類型。（本規則的唯一例外是 <code>===</code> 和 <code>!==</code>，他會進行“嚴格的”相等性和不相等性的檢查，且在檢查等相性之前，並不會把運算元轉換為相容的類型。）通常以數值進行比較。下表以範例代碼解明比較運算子︰</p>
-<pre class="eval">var var1 = 3, var2 = 4;
-</pre>
-<table class="fullwidth-table"> <tbody> <tr> <th>運算子</th> <th>說明</th> <th>返回 true 的範例</th> </tr> <tr> <td>等於 (==)</td> <td>運算元相等時，返回 true。</td> <td><code>3 == var1</code><br> <p><code>"3" == var1</code></p> <code>3 == '3'</code></td> </tr> <tr> <td>不等於 (!=)</td> <td>運算元不相等時，返回 true。</td> <td><code>var1 != 4<br> var2 != "3"</code></td> </tr> <tr> <td>嚴格的等於 (===)</td> <td>運算元相等且類型相同時，返回 true。</td> <td><code>3 === var1</code></td> </tr> <tr> <td>嚴格的不等於 (!==)</td> <td>運算元不相等或類型不相同時，返回 true。</td> <td><code>var1 !== "3"<br> 3 !== '3'</code></td> </tr> <tr> <td>大於 (&gt;)</td> <td>左邊的運算元大於右邊的運算元時，返回 true。</td> <td><code>var2 &gt; var1<br> "12" &gt; 2</code></td> </tr> <tr> <td>大於或等於 (&gt;=)</td> <td>左邊的運算元大於或等於右邊的運算元時，返回 true。</td> <td><code>var2 &gt;= var1<br> var1 &gt;= 3</code></td> </tr> <tr> <td>小於 (&lt;)</td> <td>左邊的運算元小於右邊的運算元時，返回 true。</td> <td><code>var1 &lt; var2<br> "12" &lt; "2"</code></td> </tr> <tr> <td>小於或等於 (&lt;=)</td> <td>左邊的運算元小於或等於右邊的運算元時，返回 true。</td> <td><code>var1 &lt;= var2<br> var2 &lt;= 5</code></td> </tr> </tbody>
-</table>
-<p><small><strong>表 3.3: 比較運算子</strong></small></p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:Operators:代入運算子", "Core_JavaScript_1.5_教學:運算子:算術運算子") }}</p>
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Operators/Comparison_Operators", "es": "es/Gu\u00eda_JavaScript_1.5/Operadores/Operadores_de_comparaci\u00f3n", "fr": "fr/Guide_JavaScript_1.5/Op\u00e9rateurs/Op\u00e9rateurs_de_comparaison", "ja": "ja/Core_JavaScript_1.5_Guide/Operators/Comparison_Operators", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Operatory/Operatory_por\u00f3wnania" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/特殊運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/特殊運算子/index.html
deleted file mode 100644
index a37ea47e50..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/特殊運算子/index.html
+++ /dev/null
@@ -1,186 +0,0 @@
----
-title: 特殊運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/特殊運算子
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Special_Operators
----
-<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 &gt;= 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 &lt;= 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 &lt; lowval) || (obj.value &gt; hival))
-      alert("Invalid Value!")
-}
-</pre>
-<p>你可以在每一個表單元素的 <code>onChange</code> 事件處理器中呼叫 <code>validate</code>，並使用 <code>this</code> 傳送表單元素，如下範例︰</p>
-<pre>&lt;B&gt;Enter a number between 18 and 99:&lt;/B&gt;
-&lt;INPUT TYPE = "text" NAME = "age" SIZE = 3
-   onChange="validate(this, 18, 99)"&gt;
-</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>&lt;FORM NAME="myForm"&gt;
-Form name:&lt;INPUT TYPE="text" NAME="text1" VALUE="Beluga"&gt;
-&lt;P&gt;
-&lt;INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
-   onClick="this.form.text1.value=this.form.name"&gt;
-&lt;/FORM&gt;
-</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>&lt;A HREF="javascript:void(0)"&gt;Click here to do nothing&lt;/A&gt;
-</pre>
-<p>以下代碼建立了超連結，當使用者點擊時，就傳送表單。</p>
-<pre>&lt;A HREF="javascript:void(document.form.submit())"&gt;
-Click here to submit&lt;/A&gt;
-</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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/算術運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/算術運算子/index.html
deleted file mode 100644
index e00a0e612b..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/算術運算子/index.html
+++ /dev/null
@@ -1,20 +0,0 @@
----
-title: 算術運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/算術運算子
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Arithmetic_Operators
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/邏輯運算子/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/邏輯運算子/index.html
deleted file mode 100644
index 7ba467a3cf..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/運算子/邏輯運算子/index.html
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: 邏輯運算子
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/運算子/邏輯運算子
-translation_of: Web/JavaScript/Guide/Expressions_and_Operators
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Operators/Logical_Operators
----
-<p> </p>
-<h3 id="邏輯運算子" name="邏輯運算子">邏輯運算子</h3>
-<p>邏輯運算子通常和布林（邏輯）值一起使用，並返回布林值。然而，&amp;&amp; 和 || 運算子實際上返回的是指定的運算元的其中一個的值，所以如果這些運算子與非布林值一起使用，有可能返回非布林值。邏輯運算子的說明如下表。</p>
-<table class="fullwidth-table"> <tbody> <tr> <th>運算子</th> <th>用法</th> <th>說明</th> </tr> <tr> <td>&amp;&amp;</td> <td>expr1 &amp;&amp; expr2</td> <td>（邏輯 AND）如果 expr1 可以轉換為 false，就返回 expr1。否則返回 expr2。所以，當使用於布林值時，如果兩個運算元都為 true，&amp;&amp; 返回 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>以下代碼為 &amp;&amp;（邏輯 AND）運算子的範例。</p>
-<pre>a1=true &amp;&amp; true       // t &amp;&amp; t 返回 true
-a2=true &amp;&amp; false      // t &amp;&amp; f 返回 false
-a3=false &amp;&amp; true      // f &amp;&amp; t 返回 false
-a4=false &amp;&amp; (3 == 4)  // f &amp;&amp; f 返回 false
-a5="Cat" &amp;&amp; "Dog"     // t &amp;&amp; t 返回 Dog
-a6=false &amp;&amp; "Cat"     // f &amp;&amp; t 返回 false
-a7="Cat" &amp;&amp; false     // t &amp;&amp; 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> &amp;&amp; <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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/閉包的運用/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/閉包的運用/index.html
deleted file mode 100644
index 0e0905730f..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/閉包的運用/index.html
+++ /dev/null
@@ -1,227 +0,0 @@
----
-title: 閉包的運用
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/閉包的運用
----
-<h3 id="閉包的運用" name="閉包的運用">閉包的運用</h3>
-<p>閉包（Closure）經常會被認為是 JavaScript 的高級機能，但了解閉包是精通語言的必要之事。</p>
-<p>思考以下的函數︰</p>
-<pre class="brush: js">function init() {
-  var name = "Mozilla";
-  function displayName() {
-    alert(name);
-  }
-  displayName();
-}
-</pre>
-<p><code>init()</code> 函數建立了稱為 <code>name</code> 的局域變數，然後定義了稱為 <code>displayName()</code> 的函數。<code>displayName()</code> 是內部的函數 - 他是在 <code>init()</code> 內部定義的，而且只在函數本體內部才可使用。<code>displayName()</code> 沒有他自己的局域變數，但會重複使用在外部函數裡所宣告的 name 變數。</p>
-<p>本例只會做一點事 - 試試執行代碼看會發生什麼。這是<em>詞彙作用域</em>的範例︰在 JavaScript 中，變數的作用域是由他自己在原始碼中的位置所定義的，且內部的函數能夠存取宣告於外部作用域的變數。</p>
-<p>現在思考下例︰</p>
-<pre class="brush: js">function makeFunc() {
-  var name = "Mozilla";
-  function displayName() {
-    alert(name);
-  }
-  return displayName;
-}
-
-var myFunc = makeFunc();
-myFunc();
-</pre>
-<p>如果你執行這個代碼，將會發生和前一個 <code>init()</code> 例子完全相同的效果︰字串 "Mozilla" 將會被顯示在 JavaScript 的警告方框中。其中的不同點 - 以及有趣的一點 - 是內部的 <code>displayName()</code> 函數會在執行之前從外部的函數所返回。</p>
-<p>代碼的運作看起來也許很不直覺。通常說，在函數內部的局域變數只存在於函數執行的期間。一旦 <code>makeFunc()</code> 執行完畢，預期不再需要 name 變數是很合理的。由於代碼仍舊以預期般的運作，很明顯情況並不如此。</p>
-<p>對於這個難題的解答是 <code>myFunc</code> 已經變成<em>閉包</em>了。閉包是一種特殊的物件，其中結合了兩樣東西︰函數，和函數所建立的環境。環境由任意的局域變數所組成，這些變數是由在閉包建立的時間點上存在於作用域裡的所有變數。既然如此，<code>myFunc</code> 就是結合了 <code>displayName</code> 函數和閉包建立之後就存在的 "Mozilla" 字串這兩者的閉包。</p>
-<p>這裡還有更為有趣的範例 - <code>makeAdder</code> 函數︰</p>
-<pre class="brush: js">function makeAdder(x) {
-  return function(y) {
-    return x + y;
-  };
-}
-
-var add5 = makeAdder(5);
-var add10 = makeAdder(10);
-
-print(add5(2));  // 7
-print(add10(2)); // 12
-</pre>
-<p>在這個範例中，我們已經定義了函數 <code>makeAdder(x)</code>，可接受單一參數 <code>x</code>，並返回新的函數。返回的函數會接受單一參數 <code>y</code>，並返回 <code>x</code> 和 <code>y</code> 的合。</p>
-<p>就本質而言，<code>makeAdder</code> 是函數的製造機 - 他會建立可以把指定的值和他們的參數相加的函數。在上例中，我們使用了我們的函數製造機來建立兩個新的函數 - 一個給他自己的參數加上 5，另一個則加上 10。</p>
-<p><code>add5</code> 和 <code>add10</code> 兩個都是閉包。他們共享相同的函數本體的定義，但保存了不同的環境變數。在 <code>add5</code> 的環境中，<code>x</code> 是 5。至於互有關連的 <code>add10</code>，<code>x</code> 是 10。</p>
-<h4 id="Practical_closures" name="Practical_closures">實用的閉包</h4>
-<p>該是拋開理論的時候了 - 但是閉包真的有用嗎？讓我們思考閉包潛在的用處。閉包讓你把一些資料（環境）和可操作資料的函數聯繫在一起。這一點明顯和物件導向程式設式並行不悖，物件可讓我們把一些資料（物件的屬性）和一個以上的方法聯繫在一起。</p>
-<p>因此，如果通常你會在某個地方使用附有單一方法的物件，你可以在這些地方使用閉包。</p>
-<p>視情況你可能會想這樣做，這在 Web 上尤其常見。我們寫在 Web 上的 JavaScript 代碼多半是以事件為基礎 - 我們定義了一些行為，然後把這些行為和由使用者所觸發的事件（如 click 或 keypress）連繫在一起。我們的代碼通常被連繫為 Callback︰在回應事件時，所執行的單一函數。</p>
-<p>這裡有個實際的例子︰假如我們希望在頁面上加入可以調整頁面文字的按鈕。以像素為單位，指定 body 元素的 font-size 是一個方法，然後以 em 為單位，設定在頁面上（如頁眉）的其他元素的大小︰</p>
-<pre class="brush: css">body {
-  font-family: Helvetica, Aria, sans-serif;
-  font-size: 12px;
-}
-
-h1 {
-  font-size: 1.5em;
-}
-h2 {
-  font-size: 1.2em;
-}
-</pre>
-<p>我們的互動式文字大小按鈕可以改變 body 元素的 font-size 屬性，拜相對單位之賜，接著對其他的元素做調整。</p>
-<p>JavaScript 代碼︰</p>
-<pre class="brush: js">function makeSizer(size) {
-  return function() {
-    document.body.style.fontSize = size + 'px';
-  };
-}
-
-var size12 = makeSizer(12);
-var size14 = makeSizer(14);
-var size16 = makeSizer(16);
-</pre>
-<p>現在 <code>size12</code>、<code>size14</code> 和 <code>size16</code> 這些函數可分別調整 body 文字的大小為 12、14 和 16 像素。我們可以把代碼和按鈕（本例中使用的是連結）連繫在一起，如下︰</p>
-<pre class="brush: js">function setupButtons() {
-  document.getElementById('size-12').onclick = size12;
-  document.getElementById('size-14').onclick = size14;
-  document.getElementById('size-16').onclick = size16;
-}</pre>
-<pre class="brush: html">&lt;a href="#" id="size-12"&gt;12&lt;/a&gt;
-&lt;a href="#" id="size-14"&gt;14&lt;/a&gt;
-&lt;a href="#" id="size-16"&gt;16&lt;/a&gt;
-</pre>
-<p> </p>
-<h4 id="Emulating_private_methods_with_closures" name="Emulating_private_methods_with_closures">使用閉包模擬私有的方法</h4>
-<p>像 Java 這類語言可以把方法宣告為私有的，意思是這些方法只能被同一類別的其他方法所呼叫。</p>
-<p>JavaScript 並不提供做這些事的原生方式，但可以使用閉包來模擬私有方法。私有方法不只是對限制代碼的存取這方面有用︰同時也是管理你的全域命名空間的強大方式，把非必要的方法堆在公開的界面裡。</p>
-<p>這裡是如何使用閉包來定義可以存取私有函數和變數的公開函數︰</p>
-<pre class="brush: js">var Counter = (function() {
-  var privateCounter = 0;
-  function changeBy(val) {
-    privateCounter += val;
-  }
-  return {
-    increment: function() {
-      changeBy(1);
-    },
-    decrement: function() {
-      changeBy(-1);
-    },
-    value: function() {
-      return privateCounter;
-    }
-  }
-})();
-
-alert(Counter.value()); /* 顯示 0 */
-Counter.increment();
-Counter.increment();
-alert(Counter.value()); /* 顯示 2 */
-Counter.decrement();
-alert(Counter.value()); /* 顯示 1 */
-</pre>
-<p>在此完成了很多事。在上一個範例中，每一個閉包都有他自己的環境；此處我們建立了由三個函數所共享的單一環境<span style="font-family: monospace;">︰</span><code>Counter.increment</code>、<code>Counter.decrement</code>、<code>Counter.value</code>。</p>
-<p>共享的環境是建立在無名函數的本體內，無名函數一經定義就會開始執行。環境內含兩個私有項︰稱作 <code>privateCounter</code> 的變數，以及稱作 <code>changeBy</code> 的函數。這兩個私有項都不能在無名函數外部被直接存取。相對的，必須由三個公開的函數來存取這些私有項，這三個函數是從無名函數的封裝器所返回的。</p>
-<p>這三個公開的函數共享閉包的同一個環境。感謝 JavaScript 的辭彙作用域，這三個函數都能存取 <code>privateCounter</code> 變數和 <code>changeBy</code> 函數。</p>
-<p>按照這個方式來運用閉包，可以得到通常是附加在物件導向程式設計裡的資料隱藏和封裝的好處。</p><h4 id="Creating_closures_in_loops:_A_common_mistake" name="Creating_closures_in_loops:_A_common_mistake">在循環中建立閉包︰常見的錯誤</h4>
-<p>在 JavaScript 1.7 引入 <code>let</code> 關鍵字以前，閉包常見的問題出現在當閉包是在循環內部建立的時候。思考以下的例子︰</p>
-<pre class="brush: html">&lt;p id="help"&gt;這裡會顯示有用的提示&lt;/p&gt;
-&lt;p&gt;E-mail: &lt;input type="text" id="email" name="email"&gt;&lt;/p&gt;
-&lt;p&gt;姓名: &lt;input type="text" id="name" name="name"&gt;&lt;/p&gt;
-&lt;p&gt;年齡: &lt;input type="text" id="age" name="age"&gt;&lt;/p&gt;
-</pre>
-<pre class="brush: js">function showHelp(help) {
-  document.getElementById('help').innerHTML = help;
-}
-
-function setupHelp() {
-  var helpText = [
-      {'id': 'email', 'help': '你的 e-mail 位址'},
-      {'id': 'name', 'help': '你的完整姓名'},
-      {'id': 'age', 'help': '你的年齡（你必須大於 16 歲）'}
-    ];
-
-  for (var i = 0; i &lt; helpText.length; i++) {
-    var item = helpText[i];
-    document.getElementById(item.id).onfocus = function() {
-      showHelp(item.help);
-    }
-  }
-}
-</pre>
-<p><code>helpText</code> 陣列定義了三個有用的提示，每一個都和文件中的輸入欄位的 ID 連繫在一起。循環會在這些定義裡巡回一圈，給每一個顯示相關連的說明的方法使用 onfocus 事件。</p>
-<p>如果你試著執行這個代碼，你會發現他並不如預期般的運作。不管你把焦點放在哪一個欄位上，都會顯示關於你的年齡的訊息。</p>
-<p>這其中的原因是代入給 onfocus 的函數是閉包；這些閉包是由函數的定義和從 <code>setupHelp</code> 函數的作用域所捕捉到的環境所組成的。這三個閉包已經建立了，但每一個都共享同一個環境。每次執行 onfocus 的 Callback 的時候，循環執行的是他自己的閉包，以及指向 <code>helpText</code> 列表中的最後一項的變數 item（由三個閉包所共享）。</p>
-<p>本例的解決方法是使用更多的閉包︰特別是使用稍早已描述過的函數製造機︰</p>
-<pre class="brush: js">function showHelp(help) {
-  document.getElementById('help').innerHTML = help;
-}
-
-function makeHelpCallback(help) {
-  return function() {
-    showHelp(help);
-  };
-}
-
-function setupHelp() {
-  var helpText = [
-      {'id': 'email', 'help': '你的 e-mail 位址'},
-      {'id': 'name', 'help': '你的完整姓名'},
-      {'id': 'age', 'help': '你的年齡（你必須大於 16 歲）'}
-    ];
-
-  for (var i = 0; i &lt; helpText.length; i++) {
-    var item = helpText[i];
-    document.getElementById(item.id).onfocus = makeHelpCallback(item.help);
-  }
-}
-</pre>
-<p>這次就如預期般運作。而不是所有的 Callback 都共享單一的環境，<code>makeHelpCallback</code> 給每一個 <code>help</code> 建立新的環境，此處的 <code>help</code> 參照了相對應的 <code>helpText</code> 陣列的字串。</p>
-<p>如果你使用 JavaScript 1.7 以上的版本，你可以使用 <code>let</code> 關鍵字建立具有區塊層級作用域的變數來解決這個問題︰</p>
-<pre class="brush: js">  for (var i = 0; i &lt; helpText.length; i++) {
-    let item = helpText[i];
-    document.getElementById(item.id).onfocus = function() {
-      showHelp(item.help);
-    }
-  }
-</pre>
-<p><code>let</code> 關鍵字使 item 變數改用具有區塊層級的作用域來建立，導致 for 循環每一次反復都能建立新的參考。意思是每一個閉包都會捕捉到個別的變數，解決因為共享同一環境所引起的問題。</p><h4 id="Performance_considerations" name="Performance_considerations">效能的考量</h4>
-<p>如果並沒有特定的任務需要用到閉包，且閉包對 Script 的效能會有負面的影響，因此在其他函數的內部裡建立不必要的函數是很不智的。</p>
-<p>例如，當建立新的物件或類別時，通常應該要把方法和物件的原型連繫在一起，而不是在物件的建構子中定義。這其中的理由是，每當呼叫建構子的時候，就要把方法代入（也就是每一個物件正在建立的時候）。</p>
-<p>思考以下不切實際的例子︰</p>
-<pre class="brush: js">function MyObject(name, message) {
-  this.name = String(name);
-  this.message = String(message);
-  this.getName = function() {
-    return this.name;
-  };
-
-  this.getMessage = function() {
-    return this.message;
-  };
-}
-</pre>
-<p>上面的代碼並未從閉包的行為中取得好處，應該改用重整過的形式︰</p>
-<pre class="brush: js">function MyObject(name, message) {
-  this.name = String(name);
-  this.message = String(message);
-}
-MyObject.prototype = {
-  getName: function() {
-    return this.name;
-  },
-  getMessage: function() {
-    return this.message;
-  }
-};
-</pre>
-<p>或者是︰</p>
-<pre class="brush: js">function MyObject(name, message) {
-  this.name = String(name);
-  this.message = String(message);
-}
-MyObject.prototype.getName = function() {
-  return this.name;
-};
-MyObject.prototype.getMessage = function() {
-  return this.message;
-};
-</pre>
-<p>在上面這兩個範例中，繼承的原型可以被所有的物件所共享，而且在每一次建立物件時不再需要方法的定義。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8#%E7%89%A9%E4%BB%B6%E6%A8%A1%E5%9E%8B%E7%9A%84%E7%B4%B0%E7%AF%80" title="zh tw/Core JavaScript 1.5 教學#物件模型的細節">Core_JavaScript_1.5_教學#物件模型的細節</a> 以取得更多細節。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:escape_和_unescape_函數", "Core_JavaScript_1.5_教學:物件和屬性") }}</p>
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Working_with_Closures", "ja": "ja/Core_JavaScript_1.5_Guide/Working_with_Closures", "pl": "pl/Przewodnik_po_języku_JavaScript_1.5/Praca_z_zamknięciami" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/關於/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/關於/index.html
deleted file mode 100644
index de638e2a9f..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/關於/index.html
+++ /dev/null
@@ -1,47 +0,0 @@
----
-title: 關於
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/關於
----
-<p> </p>
-<h3 id="JavaScript_各版本的新機能" name="JavaScript_各版本的新機能">JavaScript 各版本的新機能</h3>
-<ul> <li><a class="internal" href="/zh_tw/JavaScript_1.5_%E6%96%B0%E9%AE%AE%E4%BA%8B" title="zh tw/JavaScript 1.5 新鮮事">JavaScript 1.5 新鮮事</a></li> <li><a class="internal" href="/zh_tw/JavaScript_1.6_%E6%96%B0%E9%AE%AE%E4%BA%8B" title="zh tw/JavaScript 1.6 新鮮事">JavaScript 1.6 新鮮事</a></li> <li><a class="internal" href="/zh_tw/JavaScript_1.7_%E6%96%B0%E9%AE%AE%E4%BA%8B" title="zh tw/JavaScript 1.7 新鮮事">JavaScript 1.7 新鮮事</a></li> <li><a class="internal" href="/zh_tw/JavaScript_1.8_%E6%96%B0%E9%AE%AE%E4%BA%8B" title="zh tw/JavaScript 1.8 新鮮事">JavaScript 1.8 新鮮事</a></li>
-</ul>
-<h3 id="你應該知道什麼" name="你應該知道什麼">你應該知道什麼</h3>
-<p>本教學假定你已具備如下背景知識︰</p>
-<ul> <li>對網際網路和 World Wide Web (WWW) 有全面性的認識。</li> <li>有良好的 HyperText Markup Language (<a class="internal" href="/zh_tw/HTML" title="zh tw/HTML">HTML</a>) 基礎知識。</li>
-</ul>
-<p>具有某些語言（如 C 或 Visual Basic）的程式設計經驗會很有幫助，但不是必要的。</p>
-<h3 id="JavaScript_的版本" name="JavaScript_的版本">JavaScript 的版本</h3>
-<table class="fullwidth-table"> <tbody> <tr> <th>JavaScript 的版本</th> <th>Navigator 的版本</th> </tr> <tr> <td>JavaScript 1.0</td> <td>Navigator 2.0</td> </tr> <tr> <td>JavaScript 1.1</td> <td>Navigator 3.0</td> </tr> <tr> <td>JavaScript 1.2</td> <td>Navigator 4.0-4.05</td> </tr> <tr> <td>JavaScript 1.3</td> <td>Navigator 4.06-4.7x</td> </tr> <tr> <td>JavaScript 1.4</td> <td> </td> </tr> <tr> <td>JavaScript 1.5</td> <td>Navigator 6.0<br> Mozilla（開放源始碼的瀏覽器）</td> </tr> <tr> <td>JavaScript 1.6</td> <td><a class="internal" href="/zh_tw/Firefox_1.5_for_developers" title="zh tw/Firefox 1.5 for developers">Firefox 1.5</a>，其他以 Mozilla 1.8 為基礎的產品</td> </tr> <tr> <td>JavaScript 1.7</td> <td><a class="internal" href="/zh_tw/Firefox_2_%E6%8A%80%E8%A1%93%E6%96%87%E4%BB%B6" title="zh tw/Firefox 2 技術文件">Firefox 2</a>，其他以 Mozilla 1.8.1 為基礎的產品</td> </tr> <tr> <td>JavaScript 1.8</td> <td><a class="internal" href="/zh_tw/Firefox_3_for_developers" title="zh tw/Firefox 3 for developers">Firefox 3</a>，其他以 Gecko 1.9 為基礎的產品</td> </tr> </tbody>
-</table>
-<p><small><strong>表 1: JavaScript 和 Navigator 版本</strong></small><br>
-<br>
-Netscape Enterprise Server 的各版本亦分別支援不同的 JavaScript 版本。為幫助你編寫相容於 Enterprise Server 各版本的 Script，本教學使用略稱來表示 Server 的版本。</p>
-<table class="fullwidth-table"> <tbody> <tr> <th>略稱</th> <th>Enterprise Server 的版本</th> </tr> <tr> <td>NES 2.0</td> <td>Netscape Enterprise Server 2.0</td> </tr> <tr> <td>NES 3.0</td> <td>Netscape Enterprise Server 3.0</td> </tr> </tbody>
-</table>
-<p><small><strong>表 2: Netscape Enterprise Server 各版本的略稱</strong></small></p>
-<h3 id="在何處取得_JavaScript_資訊" name="在何處取得_JavaScript_資訊">在何處取得 JavaScript 資訊</h3>
-<p>以下書藉內含核心 JavaScript 的文件︰</p>
-<ul> <li><a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8" title="zh tw/Core JavaScript 1.5 教學"> Core JavaScript 教學</a>（本教學）提供有關於核心 JavaScript 語言及其物件的資訊。</li> <li><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> 提供有關於核心 JavaScript 語言的參考資料。</li>
-</ul>
-<p>如果你是 JavaScript 的新手，就從 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8" title="zh tw/Core JavaScript 1.5 教學">Core JavaScript 教學</a> 著手。如果你已具備穩固的基礎，你可以從 <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>
-<h3 id="JavaScript_的學習提示" name="JavaScript_的學習提示">JavaScript 的學習提示</h3>
-<p>JavaScript 的入門很簡單: 只需要有最新的 Web 瀏覽器。本教學使用了一些目前只能在最新版本的 Firefox（以及其化的 Gecko 瀏覽器）執行的 JavaScript 機能，所以建議使用最新版本的 Firefox。</p>
-<h4 id="互動式解譯器" name="互動式解譯器">互動式解譯器</h4>
-<p>互動式 JavaScript 的提示對於語言的學習有極大的幫助，使你不必儲存檔案或更新頁面就能以互動方式加以試驗。從 Firefox 的“工具”選單可以找到“錯誤主控台”，可提供嘗試互動式 JavaScript 的簡單途徑: 只需輸入一行代碼，並按下“執行”按鈕。</p>
-<p><img alt="Image:ErrorConsole.png" class=" internal" src="/@api/deki/files/192/=ErrorConsole.png"></p>
-<h4 id="Firebug" name="Firebug">Firebug</h4>
-<p>更高級的互動式提示還可使用第三方擴充套件 <a class="external" href="http://www.getfirebug.com/">Firebug</a>。Firebug 提供了高級的 DOM 檢視器（JavaScript 除錯器）、分析工具和各種實用工具︰</p>
-<p><img alt="Image:Firebug.png" class=" internal" src="/@api/deki/files/204/=Firebug.png"></p>
-<p>其中 Firebug 提供的最有用的功能是 <code>console.log()</code>，把自己的參數輸出到 Firebug 主控台的函數。有別於其他程式語言，JavaScript 並沒有輸出至標準輸出的概念<span style="font-family: monospace;">。</span><code>console.log()</code> 提供了很有用的替代品，使你更容易觀察程式的執行。</p>
-<p>本教學的許多範例中使用 <code>alert()</code> 顯示執行的訊息。如果你已安裝 Firebug，你可以使用 <code>console.log()</code> 取代 <code>alert()</code> 來執行這些範例。</p>
-<h3 id="文件慣例" name="文件慣例">文件慣例</h3>
-<p>JavaScript 應用程式可執行於許多的作業系統，本文的資訊可套用於所有的版本。檔案和資料夾路徑採用 Windows 格式（使用反斜線 (\) 分割資料夾名稱）。對 Unix 版本而言，資料夾路徑也是相同的，除非你使用斜線 (/) 取代反斜線來分割資料夾名稱。</p>
-<p>本教學使用如下形式的 URL︰</p>
-<p><code><span class="nowiki">http://server.domain/path/file.html</span></code></p>
-<p>在上面的 URL 中，“server”表示執行應用程式的伺服器的名稱（例如︰research1、www），“domain”表示網際網路的域名（例如︰netscape.com、uiuc.edu），“path”表示在伺服器上的資料夾結構，“file.html”表示個別的檔名。一般來說，在 URL 裡以標準的等寬字型顯示的斜體表示是可修改的項目。如果你的伺服器已啟用 Secure Sockets Layer (SSL)，URL 的 http 就應該取代為 https。</p>
-<p>本教程使用如下的字型慣例︰</p>
-<ul> <li><code>等寬字型（monospace font）</code>用於範例代碼和代碼列表、API 和語言元素（方法名和屬性名等等）、檔案名稱、路徑名稱、資料夾名稱、HTML 標記，以及必須輸入在螢幕上的文字。（等寬斜體字型用來表示代碼裡的可修改項。）</li> <li><em>斜體（Italic type）</em>用於標題、強調、變數和可修改項，以及按字面表示的文字。</li> <li><strong>粗體（Boldface）</strong>用於術語。</li>
-</ul>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學", "Core_JavaScript_1.5_教學:JavaScript_概要") }}</p>
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/About", "es": "es/Gu\u00eda_JavaScript_1.5/Acerca_de_esta_gu\u00eda", "fr": "fr/Guide_JavaScript_1.5/\u00c0_propos", "ja": "ja/Core_JavaScript_1.5_Guide/About", "ko": "ko/Core_JavaScript_1.5_Guide/About", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/O_tym_przewodniku", "zh-cn": "cn/Core_JavaScript_1.5_Guide/\u5173\u4e8e" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/陣列的運用/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/陣列的運用/index.html
deleted file mode 100644
index 7f8133da58..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/陣列的運用/index.html
+++ /dev/null
@@ -1,452 +0,0 @@
----
-title: 陣列的運用
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/陣列的運用
-translation_of: Web/JavaScript/Guide
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Working_with_Arrays
----
-<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 &lt; 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 &lt; lastB) return -1;
-  if (lastA &gt; 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 &lt; 4; i++) {
-   a[i] = [];
-   for (j = 0; j &lt; 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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/escape_和_unescape_函數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/escape_和_unescape_函數/index.html
deleted file mode 100644
index 0533e2d1a4..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/escape_和_unescape_函數/index.html
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: escape 和 unescape 函數
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/escape_和_unescape_函數
-translation_of: Web/JavaScript/Guide/Functions
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/escape_and_unescape_Functions
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/eval_函數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/eval_函數/index.html
deleted file mode 100644
index fb257f891c..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/eval_函數/index.html
+++ /dev/null
@@ -1,17 +0,0 @@
----
-title: eval 函數
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/eval_函數
-translation_of: Web/JavaScript/Guide/Functions
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/eval_Function
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/index.html
deleted file mode 100644
index b44b292eb8..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/index.html
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: 預先定義的函數
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數
-translation_of: Web/JavaScript/Guide/Functions
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/isfinite_函數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/isfinite_函數/index.html
deleted file mode 100644
index db213a465e..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/isfinite_函數/index.html
+++ /dev/null
@@ -1,24 +0,0 @@
----
-title: isFinite 函數
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/isFinite_函數
-translation_of: Web/JavaScript/Guide/Functions
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isFinite_Function
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/isnan_函數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/isnan_函數/index.html
deleted file mode 100644
index d2ea7c4a46..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/isnan_函數/index.html
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: isNaN 函數
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/isNaN_函數
-translation_of: Web/JavaScript/Guide/Functions
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/isNaN_Function
----
-<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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/number_和_string_函數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/number_和_string_函數/index.html
deleted file mode 100644
index 0b44186a97..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/number_和_string_函數/index.html
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: Number 和 String 函數
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/Number_和_String_函數
-translation_of: Web/JavaScript/Guide/Functions
-translation_of_original: >-
-  Web/JavaScript/Guide/Obsolete_Pages/Predefined_Functions/parseInt_and_parseFloat_Functions
----
-<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("&lt;br/&gt;");
-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/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/parseint_和_parsefloat_函數/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/parseint_和_parsefloat_函數/index.html
deleted file mode 100644
index 65d1287175..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的函數/parseint_和_parsefloat_函數/index.html
+++ /dev/null
@@ -1,21 +0,0 @@
----
-title: parseInt 和 parseFloat 函數
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的函數/parseInt_和_parseFloat_函數
----
-<p> </p>
-<div class="onlyinclude">
-<h4 id="parseInt_和_parseFloat_函數">parseInt 和 parseFloat 函數</h4>
-<p>這兩個〝分析〞<span style="font-family: monospace;">函數，</span><code>parseInt</code> 和 <code>parseFloat</code>，會在給與字串作為參數時返回數值。</p>
-<p><code>parseFloat</code> 的語句如下</p>
-<pre>parseFloat(str)
-</pre>
-<p>此處的 <code>parseFloat</code> 會分析他自己的參數，字串 <code>str</code>，並試著返回浮點數。如果遇到正負符號 (+ 或 -)、數字 (0-9)、小數點、指數以外的字元，他就會返回在此之前的數值，並忽略那些字元。如果連第一個字元也不可以轉換為數字，就會返回〝NaN〞（不是數字）。</p>
-<p><code>parseInt</code> 的語句如下</p>
-<pre>parseInt(str [, radix])
-</pre>
-<p><code>parseInt</code> 會分析他自己的參數，字串 <code>str</code>，並試著返回由第二個參數所指定的 <code>radix</code> （基數）的整數。<code>radix</code> 為選用性參數。舉例來說，以 10 為底的基數表示要轉換為十進制數，8 是八進制，16 是十六進制，依此類推。對於 10 以上的基數，就會使用字母來表示大於九的數字。例如，十六進制數（基數 16），就會用到 A 到 F 的字母。</p>
-<p>如果 <code>parseInt</code> 遇到不是在指定基數之內的字元，就會直接忽略這個字元及其隨後字元，並返回在此之前已經分析出來的整數值。如果連第一個字元也不可以轉換為指定基數之內的字元，就會返回〝NaN〞。<code>parseInt</code> 函數會切除字串以取得整數值。</p>
-</div>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的函數:isNaN_函數", "Core_JavaScript_1.5_教學:預先定義的函數:Number_和_String_函數") }}</p>
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Functions/parseInt_and_parseFloat_Functions", "es": "es/Gu\u00eda_JavaScript_1.5/Funciones_predefinidas/Funciones_parseInt_y_parseFloat", "fr": "fr/Guide_JavaScript_1.5/Fonctions_pr\u00e9d\u00e9finies/Les_fonctions_parseInt_et_parseFloat", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Functions/parseInt_and_parseFloat_Functions", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Funkcje_predefiniowane/Funkcje_parseInt_i_parseFloat" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/array_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/array_物件/index.html
deleted file mode 100644
index a806c4dfac..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/array_物件/index.html
+++ /dev/null
@@ -1,151 +0,0 @@
----
-title: Array 物件
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/Array_物件
----
-<p> </p>
-<h3 id="Array_物件" name="Array_物件">Array 物件</h3>
-<p>JavaScript 並沒有明確的陣列資料類型。不過你可以在你的應用程式中，使用預先定義的 <code>Array</code> 物件和他的方法來運用陣列。<code>Array</code> 物件有各種陣列的操作方法，如合併、反轉、排序。他還有用來確定陣列的長度的屬性，還有和正規表達式一起使用的屬性。</p>
-<p><em>陣列</em>是值的有序集合，你可以使用名稱或索引來參考這些值。例如，你有一個稱作 <code>emp</code> 的陣列，其中內含職員的名字，並按照職員的編號來索引。於是 <code>emp{{ mediawiki.external(1) }}</code> 就代表編號 1 的職員，<code>emp{{ mediawiki.external(2) }}</code> 就代表編號 2 的職員，依此類推。</p>
-<p> </p>
-<h4 id="陣列的建立" name="陣列的建立">陣列的建立</h4>
-<p><code>Array</code> 物件的建立如下︰</p>
-<pre>1. arrayObjectName = new Array(element0, element1, ..., elementN)
-2. arrayObjectName = new Array(arrayLength)
-</pre>
-<p><code>arrayObjectName</code> 就是新物件的名稱、或者是既存物件的屬性。當使用 <code>Array</code> 的屬性和方法的時候，<code>arrayObjectName</code> 就是既存的 <code>Array</code> 物件的名稱、或者是既存物件的屬性。</p>
-<p><code>element0, element1, ..., elementN</code> 就是陣列元素的值的列表。如果指定了這個形式的話，陣列就會以指定的值作為元素來初始化，且陣列的 length 屬性會被設為參數的數目。</p>
-<p><code>arrayLength</code> 就是陣列的初期長度。下面的代碼建立帶有五個元素的陣列︰</p>
-<pre>billingMethod = new Array(5)
-</pre>
-<p>陣列的字面表達同時也是 <code>Array</code> 物件；舉例來說，下面的字面表達就是 <code>Array</code> 物件。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E5%AD%97%E9%9D%A2%E8%A1%A8%E9%81%94#%E9%99%A3%E5%88%97%E7%9A%84%E5%AD%97%E9%9D%A2%E8%A1%A8%E9%81%94" title="zh tw/Core JavaScript 1.5 教學/字面表達#陣列的字面表達">陣列的字面表達</a> 以取得陣列的字面表達的細節。</p>
-<pre>coffees = ["French Roast", "Columbian", "Kona"]
-</pre>
-<h4 id="陣列的操作" name="陣列的操作">陣列的存放</h4>
-<p>你可以藉由把值代入給陣列自己的元素的方式來存放到陣列裡。例如，</p>
-<pre>emp[1] = "Casey Jones"
-emp[2] = "Phil Lesh"
-emp[3] = "August West"
-</pre>
-<p>你也可以在建立陣列的同時來作存放︰</p>
-<pre>myArray = new Array("Hello", myVar, 3.14159)
-</pre>
-<h4 id="陣列元素的參考" name="陣列元素的參考">陣列元素的參考</h4>
-<p>你可以使用元素的序號來參考陣列的元素。例如，假設你定義了如下的陣列︰</p>
-<pre>myArray = new Array("Wind","Rain","Fire")
-</pre>
-<p>然後你可以使用 <code>myArray{{ mediawiki.external(0) }}</code> 來參考第一個元素，使用 <code>myArray{{ mediawiki.external(1) }}</code> 來參考第二個元素。</p>
-<p>元素的索引是從零 (0) 開始的，不過陣列的長度（例如，<code>myArray.length</code>）反映的是陣列中的元素的數目。</p>
-<h4 id="Array_的方法" name="Array_的方法">Array 的方法</h4>
-<p><code>Array</code> 物件有以下的方法︰</p>
-<ul>
- <li><code>concat</code> 合併兩個陣列，並把新的陣列返回。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array("1","2","3")
-   myArray = myArray.concat("a", "b", "c"); // myArray 現在是 ["1", "2", "3", "a", "b", "c"]
-</pre>
-<p> </p>
-<ul>
- <li><code>join(deliminator = ",")</code> 把所有的陣列元素合併成字串。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array("Wind","Rain","Fire")
-   list = myArray.join(" - "); // list 的內容是 "Wind - Rain - Fire"
-</pre>
-<p> </p>
-<ul>
- <li><code>pop</code> 把陣列的最後一個元素移除掉，並把元素返回。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array("1", "2", "3");
-   last=myArray.pop(); // MyArray 現在是 ["1", "2"], last = "3"
-</pre>
-<p> </p>
-<ul>
- <li><code>push</code> 在陣列的末端加入一個以上的元素，並返回陣列的最終長度。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array("1", "2");
-   myArray.push("3"); // MyArray 現在是 ["1", "2", "3"]
-</pre>
-<p> </p>
-<ul>
- <li><code>reverse</code> 調換陣列的元素︰陣列的第一個元素變成最後一個元素，最後一個則變成第一個。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array ("1", "2", "3");
-   myArray.reverse(); // 調換陣列的結果是 myArray = [ "3", "2", "1" ]
-</pre>
-<p> </p>
-<ul>
- <li><code>shift</code> 移除陣列的第一個元素，並返回被移除的元素。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array ("1", "2", "3");
-   first=myArray.shift(); // MyArray 現在是 ["2", "3"]，first 是 "1"
-</pre>
-<p> </p>
-<ul>
- <li><code>slice (start_index, upto_index)</code> 抽出陣列的片斷，並返回新的陣列。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array ("a", "b", "c", "d", "e");
-   myArray = myArray.slice(1,4); // 從索引 1 為起點抽出所有的元素，直到索引 4 為止，返回 [ "b", "c", "d" ]
-</pre>
-<p> </p>
-<ul>
- <li><code>splice(index, count_to_remove, addelement1, addelement2, ...)</code> 加入並/或移除陣列的元素。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array ("1", "2", "3", "4", "5");
-   myArray.splice(1,3,"a","b","c", "d"); // MyArray 現在是 ["1", "a", "b", "c", "d", "5"]
-   // 這個代碼從索引 1（也就是 "2"）開始，把那裡的 3 個元素移除掉，
-   // 然後把所有的連續元素插入到那個位置。
-</pre>
-<p> </p>
-<ul>
- <li><code>sort</code> 把陣列的元素重新排序。</li>
-</ul>
-<p> </p>
-<pre class="eval">   myArray = new Array("Wind","Rain","Fire")
-   myArray.sort(); // 排序陣列的結果是 myArrray = [ "Fire", "Rain", "Wind" ]
-</pre>
-<p> </p>
-<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>
-<p> </p>
-<pre class="eval">   var sortFn = function(a,b){
-       if (a[a.length - 1] &lt; b[b.length - 1]) return -1;
-       if (a[a.length - 1] &gt; b[b.length - 1]) return 1;
-       if (a[a.length - 1] == b[b.length - 1]) return 0;
-       }
-   myArray.sort(sortFn); // 排序陣列的結果是 myArray = ["Wind","Fire","Rain"]
-</pre>
-<p> </p>
-<ul>
- <li><code>unshift</code> 在陣列的前頭加入一個以上的元素，並返回陣列的新長度。</li>
-</ul>
-<h4 id="二維陣列" name="二維陣列">二維陣列</h4>
-<p>下面的代碼建立二維陣列。</p>
-<pre>a = new Array(4)
-for (i=0; i &lt; 4; i++) {
-   a[i] = new Array(4)
-   for (j=0; j &lt; 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>
-<h4 id="陣列和正規表達式" name="陣列和正規表達式">陣列和正規表達式</h4>
-<p>如果有一個陣列是正規表達式和字串之間比對的結果，這個陣列會返回有關比對的資訊的屬性和元素。陣列可以是 <code>RegExp.exec</code>、<code>String.match</code>、<code>String.split</code> 的返回值。若需要與正規表達式一同使用陣列的資訊，詳見第四章，<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" title="zh tw/Core JavaScript 1.5 教學#正規表達式">正規表達式</a>。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件", "Core_JavaScript_1.5_教學:預先定義的核心物件:Boolean_物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/boolean_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/boolean_物件/index.html
deleted file mode 100644
index 02648f7073..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/boolean_物件/index.html
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Boolean 物件
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/Boolean_物件
----
-<p> </p>
-<h3 id="Boolean_物件" name="Boolean_物件">Boolean 物件</h3>
-<p><code>Boolean</code> 物件是原始的 Boolean 資料類型包裝而成。使用下面的語法來建立 <code>Boolean</code> 物件︰</p>
-<pre>booleanObjectName = new Boolean(value)
-</pre>
-<p>別把原始的布林值的 <code>true</code> 和 <code>false</code> 與 <code>Boolean</code> 物件的 true 和 false 值給混淆了。任何物件的值只要不是 <code>undefined</code>、<code>null</code>、<code>0</code>、<code>NaN</code>、空字串，即使是值為 false 的 <code>Boolean</code> 物件，當傳入到條件語句裡的時候，其求值結果仍為 true。參閱 <a class="internal" href="/zh_tw/Core_JavaScript_1.5_%E6%95%99%E5%AD%B8/%E6%A2%9D%E4%BB%B6%E8%AA%9E%E6%B3%95#if...else_%E8%AA%9E%E6%B3%95" title="zh tw/Core JavaScript 1.5 教學/條件語法#if...else 語法">if...else 語法</a> 取得更進一步資訊。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件:Array_物件", "Core_JavaScript_1.5_教學:預先定義的核心物件:Date_物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/date_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/date_物件/index.html
deleted file mode 100644
index ca94741f14..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/date_物件/index.html
+++ /dev/null
@@ -1,82 +0,0 @@
----
-title: Date 物件
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/Date_物件
----
-<p> </p>
-<h3 id="Date_物件" name="Date_物件">Date 物件</h3>
-<p>JavaScript 並沒有日期的資料類型。不過你可以在你的應用程式中使用 <code>Date</code> 物件及其方法來使用日期和時間。<code>Date</code> 物件有非常大量的方法可用來設定、取得、操作日期。不過沒有任何的屬性。</p>
-<p>JavaScript 處理日期的方式很類似 Java。這兩個語言有很多同樣的日期方法，而且這兩個語言都是以 1970 年 1 月 1 日 00:00:00 開始的毫秒數來儲存日期。</p>
-<p>Date 物件的範圍是以 1970 年 1 月 1 日 (UTC) 為基準，從 -100,000,000 日一直到 100,000,000 日。</p>
-<p>如下建立 <code>Date</code> 物件︰</p>
-<pre>dateObjectName = new Date([parameters])
-</pre>
-<p>此處的 <code>dateObjectName</code> 就是將要建立的 <code>Date</code> 物件的名稱；他可以是新的物件或是既存物件的屬性。</p>
-<p>前敘語法中的 <code>parameters</code> 可以是下列的任何一種形式︰</p>
-<ul>
- <li>沒有參數︰建立今天的日期和時間。例如，<code>today = new Date()</code>。</li>
- <li>以此格式表示日期的字串︰"月 日, 年 時:分:秒"。例如，<code>Xmas95 = new Date("December 25, 1995 13:30:00")</code>。如果你省略了時、分、秒，這些值會被設為零。</li>
- <li>一組年、月、日的整數值。例如，<code>Xmas95 = new Date(1995,11,25)</code>。</li>
- <li>一組年、月、日、時、分、秒的整數值。例如，<code>Xmas95 = new Date(1995,11,25,9,30,0)</code>。</li>
-</ul>
-<p><strong>JavaScript 1.2 及早期版本</strong><br>
- <code>Date</code> 物件的行為如下︰</p>
-<ul>
- <li>不允許使用 1970 年以前的日期。</li>
- <li>JavaScript 依靠平台特有的日期之便及其行為；平台與平台之間，<code>Date</code> 物件的行為有所不同。</li>
-</ul>
-<h4 id="Methods_of_the_Date_Object" name="Methods_of_the_Date_Object">Date 物件的方法</h4>
-<p>用於處理日期和時間的 <code>Date</code> 物件的方法主要可分為這幾類︰</p>
-<ul>
- <li>"set" 方法，用於設定 <code>Date</code> 物件的日期和時間的值。</li>
- <li>"get" 方法，用於取得 <code>Date</code> 物件的日期和時間的值。</li>
- <li>"to" 方法，用於從 <code>Date</code> 物件返回字串值。</li>
- <li>parse 和 UTC 方法，用於分析 <code>Date</code> 字串。</li>
-</ul>
-<p>使用 "get" 和 "set" 方法，你可以分別取得或設定秒、分、時、日、星期、月、年。還有 <code>getDay</code> 方法可返回星期，但沒有相對應的 <code>setDay</code> 方法，因為星期會自動設定。這些方法使用整數來表示如下的這些值︰</p>
-<ul>
- <li>秒和分︰0 至 59</li>
- <li>時︰0 至 23</li>
- <li>星期︰0（星期日）至 6（星期六）</li>
- <li>日︰1 至 31（月份裡的某一日）</li>
- <li>月︰0（一月）至 11（十二月）</li>
- <li>年︰從 1900 年起</li>
-</ul>
-<p>舉例來說，假設你定義了如下日期︰</p>
-<pre>Xmas95 = new Date("December 25, 1995")
-</pre>
-<p><code>Xmas95.getMonth()</code> 返回 11，而 <code>Xmas95.getFullYear()</code> 返回 1995。</p>
-<p><code>getTime</code> 和 <code>setTime</code> 方法對於日期的比較來說很有用。<code>getTime</code> 方法返回自 1970 年 1 月 1 日 00:00:00 以來的毫秒數。</p>
-<p>例如，下面的代碼顯示今年的剩餘天數︰</p>
-<pre>today = new Date()
-endYear = new Date(1995,11,31,23,59,59,999) // 設定日和月
-endYear.setFullYear(today.getFullYear()) // 設定為今年
-msPerDay = 24 * 60 * 60 * 1000 // 一天的毫秒數
-daysLeft = (endYear.getTime() - today.getTime()) / msPerDay
-daysLeft = Math.round(daysLeft) // 返回今年的剩餘天數
-</pre>
-<p>本範例建立了名為 today 的 <code>Date</code> 物件，其中內含有今天的日期。然後，使用一天的毫秒數，計算今天和 <code>endYear</code> 之間的天數，使用 <code>getTime</code> 並捨入為天數。</p>
-<p>The <code>parse</code> 方法對於把值從日期字串代入到既存的 <code>Date</code> 物件來說很有用。例如，下面的代碼使用 <code>parse</code> 和 <code>setTime</code> 把日期的值代入到 <code>IPOdate</code> 物件︰</p>
-<pre>IPOdate = new Date()
-IPOdate.setTime(Date.parse("Aug 9, 1995"))
-</pre>
-<h4 id="Using_the_Date_Object:_an_Example" name="Using_the_Date_Object:_an_Example">Date 物件的使用︰範例</h4>
-<p>在下面的範例中，函數 <code>JSClock()</code> 返回以數位時鐘為格式的時間。</p>
-<pre>function JSClock() {
-   var time = new Date()
-   var hour = time.getHours()
-   var minute = time.getMinutes()
-   var second = time.getSeconds()
-   var temp = "" + ((hour &gt; 12) ? hour - 12 : hour)
-   if (hour == 0)
-      temp = "12";
-   temp += ((minute &lt; 10) ? ":0" : ":") + minute
-   temp += ((second &lt; 10) ? ":0" : ":") + second
-   temp += (hour &gt;= 12) ? " P.M." : " A.M."
-   return temp
-}
-</pre>
-<p><code>JSClock</code> 函數首先建立稱為 <code>time</code> 的新 Date 物件；因為沒有提供參數，time 會以今天的日期和時間來建立。然後呼叫 <code>getHours</code>、<code>getMinutes</code>、<code>getSeconds</code> 方法把時、分、秒的值代入到 <code>hour</code>、<code>minute</code>、<code>second</code>。</p>
-<p>以下的四個語句會以 time 為基準建立字串。第一個語句建立變數 <code>temp</code>，使用條件表達式把值代入；如果 <code>hour</code> 大於 12，就會是 (hour - 12)，否則會是單純的 hour，除非 hour 為 0，這時就會是 12。</p>
-<p>下一個語句把 <code>minute</code> 的值附加到 temp 裡。如果 <code>minute</code> 的值小於 10，條件表達式就會加上前置為零的字串；否則加上分隔用分號的字串。接下來的語句把秒的值以同樣方式附加到 temp。</p>
-<p>最後，如果 <code>hour</code> 大於 12，條件表達式就把 "PM" 附加到 temp；否則就把 "AM" 附加到 <code>temp</code>。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件:Boolean_物件", "Core_JavaScript_1.5_教學:預先定義的核心物件:Function_物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/function_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/function_物件/index.html
deleted file mode 100644
index 4acf1e73ca..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/function_物件/index.html
+++ /dev/null
@@ -1,45 +0,0 @@
----
-title: Function 物件
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/Function_物件
----
-<p> </p>
-<h3 id="Function_物件" name="Function_物件">Function 物件</h3>
-<p>預先定義的 <code>Function</code> 物件會把指定的 JavaScript 字串的代碼編譯成函數。</p>
-<p>建立 <code>Function</code> 物件如下︰</p>
-<pre>functionObjectName = new Function ([arg1, arg2, ... argn], functionBody)
-</pre>
-<p><code>functionObjectName</code> 就是變數的名稱或既存物件的屬性。他也可以是後跟小寫的事件處理器名稱的物件，如 <code>window.onerror</code>。</p>
-<p><code>arg1</code>, <code>arg2</code>, ... <code>argn</code> 就是要被函數用作形式參數的名稱的參數。其中每一個都必須是字串，並合於有效的 JavaScript 識別子。例如 "x" 或 "theForm"。</p>
-<p><code>functionBody</code> 就是指定的 JavaScript 代碼的字串，將會編譯成函數本體。</p>
-<p><code>Function</code> 物件會在每一次被用到時求值。這比宣告函數並在你的代碼中呼叫還要沒效率，因為宣告過的函數已經編譯過了。</p>
-<p>除了此處所描述的函數的定義方式以外，你也可以使用 <code>function</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 1.5 參考</a> 取得更進一步資訊。</p>
-<p>下面的代碼把函數代入到變數 <code>setBGColor</code>。這個函數會設定目前文件的背景色。</p>
-<pre>var setBGColor = new Function("document.bgColor='antiquewhite'")
-</pre>
-<p>若要呼叫這個 <code>Function</code> 物件，你可以把指定的變數名稱如同函數一般來使用。下面的代碼執行了由 <code>setBGColor</code> 變數所指定的函數︰</p>
-<pre>var colorChoice="antiquewhite"
-if (colorChoice=="antiquewhite") {setBGColor()}
-</pre>
-<p>你可以使用下列任一方式把函數代入給事件處理器︰</p>
-<pre>1. document.form1.colorButton.onclick=setBGColor
-2. &lt;INPUT NAME="colorButton" TYPE="button"
-      VALUE="Change background color"
-      onClick="setBGColor()"&gt;
-</pre>
-<p>上面所建立的變數 <code>setBGColor</code> 類似於宣告下面的函數︰</p>
-<pre>function setBGColor() {
-   document.bgColor='antiquewhite'
-}
-</pre>
-<p>把函數代入給變數類似於宣告函數，但有幾點不同︰</p>
-<ul>
- <li>當你使用 <code>var <code>setBGColor = new Function("...")</code></code> 把函數代入給變數時，<code>setBGColor</code> 只是參照以 <code>new <code>Function()</code></code> 建立的函數的變數。</li>
- <li>當你使用 <code>function setBGColor() {...}</code> 建立函數，<code>setBGColor</code> 並不是變數，而是函數的名稱。</li>
-</ul>
-<p>你可以在函數的內部嵌入函數。內嵌的（內部）函數對於包含這個函數的（外部）函數而言是私有的︰</p>
-<ul>
- <li>只能由外部函數裡面的語句來存取內部函數。</li>
- <li>內部函數可以使用外部函數的參數和變數。外部函數不能使用內部函數的參數和變數。</li>
-</ul>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件:Date_物件", "Core_JavaScript_1.5_教學:預先定義的核心物件:Math_物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/index.html
deleted file mode 100644
index 181d55974e..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/index.html
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: 預先定義的核心物件
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件
-translation_of: Web/JavaScript/Guide
-translation_of_original: Web/JavaScript/Guide/Obsolete_Pages/Predefined_Core_Objects
----
-<p> </p>
-<h3 id="預先定義的核心物件" name="預先定義的核心物件">預先定義的核心物件</h3>
-<p>本節解說在核心 JavaScript 裡預先定義的物件︰</p>
-<ul> <li><a 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></li> <li><a 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></li> <li><a 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/Date_%E7%89%A9%E4%BB%B6" title="zh_tw/Core_JavaScript_1.5_教學/預先定義的核心物件/Date_物件">Date 物件</a></li> <li><a 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/Function_%E7%89%A9%E4%BB%B6" title="zh_tw/Core_JavaScript_1.5_教學/預先定義的核心物件/Function_物件">Function 物件</a></li> <li><a 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/Math_%E7%89%A9%E4%BB%B6" title="zh_tw/Core_JavaScript_1.5_教學/預先定義的核心物件/Math_物件">Math 物件</a></li> <li><a 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/Number_%E7%89%A9%E4%BB%B6" title="zh_tw/Core_JavaScript_1.5_教學/預先定義的核心物件/Number_物件">Number 物件</a></li> <li><a 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/RegExp_%E7%89%A9%E4%BB%B6" title="zh_tw/Core_JavaScript_1.5_教學/預先定義的核心物件/RegExp_物件">RegExp 物件</a></li> <li><a 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></li>
-</ul>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:新物件的建立:屬性的刪除", "Core_JavaScript_1.5_教學:預先定義的核心物件:Array_物件") }}</p>
-<p>{{ languages( { "en": "en/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "es": "es/Gu\u00eda_JavaScript_1.5/Objetos_base_predefinidos", "fr": "fr/Guide_JavaScript_1.5/Objets_pr\u00e9d\u00e9finis", "ja": "ja/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "ko": "ko/Core_JavaScript_1.5_Guide/Predefined_Core_Objects", "pl": "pl/Przewodnik_po_j\u0119zyku_JavaScript_1.5/Obiekty_predefiniowane" } ) }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/math_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/math_物件/index.html
deleted file mode 100644
index 8aa6bb0223..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/math_物件/index.html
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: Math 物件
-slug: Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/Math_物件
----
-<p> </p>
-<h3 id="Math_物件" name="Math_物件">Math 物件</h3>
-<p>預先定義的 <code>Math</code> 物件具有針對數學常數和函數的屬性和方法。例如，<code>Math</code> 物件的 <code>PI</code> 屬性有圓周率的值 (3.141...)，你可以在應用程式中如下使用。</p>
-<pre>Math.PI
-</pre>
-<p>同樣的，Math 的方法就是標準的數學函數。其中包括三角函數、對數函數、指數函數、以及其他函數。例如，如果你想要使用三角函數 sine，你可以如下編寫。</p>
-<pre>Math.sin(1.56)
-</pre>
-<p>注意，<code>Math</code> 所有的三角函數的方法只接受以弧度為單位的參數。</p>
-<p>下表列出了 <code>Math</code> 物件的方法。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>方法</th>
-   <th>說明</th>
-  </tr>
-  <tr>
-   <td>abs</td>
-   <td>絕對值。</td>
-  </tr>
-  <tr>
-   <td>sin, cos, tan</td>
-   <td>標準三角函數；參數以弧度為單位。</td>
-  </tr>
-  <tr>
-   <td>acos, asin, atan, atan2</td>
-   <td>反三角函數；返回值以弧度為單位。</td>
-  </tr>
-  <tr>
-   <td>exp, log</td>
-   <td>指數函數和以 <sub>e</sub> 為底的自然對數。</td>
-  </tr>
-  <tr>
-   <td>ceil</td>
-   <td>返回大於等於參數的最小整數。</td>
-  </tr>
-  <tr>
-   <td>floor</td>
-   <td>返回小於等於參數的最大整數。</td>
-  </tr>
-  <tr>
-   <td>min, max</td>
-   <td>返回兩個參數中最大的或最小的。</td>
-  </tr>
-  <tr>
-   <td>pow</td>
-   <td>指數函數；第一個參數為底數，第二個為指數。</td>
-  </tr>
-  <tr>
-   <td>random</td>
-   <td>返回介於 0 和 1 之間的隨機數。</td>
-  </tr>
-  <tr>
-   <td>round</td>
-   <td>把參數捨入至最接近的整數。</td>
-  </tr>
-  <tr>
-   <td>sqrt</td>
-   <td>平方根。</td>
-  </tr>
- </tbody>
-</table>
-<p><small><strong>表 7.1: Math 的方法</strong></small></p>
-<p>有別於其他的物件，你永遠不需要自行建立 <code>Math</code> 物件。你永遠可以使用預先定義的 <code>Math</code> 物件。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件:Function_物件", "Core_JavaScript_1.5_教學:預先定義的核心物件:Number_物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/number_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/number_物件/index.html
deleted file mode 100644
index 01ff1ca26f..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/number_物件/index.html
+++ /dev/null
@@ -1,80 +0,0 @@
----
-title: Number 物件
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/Number_物件
----
-<p> </p>
-<h3 id="Number_物件" name="Number_物件">Number 物件</h3>
-<p>The <code>Number</code> 物件具有用於數值常數的屬性，如最大值、非數字、無限大。你不能改變這些屬性的值，你可以如下使用這些屬性︰</p>
-<pre>biggestNum = Number.MAX_VALUE
-smallestNum = Number.MIN_VALUE
-infiniteNum = Number.POSITIVE_INFINITY
-negInfiniteNum = Number.NEGATIVE_INFINITY
-notANum = Number.NaN
-</pre>
-<p>你永遠可以如上方式參照預先定義的 <code>Number</code> 物件的屬性，而不是參照你自己建立的 <code>Number</code> 物件的屬性。</p>
-<p>下表列出 <code>Number</code> 物件的屬性。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>屬性</th>
-   <th>說明</th>
-  </tr>
-  <tr>
-   <td>MAX_VALUE</td>
-   <td>所能表示的最大的數字</td>
-  </tr>
-  <tr>
-   <td>MIN_VALUE</td>
-   <td>所能表示的最小的數字</td>
-  </tr>
-  <tr>
-   <td>NaN</td>
-   <td>特殊的 "not a number"（非數字）值</td>
-  </tr>
-  <tr>
-   <td>NEGATIVE_INFINITY</td>
-   <td>特殊的負無限大的值；溢出時返回</td>
-  </tr>
-  <tr>
-   <td>POSITIVE_INFINITY</td>
-   <td>特殊的正無限大的值；溢出時返回</td>
-  </tr>
- </tbody>
-</table>
-<p><small><strong>表 7.2: Number 的屬性</strong></small></p>
-<p>Number 的原型提供從 Number 物件取得各種格式的資訊的方法。下表列出 <code>Number.prototype</code> 的方法。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>方法</th>
-   <th>說明</th>
-  </tr>
-  <tr>
-   <td>toExponential</td>
-   <td>返回以指數符號表示的數字的字串。</td>
-  </tr>
-  <tr>
-   <td>toFixed</td>
-   <td>返回以固定小數點表示的數字的字串。</td>
-  </tr>
-  <tr>
-   <td>toPrecision</td>
-   <td>返回以指定精度的固定小數點表示的數字的字串。</td>
-  </tr>
-  <tr>
-   <td>toSource</td>
-   <td>返回表示指定的 Number 物件的字面表達。你可以使用這個值來建立新的物件。覆蓋 Object.toSource 方法。</td>
-  </tr>
-  <tr>
-   <td>toString</td>
-   <td>返回表示指定物件的字串。覆蓋 Object.toString 方法。</td>
-  </tr>
-  <tr>
-   <td>valueOf</td>
-   <td>返回指定物件的原始值。覆蓋 Object.valueOf 方法。</td>
-  </tr>
- </tbody>
-</table>
-<p><small><strong>表 7.3: Number.prototype 的方法</strong></small></p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件:Math_物件", "Core_JavaScript_1.5_教學:預先定義的核心物件:RegExp_物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/regexp_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/regexp_物件/index.html
deleted file mode 100644
index 6d26e86067..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/regexp_物件/index.html
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: RegExp 物件
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/RegExp_物件
----
-<p> </p>
-<h3 id="RegExp_物件" name="RegExp_物件">RegExp 物件</h3>
-<p><code>RegExp</code> 物件可讓你運用正規表達式。已在第 4 章中解說過，<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" title="zh tw/Core JavaScript 1.5 教學#正規表達式">正規表達式</a>。</p>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件:Number_物件", "Core_JavaScript_1.5_教學:預先定義的核心物件:String_物件") }}</p>
diff --git a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/string_物件/index.html b/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/string_物件/index.html
deleted file mode 100644
index 9e18d6ca98..0000000000
--- a/files/zh-tw/web/javascript/obsolete_pages/obsolete_pages/obsolete_pages/預先定義的核心物件/string_物件/index.html
+++ /dev/null
@@ -1,88 +0,0 @@
----
-title: String 物件
-slug: >-
-  Web/JavaScript/Obsolete_Pages/Obsolete_Pages/Obsolete_Pages/預先定義的核心物件/String_物件
----
-<p> </p>
-<h3 id="String_物件" name="String_物件">String 物件</h3>
-<p><code>String</code> 物件只有一個屬性，<code>length</code>，用來指明字串中的字元數目。例如，下面的代碼把 13 的值代入給 <code>x</code>，因為 "Hello, World!" 有 13 個字元︰</p>
-<pre>mystring = "Hello, World!"
-x = mystring.length
-</pre>
-<p><code>String</code> 物件有兩種類型的方法︰一種是返回對字串本身的修改，如 <code>substring</code> 和 <code>toUpperCase</code>，另一種是返回字串的 HTML 格式版本，如 <code>bold</code> 和 <code>link</code>。</p>
-<p>舉例來說，延用前面的例子，<code>mystring.toUpperCase()</code> 和 <code>"hello, world!".toUpperCase()</code> 都會返回字串 "HELLO, WORLD!"。</p>
-<p><code>substring</code> 方法接受兩個參數，並返回介於兩個參數之間的字串的子集。延用前面的例子，<code>mystring.substring(4, 9)</code> 返回字串 "o, Wo"。參閱 <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> 中的 String 物件的 <code>substring</code> 方法，以取得更進一步資訊。</p>
-<p><code>String</code> 物件也有大量的針對自動的 HTML 格式化的方法，如 bold 建立粗體文字，link 建立超連結。例如，你可以使用 link 方法建立連結到某個 URL 的超連結，如下︰</p>
-<pre>mystring.link("http://www.helloworld.com")
-</pre>
-<p>下表列出 <code>String</code> 物件的方法。</p>
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>方法</th>
-   <th>說明</th>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/anchor" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/anchor">anchor</a></td>
-   <td>建立已命名的 HTML 錨點。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/big" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/big">big</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/blink" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/blink">blink</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/bold" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/bold">bold</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/fixed" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/fixed">fixed</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/italics" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/italics">italics</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/small" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/small">small</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/strike" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/strike">strike</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/sub" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/sub">sub</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/sup" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/sup">sup</a></td>
-   <td>建立 HTML 格式的字串。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/charAt" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/charAt">charAt</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/charCodeAt" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/charCodeAt">charCodeAt</a></td>
-   <td>返回字串中指定位置的字元或者字元內碼。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/indexOf" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/indexOf">indexOf</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/lastIndexOf" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/lastIndexOf">lastIndexOf</a></td>
-   <td>返回字串中指定子字串的位置，或指定子字串的最後的位置。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/link" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/link">link</a></td>
-   <td>建立 HTML 超連結。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/concat" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/concat">concat</a></td>
-   <td>合併兩個字串的文字，並返回新的字串。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/fromCharCode" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/fromCharCode">fromCharCode</a></td>
-   <td>從指定的 Unicode 值的序列建構字串。這是 String 類別的方法，而不是 String 實體的。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/split" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/split">split</a></td>
-   <td>藉由把字串分成子字串的方式，把 String 物件分割成字串的陣列。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/slice" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/slice">slice</a></td>
-   <td>抽出字串的片斷，並返回新的字串。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/substring" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/substring">substring</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/substr" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/substr">substr</a></td>
-   <td>以指定的起始或終止索引、或起始索引和長度，返回指定字串的子集。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/match" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/match">match</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/replace">replace</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/search" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/search">search</a></td>
-   <td>與正則表達式配合使用。</td>
-  </tr>
-  <tr>
-   <td><a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/toLowerCase" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/toLowerCase">toLowerCase</a>, <a href="/en/Core_JavaScript_1.5_Reference/Global_Objects/String/toUpperCase" title="en/Core_JavaScript_1.5_Reference/Global_Objects/String/toUpperCase">toUpperCase</a></td>
-   <td>返回全是大寫或全是小寫的字串。</td>
-  </tr>
- </tbody>
-</table>
-<p><small><strong>表 7.4: String 實體的方法</strong></small></p>
-<h3 id="String_Literals_are_Not_String_Objects" name="String_Literals_are_Not_String_Objects">字串的字面表達並不是 String 物件</h3>
-<p><code>String</code> 物件只是字串的原始資料類型的包裝而已。別把字串的字面表達和 <code>String</code> 物件相混淆了。例如，下面的代碼建立字串的字面表達 <code>s1</code> 和 String 物件 <code>s2</code>︰</p>
-<pre>s1 = "foo" // 建立字串的字面表達值
-s2 = new String("foo") // 建立 String 物件
-</pre>
-<p>你可以在字串的字面表達值上呼叫所有的 <code>String</code> 物件的方法—JavaScript 會自動把字串的字面表達轉換成臨時的 <code>String</code> 物件，呼叫其方法，然後丟棄臨時的 <code>String</code> 物件。你也可以在字面表達上使用 <code>String.length</code> 屬性。</p>
-<p>你應該使用字串的字面表達，除非你確定需要使用 <code>String</code> 物件，因為 <code>String</code> 物件會有反直覺的行為。例如︰</p>
-<pre>s1 = "2 + 2" // 建立字串的字面表達值
-s2 = new String("2 + 2") //建立 String 物件
-eval(s1) // 返回數字 4
-eval(s2) // 返回字串 "2 + 2"
-</pre>
-<p>{{ PreviousNext("Core_JavaScript_1.5_教學:預先定義的核心物件:RegExp_物件", "Core_JavaScript_1.5_教學:繼承") }}</p>
diff --git a/files/zh-tw/web/javascript/reference/global_objects/arraybuffer/prototype/index.html b/files/zh-tw/web/javascript/reference/global_objects/arraybuffer/prototype/index.html
deleted file mode 100644
index 263726d7e0..0000000000
--- a/files/zh-tw/web/javascript/reference/global_objects/arraybuffer/prototype/index.html
+++ /dev/null
@@ -1,111 +0,0 @@
----
-title: ArrayBuffer.prototype
-slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
-translation_of_original: Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype
----
-<div>{{JSRef}}</div>
-
-<p>The <strong><code>ArrayBuffer.prototype</code></strong> property represents the prototype for the {{jsxref("ArrayBuffer")}} object.</p>
-
-<div>{{js_property_attributes(0,0,0)}}</div>
-
-<h2 id="描述">描述</h2>
-
-<p><code>ArrayBuffer</code> instances inherit from <code>ArrayBuffer.prototype</code>. As with all constructors, you can change the constructor's prototype object to make changes to all <code>ArrayBuffer</code> instances.</p>
-
-<h2 id="屬性">屬性</h2>
-
-<dl>
- <dt>ArrayBuffer.prototype.constructor</dt>
- <dd>Specifies the function that creates an object's prototype. The initial value is the standard built-in <code>ArrayBuffer</code> constructor.</dd>
- <dt>{{jsxref("ArrayBuffer.prototype.byteLength")}} {{readonlyInline}}</dt>
- <dd>陣列大小，以位元組（byte）計算。此屬性在陣列建立之後就不可能改變了。<strong>唯讀</strong>。</dd>
-</dl>
-
-<h2 id="方法">方法</h2>
-
-<dl>
- <dt>{{jsxref("ArrayBuffer.prototype.slice()")}}</dt>
- <dd>Returns a new <code>ArrayBuffer</code> whose contents are a copy of this <code>ArrayBuffer</code>'s bytes from <code>begin</code>, inclusive, up to <code>end</code>, exclusive. If either <code>begin</code> or <code>end</code> is negative, it refers to an index from the end of the array, as opposed to from the beginning.</dd>
-</dl>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arraybuffer.prototype', 'ArrayBuffer.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>7.0</td>
-   <td>{{ CompatGeckoDesktop("2")}}</td>
-   <td>10</td>
-   <td>11.6</td>
-   <td>5.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>4.0</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoMobile("2")}}</td>
-   <td>10</td>
-   <td>11.6</td>
-   <td>4.2</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="參見">參見</h2>
-
-<ul>
- <li>{{jsxref("ArrayBuffer")}}</li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/global_objects/date/prototype/index.html b/files/zh-tw/web/javascript/reference/global_objects/date/prototype/index.html
deleted file mode 100644
index 5490743ec0..0000000000
--- a/files/zh-tw/web/javascript/reference/global_objects/date/prototype/index.html
+++ /dev/null
@@ -1,246 +0,0 @@
----
-title: Date.prototype
-slug: Web/JavaScript/Reference/Global_Objects/Date/prototype
-tags:
-  - Date
-  - JavaScript
-  - 原型
-  - 參考資料
-  - 屬性
-translation_of: Web/JavaScript/Reference/Global_Objects/Date
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Date/prototype
----
-<div>{{JSRef}}</div>
-
-<p><strong><code>Date.prototype</code></strong> 屬性表示 {{jsxref("Date")}} 建構子的原型。</p>
-
-<div>{{js_property_attributes(0, 0, 1)}}</div>
-
-<h2 id="描述">描述</h2>
-
-<p>JavaScript {{jsxref("Date")}} 實體繼承自 <code>Date.prototype。你可以藉由改變建構子的原型物件，來影響所有繼承自</code> JavaScript {{jsxref("Date")}} 的實體。</p>
-
-<p>為了千年年份（換個說法，考慮現在已到了 2000 年）的相容性，設定上你應該採用完整的年份。舉例來說，使用 1998 而不是 98 。為了讓你能取得完整的年份資料， Javascript 包含了 {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}} ， {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} ， {{jsxref("Date.prototype.getUTCFullYear()", "getUTCFullYear()")}} 以及 {{jsxref("Date.prototype.setUTCFullYear()", "setUTCFullYear()")}} 方法。</p>
-
-<p>自 ECMAScript 6 開始， <code>Date.prototype</code> 物件只是個一般物件，而不是一個 {{jsxref("Date")}} 實體。</p>
-
-<h2 id="屬性">屬性</h2>
-
-<dl>
- <dt><code>Date.prototype.constructor</code></dt>
- <dd>回傳一個能建立實體的函數，這是 {{jsxref("Date")}} 預設的建構子。</dd>
-</dl>
-
-<h2 id="方法">方法</h2>
-
-<h3 id="Getter">Getter</h3>
-
-<dl>
- <dt>{{jsxref("Date.prototype.getDate()")}}</dt>
- <dd>回傳本地時間月份中的日期（1-31）。</dd>
- <dt>{{jsxref("Date.prototype.getDay()")}}</dt>
- <dd>回傳本地時間星期中的日子（0-6）。</dd>
- <dt>{{jsxref("Date.prototype.getFullYear()")}}</dt>
- <dd>回傳本地時間的年份（ 以 4 位數表現）。</dd>
- <dt>{{jsxref("Date.prototype.getHours()")}}</dt>
- <dd>回傳本地時間的小時（0-23）。</dd>
- <dt>{{jsxref("Date.prototype.getMilliseconds()")}}</dt>
- <dd>回傳本地時間的毫秒數（0-999）。</dd>
- <dt>{{jsxref("Date.prototype.getMinutes()")}}</dt>
- <dd>回傳本地時間的分鐘數（0-59）。</dd>
- <dt>{{jsxref("Date.prototype.getMonth()")}}</dt>
- <dd>回傳本地時間的月份（0-11）。</dd>
- <dt>{{jsxref("Date.prototype.getSeconds()")}}</dt>
- <dd>回傳本地時間的秒數（0-59)。</dd>
- <dt>{{jsxref("Date.prototype.getTime()")}}</dt>
- <dd>回傳由 1970-01-01 00:00:00 UTC 開始，到代表時間經過的毫秒數（以負值表示 1970 年之前的時間）。</dd>
- <dt>{{jsxref("Date.prototype.getTimezoneOffset()")}}</dt>
- <dd>回傳本地時差為多少分鐘。</dd>
- <dt>{{jsxref("Date.prototype.getUTCDate()")}}</dt>
- <dd>回傳標準時間的在月份中的日期（1-31）。</dd>
- <dt>{{jsxref("Date.prototype.getUTCDay()")}}</dt>
- <dd>回傳標準時間在星期中的日子（0-6）。</dd>
- <dt>{{jsxref("Date.prototype.getUTCFullYear()")}}</dt>
- <dd>回傳標準時間的年份（ 以 4 位數表現）。</dd>
- <dt>{{jsxref("Date.prototype.getUTCHours()")}}</dt>
- <dd>回傳標準時間的小時數（0-23）。</dd>
- <dt>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</dt>
- <dd>回傳標準時間裡的毫秒數（0-999）。</dd>
- <dt>{{jsxref("Date.prototype.getUTCMinutes()")}}</dt>
- <dd>回傳標準時間的分鐘數（0-59）。</dd>
- <dt>{{jsxref("Date.prototype.getUTCMonth()")}}</dt>
- <dd>回傳標準時間的月份數（0-11）。</dd>
- <dt>{{jsxref("Date.prototype.getUTCSeconds()")}}</dt>
- <dd>回傳標準時間的秒數（0-59）。</dd>
- <dt>{{jsxref("Date.prototype.getYear()")}} {{deprecated_inline}}</dt>
- <dd>回本地時間的年份（通常 2-3 位數）。用 {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}} 取代。</dd>
-</dl>
-
-<h3 id="Setter">Setter</h3>
-
-<dl>
- <dt>{{jsxref("Date.prototype.setDate()")}}</dt>
- <dd>設定本地時間月份中的日期。</dd>
- <dt>{{jsxref("Date.prototype.setFullYear()")}}</dt>
- <dd>設定本地時間的完整年份（以 4 位數表達 4 位數年份）。</dd>
- <dt>{{jsxref("Date.prototype.setHours()")}}</dt>
- <dd>設定本地時間的小時數。</dd>
- <dt>{{jsxref("Date.prototype.setMilliseconds()")}}</dt>
- <dd>設定本地時間的毫秒數。</dd>
- <dt>{{jsxref("Date.prototype.setMinutes()")}}</dt>
- <dd>設定本地時間的分鐘數。</dd>
- <dt>{{jsxref("Date.prototype.setMonth()")}}</dt>
- <dd>設定本地時間的月份。</dd>
- <dt>{{jsxref("Date.prototype.setSeconds()")}}</dt>
- <dd>設定本地時間的秒數。</dd>
- <dt>{{jsxref("Date.prototype.setTime()")}}</dt>
- <dd>設定這個 {{jsxref("Date")}} 物件距 1970-01-01 00:00:00 UTC 的毫秒數，允許使用負值表示之前的時間。</dd>
- <dt>{{jsxref("Date.prototype.setUTCDate()")}}</dt>
- <dd>設定標準時間月份中的日期。</dd>
- <dt>{{jsxref("Date.prototype.setUTCFullYear()")}}</dt>
- <dd>設定標準時間的完整年份（以 4 位數表示 4 位數年分）。</dd>
- <dt>{{jsxref("Date.prototype.setUTCHours()")}}</dt>
- <dd>設定標準時間的小時數。</dd>
- <dt>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</dt>
- <dd>設定標準時間的毫秒數。</dd>
- <dt>{{jsxref("Date.prototype.setUTCMinutes()")}}</dt>
- <dd>設定標準時間的分鐘數。</dd>
- <dt>{{jsxref("Date.prototype.setUTCMonth()")}}</dt>
- <dd>設定標準時間的月份數。</dd>
- <dt>{{jsxref("Date.prototype.setUTCSeconds()")}}</dt>
- <dd>設定標準時間的秒數。</dd>
- <dt>{{jsxref("Date.prototype.setYear()")}} {{deprecated_inline}}</dt>
- <dd>設定本地時間的年份（使用 2-3 位數）。使用 {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} 取代。</dd>
-</dl>
-
-<h3 id="Conversion_getter">Conversion getter</h3>
-
-<dl>
- <dt>{{jsxref("Date.prototype.toDateString()")}}</dt>
- <dd>以可閱讀的字串型式，回傳 {{jsxref("Date")}} 的部分資訊。</dd>
- <dt>{{jsxref("Date.prototype.toISOString()")}}</dt>
- <dd>將日期時間轉換成 ISO 8601 格式的字串回傳。</dd>
- <dt>{{jsxref("Date.prototype.toJSON()")}}</dt>
- <dd>回傳等義於 {{jsxref("Date")}} 物件使用 {{jsxref("Date.prototype.toISOString()", "toISOString()")}} 方法的結果。特別使用 {{jsxref("JSON.stringify()")}} 處理。</dd>
- <dt>{{jsxref("Date.prototype.toGMTString()")}} {{deprecated_inline}}</dt>
- <dd>回傳 {{jsxref("Date")}} 以 GMT (UT) 時區基準代表的時間字串。使用 {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}} 方法來取代。</dd>
- <dt>{{jsxref("Date.prototype.toLocaleDateString()")}}</dt>
- <dd>依照系統的時間地區設定，回傳日期字串。</dd>
- <dt>{{jsxref("Date.prototype.toLocaleFormat()")}} {{non-standard_inline}}</dt>
- <dd>傳入格式化字串參數，將日期時間轉換成指定格式的字串。</dd>
- <dt>{{jsxref("Date.prototype.toLocaleString()")}}</dt>
- <dd>回傳依系統的地區設定導出的日期時間字串。覆寫自 {{jsxref("Object.prototype.toLocaleString()")}} 方法。</dd>
- <dt>{{jsxref("Date.prototype.toLocaleTimeString()")}}</dt>
- <dd>回傳依系統的地區設定導出的時間字串。</dd>
- <dt>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>回傳一個建立相同 {{jsxref("Date")}} 物件的程式碼字串；你可以拿這個結果來建立新物件。覆寫自 {{jsxref("Object.prototype.toSource()")}} 方法。</dd>
- <dt>{{jsxref("Date.prototype.toString()")}}</dt>
- <dd>回傳代表此 {{jsxref("Date")}} 物件的字串。覆寫自 {{jsxref("Object.prototype.toString()")}} 方法。</dd>
- <dt>{{jsxref("Date.prototype.toTimeString()")}}</dt>
- <dd>以人類可讀的格式，回傳時間部分的字串。</dd>
- <dt>{{jsxref("Date.prototype.toUTCString()")}}</dt>
- <dd>依 UTC 時區，轉換出時間日期字串。</dd>
- <dt>{{jsxref("Date.prototype.valueOf()")}}</dt>
- <dd>回傳 {{jsxref("Date")}} 物件的原始數值。覆寫自 {{jsxref("Object.prototype.valueOf()")}} 方法。</dd>
-</dl>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">規範</th>
-   <th scope="col">狀態</th>
-   <th scope="col">註</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>初步定義。實作在 JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.9.5', 'Date.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>平台</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>基本支援</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
-  <tr>
-   <td>一般物件</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoDesktop("41")}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>平台</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>基本支援</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
-  <tr>
-   <td>一般物件</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile("41")}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
diff --git a/files/zh-tw/web/javascript/reference/global_objects/function/prototype/index.html b/files/zh-tw/web/javascript/reference/global_objects/function/prototype/index.html
deleted file mode 100644
index 718454721b..0000000000
--- a/files/zh-tw/web/javascript/reference/global_objects/function/prototype/index.html
+++ /dev/null
@@ -1,139 +0,0 @@
----
-title: Function.prototype
-slug: Web/JavaScript/Reference/Global_Objects/Function/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/Function
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Function/prototype
----
-<div>{{JSRef}}</div>
-
-<p><code><strong>Function.prototype</strong></code> 屬性表示 {{jsxref("Function")}} 的原型物件。</p>
-
-<h2 id="描述">描述</h2>
-
-<p>{{jsxref("Function")}} objects inherit from <code>Function.prototype</code>.  <code>Function.prototype</code> cannot be modified.</p>
-
-<h2 id="屬性">屬性</h2>
-
-<dl>
- <dt>{{jsxref("Function.arguments")}} {{deprecated_inline}}</dt>
- <dd>An array corresponding to the arguments passed to a function. This is deprecated as property of {{jsxref("Function")}}, use the {{jsxref("Functions/arguments", "arguments")}} object available within the function instead.</dd>
- <dt><s class="obsoleteElement">{{jsxref("Function.arity")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Used to specifiy the number of arguments expected by the function, but has been removed. Use the {{jsxref("Function.length", "length")}} property instead.</s></dd>
- <dt>{{jsxref("Function.caller")}} {{non-standard_inline}}</dt>
- <dd>Specifies the function that invoked the currently executing function.</dd>
- <dt>{{jsxref("Function.length")}}</dt>
- <dd>Specifies the number of arguments expected by the function.</dd>
- <dt>{{jsxref("Function.name")}}</dt>
- <dd>The name of the function.</dd>
- <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt>
- <dd>The display name of the function.</dd>
- <dt><code>Function.prototype.constructor</code></dt>
- <dd>Specifies the function that creates an object's prototype. See {{jsxref("Object.prototype.constructor")}} for more details.</dd>
-</dl>
-
-<h2 id="方法">方法</h2>
-
-<dl>
- <dt>{{jsxref("Function.prototype.apply()")}}</dt>
- <dd>Calls a function and sets its <em>this</em> to the provided value, arguments can be passed as an {{jsxref("Array")}} object.</dd>
- <dt>{{jsxref("Function.prototype.bind()")}}</dt>
- <dd>Creates a new function which, when called, has its <em>this</em> set to the provided value, with a given sequence of arguments preceding any provided when the new function was called.</dd>
- <dt>{{jsxref("Function.prototype.call()")}}</dt>
- <dd>Calls (executes) a function and sets its <em>this</em> to the provided value, arguments can be passed as they are.</dd>
- <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt>
- <dd>Returns <code>true</code> if the function is a <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">generator</a>; otherwise returns <code>false</code>.</dd>
- <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Returns a string representing the source code of the function. Overrides the {{jsxref("Object.prototype.toSource")}} method.</dd>
- <dt>{{jsxref("Function.prototype.toString()")}}</dt>
- <dd>Returns a string representing the source code of the function. Overrides the {{jsxref("Object.prototype.toString")}} method.</dd>
-</dl>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.1</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="參見">參見</h2>
-
-<ul>
- <li>{{jsxref("Function")}}</li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/global_objects/number/prototype/index.html b/files/zh-tw/web/javascript/reference/global_objects/number/prototype/index.html
deleted file mode 100644
index bfd57f3d21..0000000000
--- a/files/zh-tw/web/javascript/reference/global_objects/number/prototype/index.html
+++ /dev/null
@@ -1,85 +0,0 @@
----
-title: Number.prototype
-slug: Web/JavaScript/Reference/Global_Objects/Number/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/Number
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype
----
-<div>{{JSRef}}</div>
-
-<p><strong><code>Number.prototype</code></strong> 屬性用來表示 {{jsxref("Number")}} 建構式的原型。</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="說明">說明</h2>
-
-<p>所有 {{jsxref("Number")}} 實體都繼承自 <code>Number.prototype</code> 。{{jsxref("Number")}} 建構式的原型物件可以被修改並作用在所有 {{jsxref("Number")}} 實體。</p>
-
-<h2 id="屬性">屬性</h2>
-
-<dl>
- <dt><code>Number.prototype.constructor</code></dt>
- <dd>回傳建立這個物件實體的建構式。預設為 {{jsxref("Number")}} 物件。</dd>
-</dl>
-
-<h2 id="方法">方法</h2>
-
-<dl>
- <dt>{{jsxref("Number.prototype.toExponential()")}}</dt>
- <dd>回傳以「科學記數法」表示的數值字串。</dd>
- <dt>{{jsxref("Number.prototype.toFixed()")}}</dt>
- <dd>回傳以定點表示的數值字串。</dd>
- <dt>{{jsxref("Number.prototype.toLocaleString()")}}</dt>
- <dd>回傳以當地語言為主的數值字串。這覆寫 {{jsxref("Object.prototype.toLocaleString()")}} 的方法。</dd>
- <dt>{{jsxref("Number.prototype.toPrecision()")}}</dt>
- <dd>回傳以定點或科學記數表示的數值字串。</dd>
- <dt>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Returns an object literal representing the specified {{jsxref("Number")}} object; you can use this value to create a new object. Overrides the {{jsxref("Object.prototype.toSource()")}} method.</dd>
- <dt>{{jsxref("Number.prototype.toString()")}}</dt>
- <dd>回傳以特定基數表示的數值字串。這覆寫 {{jsxref("Object.prototype.toString()")}} 的方法 。</dd>
- <dt>{{jsxref("Number.prototype.valueOf()")}}</dt>
- <dd>回傳這個物件的原始型別，即原始數值。這覆寫 {{jsxref("Object.prototype.valueOf()")}} 。</dd>
-</dl>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">規範</th>
-   <th scope="col">狀態</th>
-   <th scope="col">註記</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
-
-<p>{{Compat("javascript.builtins.Number.prototype")}}</p>
-
-<h2 id="參見">參見</h2>
-
-<ul>
- <li>{{jsxref("Number")}}</li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/global_objects/object/prototype/index.html b/files/zh-tw/web/javascript/reference/global_objects/object/prototype/index.html
deleted file mode 100644
index 4365b10c61..0000000000
--- a/files/zh-tw/web/javascript/reference/global_objects/object/prototype/index.html
+++ /dev/null
@@ -1,219 +0,0 @@
----
-title: Object.prototype
-slug: Web/JavaScript/Reference/Global_Objects/Object/prototype
-tags:
-  - JavaScript
-  - Object
-  - 待翻譯
-translation_of: Web/JavaScript/Reference/Global_Objects/Object
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Object/prototype
----
-<div>{{JSRef}}</div>
-
-<p><code><strong>Object.prototype</strong></code> 代表 {{jsxref("Object")}} 的原型物件。</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="描述">描述</h2>
-
-<p>All objects in JavaScript are descended from {{jsxref("Object")}}; all objects inherit methods and properties from <code>Object.prototype</code>, although they may be overridden (except an <code>Object</code> with a <code>null</code> prototype, i.e. <code>Object.create(null)</code>). For example, other constructors' prototypes override the <code>constructor</code> property and provide their own {{jsxref("Object.prototype.toString()", "toString()")}} methods. Changes to the <code>Object</code> prototype object are propagated to all objects unless the properties and methods subject to those changes are overridden further along the prototype chain.</p>
-
-<h2 id="屬性">屬性</h2>
-
-<dl>
- <dt>{{jsxref("Object.prototype.constructor")}}</dt>
- <dd>Specifies the function that creates an object's prototype.</dd>
- <dt>{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}</dt>
- <dd>Points to the object which was used as prototype when the object was instantiated.</dd>
- <dt>{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt>
- <dd>Allows a function to be defined that will be executed when an undefined object member is called as a method.</dd>
- <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Used to return the number of enumerable properties directly on a user-defined object, but has been removed.</s></dd>
- <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Used to point to an object's context, but has been removed.</s></dd>
-</dl>
-
-<h2 id="方法">方法</h2>
-
-<dl>
- <dt>{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Associates a function with a property that, when accessed, executes that function and returns its return value.</dd>
- <dt>{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Associates a function with a property that, when set, executes that function which modifies the property.</dd>
- <dt>{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Returns the function associated with the specified property by the {{jsxref("Object.defineGetter", "__defineGetter__")}} method.</dd>
- <dt>{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
- <dd>Returns the function associated with the specified property by the {{jsxref("Object.defineSetter", "__defineSetter__")}} method.</dd>
- <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt>
- <dd>Returns a boolean indicating whether an object contains the specified property as a direct property of that object and not inherited through the prototype chain.</dd>
- <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt>
- <dd>Returns a boolean indication whether the specified object is in the prototype chain of the object this method is called upon.</dd>
- <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt>
- <dd>Returns a boolean indicating if the internal <a href="/en-US/docs/ECMAScript_DontEnum_attribute" title="ECMAScript_DontEnum_attribute">ECMAScript DontEnum attribute</a> is set.</dd>
- <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Returns string containing the source of an object literal representing the object that this method is called upon; you can use this value to create a new object.</dd>
- <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt>
- <dd>Calls {{jsxref("Object.toString", "toString()")}}.</dd>
- <dt>{{jsxref("Object.prototype.toString()")}}</dt>
- <dd>Returns a string representation of the object.</dd>
- <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt>
- <dd>Removes a watchpoint from a property of the object.</dd>
- <dt>{{jsxref("Object.prototype.valueOf()")}}</dt>
- <dd>Returns the primitive value of the specified object.</dd>
- <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt>
- <dd>Adds a watchpoint to a property of the object.</dd>
- <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Used to evaluate a string of JavaScript code in the context of the specified object, but has been removed.</s></dd>
-</dl>
-
-<h2 id="範例">範例</h2>
-
-<p>因為 JavaScript 並沒有子類別的物件，所以原型是個很有用的解決辦法, 使某些函數作為物件的基本類別物件。例如：</p>
-
-<pre class="brush: js">var Person = function() {
-  this.canTalk = true;
-};
-
-Person.prototype.greet = function() {
-  if (this.canTalk) {
-    console.log('Hi, I am ' + this.name);
-  }
-};
-
-var Employee = function(name, title) {
-  Person.call(this);
-  this.name = name;
-  this.title = title;
-};
-
-Employee.prototype = Object.create(Person.prototype);
-Employee.prototype.constructor = Employee;
-
-Employee.prototype.greet = function() {
-  if (this.canTalk) {
-    console.log('Hi, I am ' + this.name + ', the ' + this.title);
-  }
-};
-
-var Customer = function(name) {
-  Person.call(this);
-  this.name = name;
-};
-
-Customer.prototype = Object.create(Person.prototype);
-Customer.prototype.constructor = Customer;
-
-var Mime = function(name) {
-  Person.call(this);
-  this.name = name;
-  this.canTalk = false;
-};
-
-Mime.prototype = Object.create(Person.prototype);
-Mime.prototype.constructor = Mime;
-
-var bob = new Employee('Bob', 'Builder');
-var joe = new Customer('Joe');
-var rg = new Employee('Red Green', 'Handyman');
-var mike = new Customer('Mike');
-var mime = new Mime('Mime');
-
-bob.greet();
-// Hi, I am Bob, the Builder
-
-joe.greet();
-// Hi, I am Joe
-
-rg.greet();
-// Hi, I am Red Green, the Handyman
-
-mike.greet();
-// Hi, I am Mike
-
-mime.greet();
-</pre>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="參見">參見</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introduction to Object-Oriented JavaScript</a></li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/global_objects/promise/prototype/index.html b/files/zh-tw/web/javascript/reference/global_objects/promise/prototype/index.html
deleted file mode 100644
index f93572bea3..0000000000
--- a/files/zh-tw/web/javascript/reference/global_objects/promise/prototype/index.html
+++ /dev/null
@@ -1,65 +0,0 @@
----
-title: Promise.prototype
-slug: Web/JavaScript/Reference/Global_Objects/Promise/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/Promise
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Promise/prototype
----
-<div>{{JSRef}}</div>
-
-<p><code><strong>Promise</strong></code><strong><code>.prototype</code></strong> 屬性代表了 {{jsxref("Promise")}} 建構式的原型物件。</p>
-
-<div>{{js_property_attributes(0,0,0)}}</div>
-
-<h2 id="描述">描述</h2>
-
-<p>所有 {{jsxref("Promise")}} 實例都繼承自 {{jsxref("Promise.prototype")}}。您可以使用建構式的原型物件來增加屬性或方法到所有的 <code>Promise</code> 實例。</p>
-
-<h2 id="屬性">屬性</h2>
-
-<dl>
- <dt><code>Promise.prototype.constructor</code></dt>
- <dd>回傳一個建立實例原型（instance's prototype）的函式。預設為 {{jsxref("Promise")}} 函數。</dd>
-</dl>
-
-<h2 id="方法">方法</h2>
-
-<dl>
- <dt>{{jsxref("Promise.catch", "Promise.prototype.catch(onRejected)")}}</dt>
- <dd>繫結一個拒絕回呼函式（rejection handler callback）到 promise，當它被呼叫時回傳一個以回傳值作解析的新 promise，或者當 promise 被實現時以原值作解析。</dd>
- <dt>{{jsxref("Promise.then", "Promise.prototype.then(onFulfilled, onRejected)")}}</dt>
- <dd>繫結實現或拒絕回呼函式到 promise，回傳一個以 handler 之回傳值作解析的新 promise，或者當 promise 未處理（not handled）時以原值作解析。(i.e. 比如相關聯的 <code>onFulfilled</code> 或 <code>onRejected</code> 不是函式。)</dd>
-</dl>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-promise.prototype', 'Promise.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-promise.prototype', 'Promise.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p>
-
-<p>{{Compat("javascript/promise","Promise.prototype")}}</p>
-
-<h2 id="參見">參見</h2>
-
-<ul>
- <li>{{jsxref("Promise")}}</li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/global_objects/string/prototype/index.html b/files/zh-tw/web/javascript/reference/global_objects/string/prototype/index.html
deleted file mode 100644
index 011c61418e..0000000000
--- a/files/zh-tw/web/javascript/reference/global_objects/string/prototype/index.html
+++ /dev/null
@@ -1,177 +0,0 @@
----
-title: String.prototype
-slug: Web/JavaScript/Reference/Global_Objects/String/prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/String
-translation_of_original: Web/JavaScript/Reference/Global_Objects/String/prototype
----
-<div>{{JSRef}}</div>
-
-<p>The <strong><code>String.prototype</code></strong> property represents the {{jsxref("String")}} prototype object.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Description">Description</h2>
-
-<p>All {{jsxref("String")}} instances inherit from <code>String.prototype</code>. Changes to the <code>String</code> prototype object are propagated to all {{jsxref("String")}} instances.</p>
-
-<h2 id="Properties">Properties</h2>
-
-<dl>
- <dt><code>String.prototype.constructor</code></dt>
- <dd>Specifies the function that creates an object's prototype.</dd>
- <dt>{{jsxref("String.prototype.length")}}</dt>
- <dd>Reflects the length of the string.</dd>
- <dt><code><em>N</em></code></dt>
- <dd>Used to access the character in the <em>N</em>th position where <em>N</em> is a positive integer between 0 and one less than the value of {{jsxref("String.length", "length")}}. These properties are read-only.</dd>
-</dl>
-
-<h2 id="Methods">Methods</h2>
-
-<h3 id="Methods_unrelated_to_HTML">Methods unrelated to HTML</h3>
-
-<dl>
- <dt>{{jsxref("String.prototype.charAt()")}}</dt>
- <dd>Returns the character (exactly one UTF-16 code unit) at the specified index.</dd>
- <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt>
- <dd>Returns a number that is the UTF-16 code unit value at the given index.</dd>
- <dt>{{jsxref("String.prototype.codePointAt()")}}</dt>
- <dd>Returns a nonnegative integer Number that is the code point value of the UTF-16 encoded code point starting at the specified index.</dd>
- <dt>{{jsxref("String.prototype.concat()")}}</dt>
- <dd>Combines the text of two strings and returns a new string.</dd>
- <dt>{{jsxref("String.prototype.includes()")}}</dt>
- <dd>Determines whether one string may be found within another string.</dd>
- <dt>{{jsxref("String.prototype.endsWith()")}}</dt>
- <dd>Determines whether a string ends with the characters of another string.</dd>
- <dt>{{jsxref("String.prototype.indexOf()")}}</dt>
- <dd>Returns the index within the calling {{jsxref("String")}} object of the first occurrence of the specified value, or -1 if not found.</dd>
- <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt>
- <dd>Returns the index within the calling {{jsxref("String")}} object of the last occurrence of the specified value, or -1 if not found.</dd>
- <dt>{{jsxref("String.prototype.localeCompare()")}}</dt>
- <dd>Returns a number indicating whether a reference string comes before or after or is the same as the given string in sort order.</dd>
- <dt>{{jsxref("String.prototype.match()")}}</dt>
- <dd>Used to match a regular expression against a string.</dd>
- <dt>{{jsxref("String.prototype.normalize()")}}</dt>
- <dd>Returns the Unicode Normalization Form of the calling string value.</dd>
- <dt>{{jsxref("String.prototype.padEnd()")}}</dt>
- <dd>Pads the current string from the end with a given string to create a new string from a given length.</dd>
- <dt>{{jsxref("String.prototype.padStart()")}}</dt>
- <dd>Pads the current string from the start with a given string to create a new string from a given length.</dd>
- <dt><s class="obsoleteElement">{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Wraps the string in double quotes ("<code>"</code>").</s></dd>
- <dt>{{jsxref("String.prototype.repeat()")}}</dt>
- <dd>Returns a string consisting of the elements of the object repeated the given times.</dd>
- <dt>{{jsxref("String.prototype.replace()")}}</dt>
- <dd>Used to find a match between a regular expression and a string, and to replace the matched substring with a new substring.</dd>
- <dt>{{jsxref("String.prototype.search()")}}</dt>
- <dd>Executes the search for a match between a regular expression and a specified string.</dd>
- <dt>{{jsxref("String.prototype.slice()")}}</dt>
- <dd>Extracts a section of a string and returns a new string.</dd>
- <dt>{{jsxref("String.prototype.split()")}}</dt>
- <dd>Splits a {{jsxref("Global_Objects/String", "String")}} object into an array of strings by separating the string into substrings.</dd>
- <dt>{{jsxref("String.prototype.startsWith()")}}</dt>
- <dd>Determines whether a string begins with the characters of another string.</dd>
- <dt>{{jsxref("String.prototype.substr()")}}</dt>
- <dd>Returns the characters in a string beginning at the specified location through the specified number of characters.</dd>
- <dt>{{jsxref("String.prototype.substring()")}}</dt>
- <dd>Returns the characters in a string between two indexes into the string.</dd>
- <dt>{{jsxref("String.prototype.toLocaleLowerCase()")}}</dt>
- <dd>The characters within a string are converted to lower case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}.</dd>
- <dt>{{jsxref("String.prototype.toLocaleUpperCase()")}}</dt>
- <dd>The characters within a string are converted to upper case while respecting the current locale. For most languages, this will return the same as {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}.</dd>
- <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt>
- <dd>Returns the calling string value converted to lower case.</dd>
- <dt>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Returns an object literal representing the specified object; you can use this value to create a new object. Overrides the {{jsxref("Object.prototype.toSource()")}} method.</dd>
- <dt>{{jsxref("String.prototype.toString()")}}</dt>
- <dd>Returns a string representing the specified object. Overrides the {{jsxref("Object.prototype.toString()")}} method.</dd>
- <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt>
- <dd>Returns the calling string value converted to uppercase.</dd>
- <dt>{{jsxref("String.prototype.trim()")}}</dt>
- <dd>Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5 standard.</dd>
- <dt>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</dt>
- <dd>Trims whitespace from the left side of the string.</dd>
- <dt>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</dt>
- <dd>Trims whitespace from the right side of the string.</dd>
- <dt>{{jsxref("String.prototype.valueOf()")}}</dt>
- <dd>Returns the primitive value of the specified object. Overrides the {{jsxref("Object.prototype.valueOf()")}} method.</dd>
- <dt>{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}</dt>
- <dd>Returns a new <code>Iterator</code> object that iterates over the code points of a String value, returning each code point as a String value.</dd>
-</dl>
-
-<h3 id="HTML_wrapper_methods">HTML wrapper methods</h3>
-
-<p>These methods are of limited use, as they provide only a subset of the available HTML tags and attributes.</p>
-
-<dl>
- <dt>{{jsxref("String.prototype.anchor()")}}</dt>
- <dd>{{htmlattrxref("name", "a", "&lt;a name=\"name\"&gt;")}} (hypertext target)</dd>
- <dt>{{jsxref("String.prototype.big()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("big")}}</dd>
- <dt>{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("blink")}}</dd>
- <dt>{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("b")}}</dd>
- <dt>{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("tt")}}</dd>
- <dt>{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}</dt>
- <dd>{{htmlattrxref("color", "font", "&lt;font color=\"color\"&gt;")}}</dd>
- <dt>{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}</dt>
- <dd>{{htmlattrxref("size", "font", "&lt;font size=\"size\"&gt;")}}</dd>
- <dt>{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("i")}}</dd>
- <dt>{{jsxref("String.prototype.link()")}}</dt>
- <dd>{{htmlattrxref("href", "a", "&lt;a href=\"url\"&gt;")}} (link to URL)</dd>
- <dt>{{jsxref("String.prototype.small()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("small")}}</dd>
- <dt>{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("strike")}}</dd>
- <dt>{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("sub")}}</dd>
- <dt>{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}</dt>
- <dd>{{HTMLElement("sup")}}</dd>
-</dl>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
-
-<p>{{Compat("javascript.builtins.String.prototype")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("String")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/operators/arithmetic_operators/index.html b/files/zh-tw/web/javascript/reference/operators/arithmetic_operators/index.html
deleted file mode 100644
index 050c362008..0000000000
--- a/files/zh-tw/web/javascript/reference/operators/arithmetic_operators/index.html
+++ /dev/null
@@ -1,309 +0,0 @@
----
-title: 算術運算子
-slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p><strong>算術運算子接受數值（資料型態為字串或變數都可）作為其運算子並回傳單個數值。 標準算術運算符號有加號（+），減號（ - ），乘（*）和除（/）。</strong></p>
-
-<div>{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}</div>
-
-
-
-<h2 id="Addition_()"><a id="加法" name="加法">Addition (+)</a></h2>
-
-<p>加法運算子生成數字(運算元)的總和或字串串接。</p>
-
-<h3 id="Syntax">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> x + y
-</pre>
-
-<h3 id="Examples">Examples</h3>
-
-<pre class="brush: js">// Number + Number -&gt; addition
-1 + 2 // 3
-
-// Boolean + Number -&gt; addition
-true + 1 // 2
-
-// Boolean + Boolean -&gt; addition
-false + false // 0
-
-// Number + String -&gt; concatenation
-5 + 'foo' // "5foo"
-
-// String + Boolean -&gt; concatenation
-'foo' + false // "foofalse"
-
-// String + String -&gt; concatenation
-'foo' + 'bar' // "foobar"
-</pre>
-
-<h2 id="Subtraction_(-)"><a id="減法" name="減法">Subtraction (-)</a></h2>
-
-<p>減法運算子能算出兩個運算元間的差異。</p>
-
-<h3 id="Syntax_2">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> x - y
-</pre>
-
-<h3 id="Examples_2">Examples</h3>
-
-<pre class="brush: js">5 - 3 // 2
-3 - 5 // -2
-'foo' - 3 // NaN</pre>
-
-<h2 id="Division_()"><a id="除法" name="除法">Division (/)</a></h2>
-
-<p>The division operator produces the quotient of its operands where the left operand is the dividend and the right operand is the divisor.</p>
-
-<h3 id="Syntax_3">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> x / y
-</pre>
-
-<h3 id="Examples_3">Examples</h3>
-
-<pre class="brush: js">1 / 2      // returns 0.5 in JavaScript
-1 / 2      // returns 0 in Java
-// (neither number is explicitly a floating point number)
-
-1.0 / 2.0  // returns 0.5 in both JavaScript and Java
-
-2.0 / 0    // returns Infinity in JavaScript
-2.0 / 0.0  // returns Infinity too
-2.0 / -0.0 // returns -Infinity in JavaScript</pre>
-
-<h2 id="Multiplication_(*)"><a id="乘法" name="乘法">Multiplication (*)</a></h2>
-
-<p>The multiplication operator produces the product of the operands.</p>
-
-<h3 id="Syntax_4">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> x * y
-</pre>
-
-<h3 id="Examples_4">Examples</h3>
-
-<pre class="brush: js">2 * 2 // 4
--2 * 2 // -4
-Infinity * 0 // NaN
-Infinity * Infinity // Infinity
-'foo' * 2 // NaN
-</pre>
-
-<h2 id="Remainder_()"><a id="餘數運算" name="餘數運算">Remainder (%)</a></h2>
-
-<p>The remainder operator returns the remainder left over when one operand is divided by a second operand. It always takes the sign of the dividend.</p>
-
-<h3 id="Syntax_5">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> var1 % var2
-</pre>
-
-<h3 id="Examples_5">Examples</h3>
-
-<pre class="brush: js">12 % 5 // 2
--1 % 2 // -1
-1 % -2 // 1
-NaN % 2 // NaN
-1 % 2 // 1
-2 % 3 // 2
--4 % 2 // -0
-5.5 % 2 // 1.5
-</pre>
-
-<h2 id="Exponentiation_(**)"><a id="指數運算" name="指數運算">Exponentiation (**)</a></h2>
-
-<p>The exponentiation operator returns the result of raising first operand to the power second operand. that is, <code>var1</code><sup><code>var2</code></sup>, in the preceding statement, where <code>var1</code> and <code>var2</code> are variables. Exponentiation operator is right associative. <code>a ** b ** c</code> is equal to <code>a ** (b ** c)</code>.</p>
-
-<h3 id="Syntax_6">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> var1 ** var2
-</pre>
-
-<h3 id="Notes">Notes</h3>
-
-<p>In most languages like PHP and Python and others that have an exponentiation operator (**), the exponentiation operator is defined to have a higher precedence than unary operators such as unary + and unary -, but there are a few exceptions. For example, in Bash the ** operator is defined to have a lower precedence than unary operators. In JavaScript, it is impossible to write an ambiguous exponentiation expression, i.e. you cannot put a unary operator (<code>+/-/~/!/delete/void/typeof</code>) immediately before the base number.</p>
-
-<pre class="brush: js">-2 ** 2;
-// 4 in Bash, -4 in other languages.
-// This is invalid in JavaScript, as the operation is ambiguous.
-
-
--(2 ** 2);
-// -4 in JavaScript and the author's intention is unambiguous.
-</pre>
-
-<h3 id="Examples_6">Examples</h3>
-
-<pre class="brush: js">2 ** 3 // 8
-3 ** 2 // 9
-3 ** 2.5 // 15.588457268119896
-10 ** -1 // 0.1
-NaN ** 2 // NaN
-
-2 ** 3 ** 2 // 512
-2 ** (3 ** 2) // 512
-(2 ** 3) ** 2 // 64
-</pre>
-
-<p>To invert the sign of the result of an exponentiation expression:</p>
-
-<pre class="brush: js">-(2 ** 2) // -4
-</pre>
-
-<p>To force the base of an exponentiation expression to be a negative number:</p>
-
-<pre class="brush: js">(-2) ** 2 // 4
-</pre>
-
-<div class="note">
-<p><strong>Note:</strong> JavaScript also has <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">a bitwise operator ^ (logical XOR)</a>. <code>**</code> and <code>^</code> are different (for example : <code>2 ** 3 === 8</code> when <code>2 ^ 3 === 1</code>.)</p>
-</div>
-
-<h2 id="Increment_()"><a id="遞增運算" name="遞增運算">Increment (++)</a></h2>
-
-<p>The increment operator increments (adds one to) its operand and returns a value.</p>
-
-<ul>
- <li>If used postfix, with operator after operand (for example, x++), then it returns the value before incrementing.</li>
- <li>If used prefix with operator before operand (for example, ++x), then it returns the value after incrementing.</li>
-</ul>
-
-<h3 id="Syntax_7">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> x++ or ++x
-</pre>
-
-<h3 id="Examples_7">Examples</h3>
-
-<pre class="brush: js">// Postfix
-var x = 3;
-y = x++; // y = 3, x = 4
-
-// Prefix
-var a = 2;
-b = ++a; // a = 3, b = 3
-</pre>
-
-<h2 id="Decrement_(--)"><a id="遞減運算" name="遞減運算">Decrement (--)</a></h2>
-
-<p>The decrement operator decrements (subtracts one from) its operand and returns a value.</p>
-
-<ul>
- <li>If used postfix (for example, x--), then it returns the value before decrementing.</li>
- <li>If used prefix (for example, --x), then it returns the value after decrementing.</li>
-</ul>
-
-<h3 id="Syntax_8">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> x-- or --x
-</pre>
-
-<h3 id="Examples_8">Examples</h3>
-
-<pre class="brush: js">// Postfix
-var x = 3;
-y = x--; // y = 3, x = 2
-
-// Prefix
-var a = 2;
-b = --a; // a = 1, b = 1
-</pre>
-
-<h2 id="Unary_negation_(-)"><a name="Unary_negation">Unary negation (-)</a></h2>
-
-<p>The unary negation operator precedes its operand and negates it.</p>
-
-<h3 id="Syntax_9">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> -x
-</pre>
-
-<h3 id="Examples_9">Examples</h3>
-
-<pre class="brush: js">var x = 3;
-y = -x; // y = -3, x = 3
-
-// Unary negation operator can convert non-numbers into a number
-var x = "4";
-y = -x; // y = -4
-</pre>
-
-<h2 id="Unary_plus_()"><a name="Unary_plus">Unary plus</a> (+)</h2>
-
-<p>The unary plus operator precedes its operand and evaluates to its operand but attempts to convert it into a number, if it isn't already. Although unary negation (-) also can convert non-numbers, unary plus is the fastest and preferred way of converting something into a number, because it does not perform any other operations on the number. It can convert string representations of integers and floats, as well as the non-string values <code>true</code>, <code>false</code>, and <code>null</code>. Integers in both decimal and hexadecimal ("0x"-prefixed) formats are supported. Negative numbers are supported (though not for hex). If it cannot parse a particular value, it will evaluate to {{jsxref("NaN")}}.</p>
-
-<h3 id="Syntax_10">Syntax</h3>
-
-<pre class="syntaxbox"><strong>Operator:</strong> +x
-</pre>
-
-<h3 id="Examples_10">Examples</h3>
-
-<pre class="brush: js">+3     // 3
-+'3'   // 3
-+true  // 1
-+false // 0
-+null  // 0
-+function(val){ return val } // NaN
-</pre>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Additive operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Multiplicative operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Postfix expressions</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Unary operators</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Additive operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">Multiplicative operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">Postfix expressions</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">Unary operators</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2016')}}</td>
-   <td>Added <a href="https://github.com/rwaldron/exponentiation-operator">Exponentiation operator</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2017', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2017')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-additive-operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-
-
-<p>{{Compat("javascript.operators.arithmetic")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Assignment operators</a></li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/operators/bitwise_operators/index.html b/files/zh-tw/web/javascript/reference/operators/bitwise_operators/index.html
deleted file mode 100644
index 86f78270b5..0000000000
--- a/files/zh-tw/web/javascript/reference/operators/bitwise_operators/index.html
+++ /dev/null
@@ -1,555 +0,0 @@
----
-title: 位元運算子
-slug: Web/JavaScript/Reference/Operators/Bitwise_Operators
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p><strong>位元運算子</strong>將運算元視為一段 32 位元長的 0 和 1 序列，而不是十進位、十六進位或八進位的 <code><a href="/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Numbers</a></code>。 舉例來說，十進位的 9 可以用二進位表示為 1001。位元運算子對這樣的二進位表示法進行運算，然後回傳標準 JavaScript 數值。</p>
-
-<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div>
-
-
-
-<p>下表總結了 JavaScript 的位元運算子：</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Operator</th>
-   <th>Usage</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td><a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(位元_AND)">位元 AND</a></td>
-   <td><code>a &amp; b</code></td>
-   <td>當兩運算元的該位置皆為 <code>1</code> 時，回傳值的該位置為 <code>1</code>。</td>
-  </tr>
-  <tr>
-   <td><a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(位元_OR)">位元 OR</a></td>
-   <td><code>a | b</code></td>
-   <td>當兩運算元的該位置有一者為 <code>1</code> 時，回傳值的該位置為 <code>1</code>。</td>
-  </tr>
-  <tr>
-   <td><a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(位元_XOR)">位元 XOR</a></td>
-   <td><code>a ^ b</code></td>
-   <td>當兩運算元的該位置恰好一者為 <code>1</code> 時，回傳值的該位置為 <code>1</code>。</td>
-  </tr>
-  <tr>
-   <td><a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(位元_NOT)">位元 NOT</a></td>
-   <td><code>~ a</code></td>
-   <td>將運算元的所有位元反轉。</td>
-  </tr>
-  <tr>
-   <td><a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3C%3C_(左移)">左移</a></td>
-   <td><code>a &lt;&lt; b</code></td>
-   <td>將 <code>a</code> 的二進位表示法左移 <code>b</code> (&lt; 32) 位元，右側補 <code>0</code>。</td>
-  </tr>
-  <tr>
-   <td><a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3E%3E_(保持符號右移)">保持符號右移</a></td>
-   <td><code>a &gt;&gt; b</code></td>
-   <td>將 <code>a</code> 的二進位表示法右移 <code>b</code> (&lt; 32) 位元，拋棄被移出的位元。</td>
-  </tr>
-  <tr>
-   <td><a href="https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3E%3E%3E_(填零右移)">填零右移</a></td>
-   <td><code>a &gt;&gt;&gt; b</code>  </td>
-   <td>將 <code>a</code> 的二進位表示法右移 <code>b</code> (&lt; 32) 位元，拋棄被移出的位元，並於右側補 <code>0</code>。</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="帶號的_32位元整數">帶號的 32位元整數</h2>
-
-<p>所有位元運算子的運算元皆會被轉換成二<a href="https://en.wikipedia.org/wiki/Method_of_complements">補數系統</a>下的帶號32位元整數。二補數系統意味著一個整數的加法反元素(例如 5和 -5)是該整數的所有位元反轉(位元 NOT，也就是該數的一補數) 再加一。舉例來說，下面的序列代表著整數 314：</p>
-
-<pre class="brush: js">00000000000000000000000100111010
-</pre>
-
-<p>下面的序列代表 <code>~314</code>，也就是 <code>314</code> 的一補數：</p>
-
-<pre class="brush: js">11111111111111111111111011000101
-</pre>
-
-<p>接著，下面代表著 <code>-314</code>，也就是 <code>314</code> 的二補數：</p>
-
-<pre class="brush: js">11111111111111111111111011000110
-</pre>
-
-<p>二補數系統確保了正值時最左邊的位元為 0，反之則為 1。因此，最左邊的位元被稱作符號位。</p>
-
-<p>整數 <code>0</code> 全由位元 0組成。</p>
-
-<pre class="brush: js">0 (base 10) = 00000000000000000000000000000000 (base 2)
-</pre>
-
-<p>整數 <code>-1</code> 全由位元 1組成。</p>
-
-<pre class="brush: js">-1 (base 10) = 11111111111111111111111111111111 (base 2)
-</pre>
-
-<p>整數 <code>-2147483648</code> (十六進位： <code>-0x80000000</code>) 除了第一位為 1，其餘皆由位元 0組成。</p>
-
-<pre class="brush: js">-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
-</pre>
-
-<p>整數 <code>-2147483648</code> (十六進位： <code>-0x7fffffff</code>) 除了第一位為 0，其餘皆由位元 1組成。</p>
-
-<pre class="brush: js">2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
-</pre>
-
-<p>整數 <code>-2147483648</code> 和 <code>2147483647</code> 分別為帶號32位元整數所能表示的最小值和最大值。</p>
-
-<h2 id="位元邏輯運算子">位元邏輯運算子</h2>
-
-<p>大致上，位元邏輯運算子的運作如下︰</p>
-
-<ul>
- <li>運算元會被轉換成 32位元的整數，並被表達為一系列的位元 (0 和 1)。多於 32位元的數值在轉換中其超出第32位元的部分會被捨棄。下面的多於32位元整數在被轉換時：
-  <pre class="brush: js">Before: 11100110111110100000000000000110000000000001
-After:              10100000000000000110000000000001</pre>
- </li>
- <li>兩個運算元中的位元會根據其位置兩兩一組：第一個跟第一個、第二個跟第二個 ...</li>
- <li>運算子會作用在每一組位元上，運算完成後再重新組合起來得到回傳值。</li>
-</ul>
-
-<h3 id="(位元_AND)"><a id="Bitwise_AND" name="Bitwise_AND">&amp; (位元 AND)</a></h3>
-
-<p>對每一組位元執行 AND 運算。<code>a</code> AND <code>b</code> 只在 <code>a</code> 和 <code>b</code> 同時為 <code>1</code> 時得到 1。AND運算的真值表如下：</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td class="header">a</td>
-   <td class="header">b</td>
-   <td class="header">a AND b</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>1</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
- </tbody>
-</table>
-
-<pre class="brush: js">.    9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 &amp; 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
-</pre>
-
-<p>將任何數 <code>x</code> 和 <code>0</code> 做位元 AND 皆會得到 <code>0</code>。將任何數 <code>x</code> 和 <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">-1</span></font> 做位元 AND 皆會得到 <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">x</span></font>。</p>
-
-<h3 id="(位元_OR)"><a name="Bitwise_OR">| (位元 OR)</a></h3>
-
-<p>對每一組位元執行 OR 運算。<code>a</code> OR <code>b</code> 在 <code>a</code> 和 <code>b</code> 有一者為 <code>1</code> 時得到 1。OR運算的真值表如下：</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td class="header">a</td>
-   <td class="header">b</td>
-   <td class="header">a OR b</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>0</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
- </tbody>
-</table>
-
-<pre class="brush: js">.    9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
-</pre>
-
-<p>將任何數 <code>x</code> 和 <code>0</code> 做位元 OR 皆會得到 <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">x</span></font>。將任何數 <code>x</code> 和 <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">-1</span></font> 做位元 OR 皆會得到 <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">-1</span></font>。</p>
-
-<h3 id="(位元_XOR)"><a name="Bitwise_XOR">^ (位元 XOR)</a></h3>
-
-<p>對每一組位元執行 XOR 運算。<code>a</code> XOR <code>b</code> 只在 <code>a</code> 和 <code>b</code> 恰一者為 <code>1</code> 時得到 1。XOR運算的真值表如下：</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td class="header">a</td>
-   <td class="header">b</td>
-   <td class="header">a XOR b</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>0</td>
-   <td>0</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>1</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>0</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>1</td>
-   <td>0</td>
-  </tr>
- </tbody>
-</table>
-
-<pre class="brush: js">.    9 (base 10) = 00000000000000000000000000001001 (base 2)
-    14 (base 10) = 00000000000000000000000000001110 (base 2)
-                   --------------------------------
-14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
-</pre>
-
-<p>將任何數 <code>x</code> 和 <code>0</code> 做位元 AND 皆會得到 <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">x</span></font>。將任何數 <code>x</code> 和 <font face="consolas, Liberation Mono, courier, monospace">-1</font> 做位元 AND 皆會得到 <code>~x</code>。</p>
-
-<h3 id="(位元_NOT)"><a name="Bitwise_NOT">~ (位元 NOT)</a></h3>
-
-<p>對每一個位元執行 NOT 運算。NOT <code>a</code> 會得到 <code>a</code> 的反轉值(也就是一補數)。NOT運算的真值表如下：</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td class="header">a</td>
-   <td class="header">NOT a</td>
-  </tr>
-  <tr>
-   <td>0</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td>1</td>
-   <td>0</td>
-  </tr>
- </tbody>
-</table>
-
-<pre class="brush: js"> 9 (base 10) = 00000000000000000000000000001001 (base 2)
-               --------------------------------
-~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
-</pre>
-
-<p>將任何數 <code>x</code> 做位元 NOT 皆會得到 <code>-(x + 1)</code>。舉例來說，<code>~-5</code> 會得到 <code>4</code>。</p>
-
-<p>值得注意的是，因為使用 32位元表示法表示數值 <code>~-1</code> 和 <code>~4294967295</code> (2<sup>32</sup>-1) 皆會得到 <code>0</code>。</p>
-
-<h2 id="位元位移運算子">位元位移運算子</h2>
-
-<p>位移運算子需要兩個運算元：第一個是要被位移的值，第二個是位元位移量。位移的方向取決於使用的運算子。</p>
-
-<p>位移運算子將運算元轉換成 32位元的大端序整數並回傳一個與左運算元相同類別的值。右運算元應不大於32，如果超過的話，將只會使用後 5個位元。</p>
-
-<h3 id="&lt;&lt;_(左移)"><a name="Left_shift">&lt;&lt; (左移)</a></h3>
-
-<p>將第一個運算元向左位移指定的量。被移出的位元會被拋棄，並從右側補零。</p>
-
-<p>例如，<code>9 &lt;&lt; 2</code> 會得到 36：</p>
-
-<pre class="brush: js">.    9 (base 10): 00000000000000000000000000001001 (base 2)
-                  --------------------------------
-9 &lt;&lt; 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
-</pre>
-
-<p>將任意值 <code>x</code> 左移 <code>y</code> 位元會得到 <code>x * 2 ** y</code>。</p>
-
-<h3 id=">>_(保持符號右移)"><a name="Right_shift">&gt;&gt; (保持符號右移)</a></h3>
-
-<p>將第一個運算元向右位移指定的量。被移出的位元會被拋棄，並從左側補進和原本最左端相同的位元值。因為新的最左端位元和原本的最左端位元是一樣的，符號位(最左端位元)並不會改變。「保持符號」之名便是因此。</p>
-
-<p>例如，<code>9 &gt;&gt; 2</code> 會得到 2：</p>
-
-<pre class="brush: js">.    9 (base 10): 00000000000000000000000000001001 (base 2)
-                  --------------------------------
-9 &gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
-</pre>
-
-<p>同樣地，<code>-9 &gt;&gt; 2</code> 會得到 <code>-3</code>，因為符號會保持不變。</p>
-
-<pre class="brush: js">.    -9 (base 10): 11111111111111111111111111110111 (base 2)
-                   --------------------------------
--9 &gt;&gt; 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
-</pre>
-
-<h3 id=">>>_(填零右移)"><a name="Unsigned_right_shift">&gt;&gt;&gt; (填零右移)</a></h3>
-
-<p>將第一個運算元向右位移指定的量。被移出的位元會被拋棄，並從左側補零。因為符號位變成 0，所以結果永遠都是正值。</p>
-
-<p>對非負的數來說，填零右移會得到和保持符號右移一樣的結果。例如，<code>9 &gt;&gt;&gt; 2</code> 和 <code>9 &gt;&gt; 2</code> 一樣，皆會得到 2：</p>
-
-<pre class="brush: js">.     9 (base 10): 00000000000000000000000000001001 (base 2)
-                   --------------------------------
-9 &gt;&gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
-</pre>
-
-<p>然而對負值來說並不是這麼一回事。例如，<code>-9 &gt;&gt;&gt; 2</code> 會得到 1073741821，跟 <code>-9 &gt;&gt; 2</code> (得到 <code>-3</code>)的結果是不一樣的：</p>
-
-<pre class="brush: js">.     -9 (base 10): 11111111111111111111111111110111 (base 2)
-                    --------------------------------
--9 &gt;&gt;&gt; 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
-</pre>
-
-<h2 id="範例">範例</h2>
-
-<h3 id="旗標(flags)_和遮罩_(bitmasks)">旗標(flags) 和遮罩 (bitmasks)</h3>
-
-<p>位元運算子常被用於生成、修改、和讀取旗標序列，就像是二進制的變數一般。雖然也可以使用普通變數，但使用二進制的旗標序列大大的減少了所需空間 (32 倍)。</p>
-
-<p>假設有 4個旗標：</p>
-
-<ul>
- <li>旗標 A：我們有螞蟻問題</li>
- <li>旗標 B：我們擁有一隻蝙蝠</li>
- <li>旗標 C：我們擁有一隻貓</li>
- <li>旗標 D：我們擁有一隻鴨子</li>
-</ul>
-
-<p>這些旗標倍表達成一個位元序列：DCBA。當一個旗標被立起 (set)時，其值為1。當一個旗標被放下 (clear)，其值為0。假設有一變數 <code>flags</code> 的二進位值為 0101：</p>
-
-<pre class="brush: js">var flags = 5;   // 二進位 0101
-</pre>
-
-<p>這個值表示：</p>
-
-<ul>
- <li>旗標 A為真 (我們有螞蟻問題);</li>
- <li>旗標 B為假 (我們並未擁有一隻蝙蝠);</li>
- <li>旗標 C為真 (我們擁有一隻貓);</li>
- <li>旗標 D為假 (我們並未擁有一隻鴨子);</li>
-</ul>
-
-<p>因為位元運算子進行的是 32位元操作，0101 實際上是 00000000000000000000000000000101，但前導的 0可被忽略因為他們沒有實際上的意義。</p>
-
-<p>位元遮罩則為一個可以修改且(或)讀取旗標序列的位元序列。通常為每個單獨旗標為真的「初始」值：</p>
-
-<pre class="brush: js">var FLAG_A = 1; // 0001
-var FLAG_B = 2; // 0010
-var FLAG_C = 4; // 0100
-var FLAG_D = 8; // 1000
-</pre>
-
-<p>新的位元遮罩可以透過對初始遮罩進行位元運算獲得。例如，遮罩 1011 可以透過對 FLAG_A、FLAG_B、和 FLAG_D進行 OR運算獲得：</p>
-
-<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 =&gt; 1011
-</pre>
-
-<p>Individual flag values can be extracted by ANDing them with a bitmask, where each bit with the value of one will "extract" the corresponding flag. The bitmask <em>masks</em> out the non-relevant flags by ANDing with zeroes (hence the term "bitmask"). For example, the bitmask 0100 can be used to see if flag C is set:</p>
-
-<pre class="brush: js">// if we own a cat
-if (flags &amp; FLAG_C) { // 0101 &amp; 0100 =&gt; 0100 =&gt; true
-   // do stuff
-}
-</pre>
-
-<p>A bitmask with multiple set flags acts like an "either/or". For example, the following two are equivalent:</p>
-
-<pre class="brush: js">// if we own a bat or we own a cat
-// (0101 &amp; 0010) || (0101 &amp; 0100) =&gt; 0000 || 0100 =&gt; true
-if ((flags &amp; FLAG_B) || (flags &amp; FLAG_C)) {
-   // do stuff
-}
-</pre>
-
-<pre class="brush: js">// if we own a bat or cat
-var mask = FLAG_B | FLAG_C; // 0010 | 0100 =&gt; 0110
-if (flags &amp; mask) { // 0101 &amp; 0110 =&gt; 0100 =&gt; true
-   // do stuff
-}
-</pre>
-
-<p>Flags can be set by ORing them with a bitmask, where each bit with the value one will set the corresponding flag, if that flag isn't already set. For example, the bitmask 1100 can be used to set flags C and D:</p>
-
-<pre class="brush: js">// yes, we own a cat and a duck
-var mask = FLAG_C | FLAG_D; // 0100 | 1000 =&gt; 1100
-flags |= mask;   // 0101 | 1100 =&gt; 1101
-</pre>
-
-<p>Flags can be cleared by ANDing them with a bitmask, where each bit with the value zero will clear the corresponding flag, if it isn't already cleared. This bitmask can be created by NOTing primitive bitmasks. For example, the bitmask 1010 can be used to clear flags A and C:</p>
-
-<pre class="brush: js">// no, we don't have an ant problem or own a cat
-var mask = ~(FLAG_A | FLAG_C); // ~0101 =&gt; 1010
-flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
-</pre>
-
-<p>The mask could also have been created with <code>~FLAG_A &amp; ~FLAG_C</code> (De Morgan's law):</p>
-
-<pre class="brush: js">// no, we don't have an ant problem, and we don't own a cat
-var mask = ~FLAG_A &amp; ~FLAG_C;
-flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
-</pre>
-
-<p>Flags can be toggled by XORing them with a bitmask, where each bit with the value one will toggle the corresponding flag. For example, the bitmask 0110 can be used to toggle flags B and C:</p>
-
-<pre class="brush: js">// if we didn't have a bat, we have one now,
-// and if we did have one, bye-bye bat
-// same thing for cats
-var mask = FLAG_B | FLAG_C;
-flags = flags ^ mask;   // 1100 ^ 0110 =&gt; 1010
-</pre>
-
-<p>Finally, the flags can all be flipped with the NOT operator:</p>
-
-<pre class="brush: js">// entering parallel universe...
-flags = ~flags;    // ~1010 =&gt; 0101
-</pre>
-
-<h3 id="Conversion_snippets">Conversion snippets</h3>
-
-<p>Convert a binary <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> to a decimal <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>:</p>
-
-<pre class="brush: js">var sBinString = '1011';
-var nMyNumber = parseInt(sBinString, 2);
-alert(nMyNumber); // prints 11, i.e. 1011
-</pre>
-
-<p>Convert a decimal <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> to a binary <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code>:</p>
-
-<pre class="brush: js">var nMyNumber = 11;
-var sBinString = nMyNumber.toString(2);
-alert(sBinString); // prints 1011, i.e. 11
-</pre>
-
-<h3 id="Automate_Mask_Creation">Automate Mask Creation</h3>
-
-<p>You can create multiple masks from a set of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> values, like this:</p>
-
-<pre class="brush: js">function createMask() {
-  var nMask = 0, nFlag = 0, nLen = arguments.length &gt; 32 ? 32 : arguments.length;
-  for (nFlag; nFlag &lt; nLen; nMask |= arguments[nFlag] &lt;&lt; nFlag++);
-  return nMask;
-}
-var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
-var mask2 = createMask(false, false, true); // 4, i.e.: 0100
-var mask3 = createMask(true); // 1, i.e.: 0001
-// etc.
-
-alert(mask1); // prints 11, i.e.: 1011
-</pre>
-
-<h3 id="Reverse_algorithm_an_array_of_booleans_from_a_mask">Reverse algorithm: an array of booleans from a mask</h3>
-
-<p>If you want to create an <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code> from a mask you can use this code:</p>
-
-<pre class="brush: js">function arrayFromMask(nMask) {
-  // nMask must be between -2147483648 and 2147483647
-  if (nMask &gt; 0x7fffffff || nMask &lt; -0x80000000) {
-    throw new TypeError('arrayFromMask - out of range');
-  }
-  for (var nShifted = nMask, aFromMask = []; nShifted;
-       aFromMask.push(Boolean(nShifted &amp; 1)), nShifted &gt;&gt;&gt;= 1);
-  return aFromMask;
-}
-
-var array1 = arrayFromMask(11);
-var array2 = arrayFromMask(4);
-var array3 = arrayFromMask(1);
-
-alert('[' + array1.join(', ') + ']');
-// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011
-</pre>
-
-<p>You can test both algorithms at the same time…</p>
-
-<pre class="brush: js">var nTest = 19; // our custom mask
-var nResult = createMask.apply(this, arrayFromMask(nTest));
-
-alert(nResult); // 19
-</pre>
-
-<p>For the didactic purpose only (since there is the <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code> method), we show how it is possible to modify the <code>arrayFromMask</code> algorithm in order to create a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> containing the binary representation of a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>, rather than an <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code>:</p>
-
-<pre class="brush: js">function createBinaryString(nMask) {
-  // nMask must be between -2147483648 and 2147483647
-  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag &lt; 32;
-       nFlag++, sMask += String(nShifted &gt;&gt;&gt; 31), nShifted &lt;&lt;= 1);
-  return sMask;
-}
-
-var string1 = createBinaryString(11);
-var string2 = createBinaryString(4);
-var string3 = createBinaryString(1);
-
-alert(string1);
-// prints 00000000000000000000000000001011, i.e. 11
-</pre>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.7')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Binary bitwise operators</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Binary bitwise operators</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">Binary bitwise operators</a></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<div class="hidden">
-<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
-</div>
-
-<p>{{Compat("javascript.operators.bitwise")}}</p>
-
-<h2 id="另見">另見</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Logical operators</a></li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/operators/comparison_operators/index.html b/files/zh-tw/web/javascript/reference/operators/comparison_operators/index.html
deleted file mode 100644
index f0b3e39c6e..0000000000
--- a/files/zh-tw/web/javascript/reference/operators/comparison_operators/index.html
+++ /dev/null
@@ -1,284 +0,0 @@
----
-title: 比較運算子
-slug: Web/JavaScript/Reference/Operators/Comparison_Operators
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p>JavaScript has both strict and type–converting comparisons. A strict comparison (e.g., <code>===</code>) is only true if the operands are of the same type and the contents match. The more commonly-used abstract comparison (e.g. <code>==</code>) converts the operands to the same type before making the comparison. For relational abstract comparisons (e.g., <code>&lt;=</code>), the operands are first converted to primitives, then to the same type, before comparison.</p>
-
-<p>Strings are compared based on standard lexicographical ordering, using Unicode values.</p>
-
-<p>Features of comparisons:</p>
-
-<ul>
- <li>Two strings are strictly equal when they have the same sequence of characters, same length, and same characters in corresponding positions.</li>
- <li>Two numbers are strictly equal when they are numerically equal (have the same number value). <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="NaN">NaN</a> is not equal to anything, including NaN. Positive and negative zeros are equal to one another.</li>
- <li>Two Boolean operands are strictly equal if both are <code>true</code> or both are <code>false</code>.</li>
- <li>Two distinct objects are never equal for either strict or abstract comparisons.</li>
- <li>An expression comparing Objects is only true if the operands reference the same Object.</li>
- <li>Null and Undefined Types are strictly equal to themselves and abstractly equal to each other.</li>
-</ul>
-
-<h2 id="Equality_operators">Equality operators</h2>
-
-<h3 id="Equality_()"><a name="Equality">Equality (==)</a></h3>
-
-<p>The equality operator converts the operands if they are <strong>not of the same type</strong>, then applies strict comparison. If <strong>both operands are objects</strong>, then JavaScript compares internal references which are equal when operands refer to the same object in memory.</p>
-
-<h4 id="Syntax">Syntax</h4>
-
-<pre class="syntaxbox">x == y
-</pre>
-
-<h4 id="Examples">Examples</h4>
-
-<pre class="brush: js">  1   ==  1        // true
- "1"  ==  1        // true
-  1   == '1'       // true
-  0   == false     // true
-  0   == null      // false
-var object1 = {"value":"key"}, object2={"value":"key"};
-object1 == object2 //false
-
-  0   == undefined // false
-null  == undefined // true
-</pre>
-
-<h3 id="Inequality_(!)"><a name="Inequality">Inequality (!=)</a></h3>
-
-<p>The inequality operator returns true if the operands are not equal. If the two operands are <strong>not of the same type</strong>, JavaScript attempts to convert the operands to an appropriate type for the comparison. If <strong>both operands are objects</strong>, then JavaScript compares internal references which are not equal when operands refer to different objects in memory.</p>
-
-<h4 id="Syntax_2">Syntax</h4>
-
-<pre class="syntaxbox">x != y</pre>
-
-<h4 id="Examples_2">Examples</h4>
-
-<pre class="brush: js">1 !=   2     // true
-1 !=  "1"    // false
-1 !=  '1'    // false
-1 !=  true   // false
-0 !=  false  // false
-</pre>
-
-<h3 id="Identity_strict_equality_()"><a name="Identity">Identity / strict equality (===)</a></h3>
-
-<p>The identity operator returns true if the operands are strictly equal (see above) <strong>with no type conversion</strong>. </p>
-
-<h4 id="Syntax_3">Syntax</h4>
-
-<pre class="syntaxbox">x === y</pre>
-
-<h4 id="Examples_3">Examples</h4>
-
-<pre class="brush: js ">3 === 3   // true
-3 === '3' // false
-var object1 = {"value":"key"}, object2={"value":"key"};
-object1 === object2 //false</pre>
-
-<p> </p>
-
-<h3 id="Non-identity_strict_inequality_(!)"><a name="Nonidentity">Non-identity / strict inequality (!==)</a></h3>
-
-<p>The non-identity operator returns true if the operands <strong>are not equal and/or not of the same type</strong>.</p>
-
-<h4 id="Syntax_4">Syntax</h4>
-
-<pre class="syntaxbox">x !== y</pre>
-
-<h4 id="Examples_4">Examples</h4>
-
-<pre class="brush: js">3 !== '3' // true
-4 !== 3   // true
-</pre>
-
-<h2 id="Relational_operators">Relational operators</h2>
-
-<p>Each of these operators will call the <code>valueOf()</code> function on each operand before a comparison is made.</p>
-
-<h3 id="Greater_than_operator_(>)"><a name="Greater_than_operator">Greater than operator (&gt;)</a></h3>
-
-<p>The greater than operator returns true if the left operand is greater than the right operand.</p>
-
-<h4 id="Syntax_5">Syntax</h4>
-
-<pre class="syntaxbox">x &gt; y</pre>
-
-<h4 id="Examples_5">Examples</h4>
-
-<pre class="brush: js">4 &gt; 3 // true
-</pre>
-
-<h3 id="Greater_than_or_equal_operator_(>)"><a name="Greater_than_or_equal_operator">Greater than or equal operator (&gt;=)</a></h3>
-
-<p>The greater than or equal operator returns true if the left operand is greater than or equal to the right operand.</p>
-
-<h4 id="Syntax_6">Syntax</h4>
-
-<pre class="syntaxbox"> x &gt;= y</pre>
-
-<h4 id="Examples_6">Examples</h4>
-
-<pre class="brush: js">4 &gt;= 3 // true
-3 &gt;= 3 // true
-</pre>
-
-<h3 id="Less_than_operator_(&lt;)"><a name="Less_than_operator">Less than operator (&lt;)</a></h3>
-
-<p>The less than operator returns true if the left operand is less than the right operand.</p>
-
-<h4 id="Syntax_7">Syntax</h4>
-
-<pre class="syntaxbox"> x &lt; y</pre>
-
-<h4 id="Examples_7">Examples</h4>
-
-<pre class="brush: js">3 &lt; 4 // true
-</pre>
-
-<h3 id="Less_than_or_equal_operator_(&lt;)"><a id="Less_than_or_equal_operator" name="Less_than_or_equal_operator">Less than or equal operator (&lt;=)</a></h3>
-
-<p>The less than or equal operator returns true if the left operand is less than or equal to the right operand.</p>
-
-<h4 id="Syntax_8">Syntax</h4>
-
-<pre class="syntaxbox"> x &lt;= y</pre>
-
-<h4 id="Examples_8">Examples</h4>
-
-<pre class="brush: js">3 &lt;= 4 // true
-</pre>
-
-<h2 id="Using_the_Equality_Operators">Using the Equality Operators</h2>
-
-<p>The standard equality operators (<code>==</code> and <code>!=</code>) use the <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">Abstract Equality Comparison Algorithm</a> to compare two operands. If the operands are of different types, it will attempt to convert them to the same type before making the comparison, e.g., in the expression <code>5 == '5'</code>, the string on the right is converted to {{jsxref("Number")}} before the comparison is made.</p>
-
-<p>The strict equality operators (<code>===</code> and <code>!==</code>) use the <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">Strict Equality Comparison Algorithm</a> and are intended for performing equality comparisons on operands of the same type. If the operands are of different types, the result is always <code>false</code> so <code>5 !== '5'</code>.</p>
-
-<p>Use strict equality operators if the operands must be of a specific type as well as value or if the exact type of the operands is important. Otherwise, use the standard equality operators, which allow you to compare the identity of two operands even if they are not of the same type.</p>
-
-<p>When type conversion is involved in the comparison (i.e., non–strict comparison), JavaScript converts the types {{jsxref("String")}}, {{jsxref("Number")}}, {{jsxref("Boolean")}}, or {{jsxref("Object")}} operands as follows:</p>
-
-<ul>
- <li>When comparing a number and a string, the string is converted to a number value. JavaScript attempts to convert the string numeric literal to a <code>Number</code> type value. First, a mathematical value is derived from the string numeric literal. Next, this value is rounded to nearest <code>Number</code> type value.</li>
- <li>If one of the operands is <code>Boolean</code>, the Boolean operand is converted to 1 if it is <code>true</code> and +0 if it is <code>false</code>.</li>
- <li>If an object is compared with a number or string, JavaScript attempts to return the default value for the object. Operators attempt to convert the object to a primitive value, a <code>String</code> or <code>Number</code> value, using the <code>valueOf</code> and <code>toString</code> methods of the objects. If this attempt to convert the object fails, a runtime error is generated.</li>
- <li>Note that an object is converted into a primitive if, and only if, its comparand is a primitive. If both operands are objects, they're compared as objects, and the equality test is true only if both refer the same object.</li>
-</ul>
-
-<div class="note"><strong>Note:</strong> String objects are Type Object, not String! String objects are rarely used, so the following results might be surprising:</div>
-
-<pre class="brush:js">// true as both operands are type String (i.e. string primitives):
-'foo' === 'foo'
-
-var a = new String('foo');
-var b = new String('foo');
-
-// false as a and b are type Object and reference different objects
-a == b
-
-// false as a and b are type Object and reference different objects
-a === b
-
-// true as a and 'foo' are of different type and, the Object (a)
-// is converted to String 'foo' before comparison
-a == 'foo'</pre>
-
-<h2 id="規範">規範</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.0</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Adds <code>===</code> and <code>!==</code> operators. Implemented in JavaScript 1.3</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.8')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Relational Operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Equality Operators</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-relational-operators')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-relational-operators">Relational Operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-equality-operators">Equality Operators</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://tc39.github.io/ecma262/#sec-relational-operators">Relational Operators</a>, <a href="http://tc39.github.io/ecma262/#sec-equality-operators">Equality Operators</a></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="瀏覽器相容性">瀏覽器相容性</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="參見">參見</h2>
-
-<ul>
- <li>{{jsxref("Object.is()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
- <li><a href="/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness">Equality comparisons and sameness</a></li>
-</ul>
diff --git a/files/zh-tw/web/javascript/reference/operators/logical_operators/index.html b/files/zh-tw/web/javascript/reference/operators/logical_operators/index.html
deleted file mode 100644
index 2fb07f891e..0000000000
--- a/files/zh-tw/web/javascript/reference/operators/logical_operators/index.html
+++ /dev/null
@@ -1,244 +0,0 @@
----
-title: Logical operators
-slug: Web/JavaScript/Reference/Operators/Logical_Operators
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p>邏輯運算子通常會搭配 {{jsxref("Boolean")}} (logical) 值。若是，則回傳布林值。然而， <code>&amp;&amp;</code> 和 <code>||</code>  運算子通常回傳其中一運算元的值, 因此若這些運算子搭配非布林值使用，他們會回傳非布林值。</p>
-
-<div>{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}</div>
-
-
-
-<h2 id="說明">說明</h2>
-
-<p>邏輯運算子的使用方式如下(<code><em>expr</em></code> 可能會是 <a href="/en-US/docs/Glossary/Data_structure">type</a>，不只是布林值)：</p>
-
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>Operator</th>
-   <th>Syntax</th>
-   <th>Description</th>
-  </tr>
-  <tr>
-   <td>邏輯 AND (<code>&amp;&amp;</code>)</td>
-   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
-   <td>若 <code>expr<strong>1</strong></code> 可被轉換成 <code>true</code>, 回傳 <code>expr<strong>2</strong></code>; 否則 回傳 <code>expr<strong>1</strong></code>.</td>
-  </tr>
-  <tr>
-   <td>邏輯 OR (<code>||</code>)</td>
-   <td><code><em>expr1</em> || <em>expr2</em></code></td>
-   <td>若 <code>expr<strong>1</strong></code> 可被轉換成 <code>true</code>, 回傳 <code>expr<strong>1</strong></code>; 否則 回傳 <code>expr<strong>2</strong></code>.</td>
-  </tr>
-  <tr>
-   <td>邏輯 NOT (<code>!</code>)</td>
-   <td><code>!<em>expr</em></code></td>
-   <td>回傳 <code>false</code> 若它的單一運算元可被轉換成 <code>true</code>; 否則回傳 <code>true</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<p>If a value can be converted to <code>true</code>, the value is so-called {{Glossary("truthy")}}. If a value can be converted to <code>false</code>, the value is so-called {{Glossary("falsy")}}.</p>
-
-<p>Examples of expressions that can be converted to false are:</p>
-
-<ul>
- <li><code>null</code>;</li>
- <li><code>NaN</code>;</li>
- <li><code>0</code>;</li>
- <li>empty string (<code>""</code> or <code>''</code> or <code>``</code>);</li>
- <li><code>undefined</code>.</li>
-</ul>
-
-<p>Even though the <code>&amp;&amp;</code> and <code>||</code> operators can be used with operands that are not Boolean values, they can still be considered boolean operators since their return values can always be converted to <a href="/en-US/docs/Web/JavaScript/Data_structures#Boolean_type">boolean primitives</a>. To explicitly convert their return value (or any expression in general) to the corresponding boolean value, use a double <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT">NOT operator</a> or the <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Boolean</a> constructor.</p>
-
-<h3 id="Short-circuit_evaluation">Short-circuit evaluation</h3>
-
-<p>As logical expressions are evaluated left to right, they are tested for possible "short-circuit" evaluation using the following rules:</p>
-
-<ul>
- <li><code>(some falsy expression) &amp;&amp; <em>expr</em></code> is short-circuit evaluated to the falsy expression;</li>
- <li><code>(some truthy expression) || <em>expr</em></code> is short-circuit evaluated to the truthy expression.</li>
-</ul>
-
-<p>Short circuit means that the <em>expr</em> parts above are <strong>not evaluated</strong>, hence any side effects of doing so do not take effect (e.g., if <em>expr</em> is a function call, the calling never takes place). This happens because the value of the operator is already determined after the evaluation of the first operand. See example:</p>
-
-<pre class="brush: js">function A(){ console.log('called A'); return false; }
-function B(){ console.log('called B'); return true; }
-
-console.log( A() &amp;&amp; B() );
-// logs "called A" due to the function call,
-// then logs false (which is the resulting value of the operator)
-
-console.log( B() || A() );
-// logs "called B" due to the function call,
-// then logs true (which is the resulting value of the operator)
-</pre>
-
-<h3 id="Operator_precedence">Operator precedence</h3>
-
-<p>The following expressions might seem equivalent, but they are not, because the <code>&amp;&amp;</code> operator is executed before the <code>||</code> operator (see <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">operator precedence</a>).</p>
-
-<pre class="brush: js">true || false &amp;&amp; false      // returns true, because &amp;&amp; is executed first
-(true || false) &amp;&amp; false    // returns false, because operator precedence cannot apply</pre>
-
-<h3 id="Logical_AND_()"><a name="Logical_AND">Logical AND (<code>&amp;&amp;</code>)</a></h3>
-
-<p>The following code shows examples of the <code>&amp;&amp;</code> (logical AND) operator.</p>
-
-<pre class="brush: js">a1 = true  &amp;&amp; true       // t &amp;&amp; t returns true
-a2 = true  &amp;&amp; false      // t &amp;&amp; f returns false
-a3 = false &amp;&amp; true       // f &amp;&amp; t returns false
-a4 = false &amp;&amp; (3 == 4)   // f &amp;&amp; f returns false
-a5 = 'Cat' &amp;&amp; 'Dog'      // t &amp;&amp; t returns "Dog"
-a6 = false &amp;&amp; 'Cat'      // f &amp;&amp; t returns false
-a7 = 'Cat' &amp;&amp; false      // t &amp;&amp; f returns false
-a8 = ''    &amp;&amp; false      // f &amp;&amp; f returns ""
-a9 = false &amp;&amp; ''         // f &amp;&amp; f returns false
-</pre>
-
-<h3 id="Logical_OR_()"><a name="Logical_OR">Logical OR (<code>||</code>)</a></h3>
-
-<p>The following code shows examples of the <code>||</code> (logical OR) operator.</p>
-
-<pre class="brush: js">o1 = true  || true       // t || t returns true
-o2 = false || true       // f || t returns true
-o3 = true  || false      // t || f returns true
-o4 = false || (3 == 4)   // f || f returns false
-o5 = 'Cat' || 'Dog'      // t || t returns "Cat"
-o6 = false || 'Cat'      // f || t returns "Cat"
-o7 = 'Cat' || false      // t || f returns "Cat"
-o8 = ''    || false      // f || f returns false
-o9 = false || ''         // f || f returns ""
-o10 = false || varObject // f || object returns varObject
-</pre>
-
-<h3 id="Logical_NOT_(!)"><a name="Logical_NOT">Logical NOT (<code>!</code>)</a></h3>
-
-<p>The following code shows examples of the <code>!</code> (logical NOT) operator.</p>
-
-<pre class="brush: js">n1 = !true               // !t returns false
-n2 = !false              // !f returns true
-n3 = !''                 // !f returns true
-n4 = !'Cat'              // !t returns false
-</pre>
-
-<h4 id="Double_NOT_(!!)">Double NOT (<code>!!</code>)</h4>
-
-<p>It is possible to use a couple of NOT operators in series to explicitly force the conversion of any value to the corresponding <a href="/en-US/docs/Web/JavaScript/Data_structures#Boolean_type">boolean primitive</a>. The conversion is based on the "truthyness" or "falsyness" of the value (see {{Glossary("truthy")}} and {{Glossary("falsy")}}).</p>
-
-<p>The same conversion can be done through the {{jsxref("Boolean")}} function.</p>
-
-<pre class="brush: js">n1 = !!true                   // !!truthy returns true
-n2 = !!{}                     // !!truthy returns true: <strong>any</strong> object is truthy...
-n3 = !!(new Boolean(false))   // ...even Boolean objects with a false <em>.valueOf()</em>!
-n4 = !!false                  // !!falsy returns false
-n5 = !!""                     // !!falsy returns false
-n6 = !!Boolean(false)         // !!falsy returns false
-</pre>
-
-<h3 id="Conversion_rules_for_booleans">Conversion rules for booleans</h3>
-
-<h4 id="Converting_AND_to_OR">Converting AND to OR</h4>
-
-<p>The following operation involving <strong>booleans</strong>:</p>
-
-<pre class="brush: js">bCondition1 &amp;&amp; bCondition2</pre>
-
-<p>is always equal to:</p>
-
-<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre>
-
-<h4 id="Converting_OR_to_AND">Converting OR to AND</h4>
-
-<p>The following operation involving <strong>booleans</strong>:</p>
-
-<pre class="brush: js">bCondition1 || bCondition2</pre>
-
-<p>is always equal to:</p>
-
-<pre class="brush: js">!(!bCondition1 &amp;&amp; !bCondition2)</pre>
-
-<h4 id="Converting_between_NOTs">Converting between NOTs</h4>
-
-<p>The following operation involving <strong>booleans</strong>:</p>
-
-<pre class="brush: js">!!bCondition</pre>
-
-<p>is always equal to:</p>
-
-<pre class="brush: js">bCondition</pre>
-
-<h3 id="Removing_nested_parentheses">Removing nested parentheses</h3>
-
-<p>As logical expressions are evaluated left to right, it is always possible to remove parentheses from a complex expression following some rules.</p>
-
-<h4 id="Removing_nested_AND">Removing nested AND</h4>
-
-<p>The following composite operation involving <strong>booleans</strong>:</p>
-
-<pre class="brush: js">bCondition1 || (bCondition2 &amp;&amp; bCondition3)</pre>
-
-<p>is always equal to:</p>
-
-<pre class="brush: js">bCondition1 || bCondition2 &amp;&amp; bCondition3</pre>
-
-<h4 id="Removing_nested_OR">Removing nested OR</h4>
-
-<p>The following composite operation involving <strong>booleans</strong>:</p>
-
-<pre class="brush: js">bCondition1 &amp;&amp; (bCondition2 || bCondition3)</pre>
-
-<p>is always equal to:</p>
-
-<pre class="brush: js">!(!bCondition1 || !bCondition2 &amp;&amp; !bCondition3)</pre>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.11')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.9">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.11">Binary Logical Operators</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">Binary Logical Operators</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Defined in several sections of the specification: <a href="http://tc39.github.io/ecma262/#sec-logical-not-operator">Logical NOT Operator</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-logical-operators">Binary Logical Operators</a></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-
-
-<p>{{Compat("javascript.operators.logical")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li>
- <li>{{jsxref("Boolean")}}</li>
- <li><a href="/en-US/docs/Glossary/Truthy">Truthy</a></li>
- <li><a href="/en-US/docs/Glossary/Falsy">Falsy</a></li>
-</ul>