path: root/files/zh-tw/web/javascript/guide/expressions_and_operators/index.html

---
title: 運算式與運算子
slug: Web/JavaScript/Guide/Expressions_and_Operators
translation_of: Web/JavaScript/Guide/Expressions_and_Operators
---
<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Functions", "Web/JavaScript/Guide/Numbers_and_dates")}}</div>

<p class="summary">這個章節將講述 JavaScript 的運算式與運算子，包括賦值運算子，比較運算子，算術運算子，位元運算子， 邏輯運算子, 字串運算子, 條件(三元)運算子 以及更多運算子.</p>

<p>更多關於運算子以及運算式的資料可以在 <a href="/en-US/docs/Web/JavaScript/Reference/Operators">reference</a> 中找到。</p>

<h2 id="運算子">運算子</h2>

<p>JavaScript 有以下幾種運算子。 此處將描述運算子以及一些運算子的優先順序。</p>

<ul>
 <li>{{ web.link("#賦值運算子", "賦值運算子") }}</li>
 <li>{{ web.link("#比較運算子", "比較運算子") }}</li>
 <li>{{ web.link("#算術運算子", "算術運算子") }}</li>
 <li>{{ web.link("#位元運算子", "位元運算子") }}</li>
 <li>{{ web.link("#邏輯運算子", "邏輯運算子") }}</li>
 <li>{{ web.link("#字串運算子", "字串運算子") }}</li>
 <li>{{ web.link("#條件(三元)運算子", "條件(三元)運算子")}}</li>
 <li>{{ web.link("#逗點運算子", "逗點運算子")}}</li>
 <li>{{ web.link("#一元運算子", "一元運算子")}}</li>
 <li>{{ web.link("#關係運算子", "關係運算子")}}</li>
</ul>

<p>JavaScript 同時具有二元運算子及一元運算子， 以及一種特殊的 三元運算子，也就是 條件運算子。 一個二元運算子需要具備兩個運算元， 一個在運算元之前，一個在運算元之後:</p>

<pre class="syntaxbox notranslate"><em>運算元1</em> <em>運算子</em> <em>運算元2</em>
</pre>

<p>例如, <code>3+4</code> 或 <code>x*y</code>.</p>

<p>一個 一元運算子 需要一個運算元， 位於運算子之前或之後:</p>

<pre class="syntaxbox notranslate"><em>運算子</em> <em>運算元</em>
</pre>

<p>或</p>

<pre class="syntaxbox notranslate"><em>運算元 運算子</em>
</pre>

<p>例如， <code>x++</code> 或 <code>++x</code>.</p>

<h3 id="賦值運算子">賦值運算子</h3>

<p>一個 <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">賦值運算子</a> 將 基於其 右方的運算元 的值賦予其 左方的運算元。 最簡單的 賦值運算子 是 等於 (<code>=</code>)， 它將賦予 左方運算元 與 右方運算元相同之值。 也就是， <code>x = y</code> 會把y的值賦予給x。</p>

<p>也有一些復合的 賦值運算子 是為了縮短下面表中的運算:</p>

<table class="standard-table">
 <caption>復合運算子</caption>
 <thead>
  <tr>
   <th>名稱</th>
   <th>簡化的運算子</th>
   <th>意義</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">賦值</a></td>
   <td><code>x = y</code></td>
   <td><code>x = y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Addition_assignment">加法</a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">賦值</a></td>
   <td><code>x += y</code></td>
   <td><code>x = x + y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Subtraction_assignment">減法</a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">賦值</a></td>
   <td><code>x -= y</code></td>
   <td><code>x = x - y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Multiplication_assignment">乘法</a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">賦值</a></td>
   <td><code>x *= y</code></td>
   <td><code>x = x * y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Division_assignment">除法</a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">賦值</a></td>
   <td><code>x /= y</code></td>
   <td><code>x = x / y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Remainder_assignment">餘數</a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">賦值</a></td>
   <td><code>x %= y</code></td>
   <td><code>x = x % y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Exponentiation_assignment">指數</a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Assignment">賦值</a></td>
   <td><code>x **= y</code></td>
   <td><code>x = x ** y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Left_shift_assignment">左移賦值</a></td>
   <td><code>x &lt;&lt;= y</code></td>
   <td><code>x = x &lt;&lt; y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Right_shift_assignment">右移賦值</a></td>
   <td><code>x &gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt; y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Unsigned_right_shift_assignment">無號右移賦值</a></td>
   <td><code>x &gt;&gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt;&gt; y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Bitwise_AND_assignment">位元 AND 賦值</a></td>
   <td><code>x &amp;= y</code></td>
   <td><code>x = x &amp; y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Bitwise_XOR_assignment">位元 XOR 賦值</a></td>
   <td><code>x ^= y</code></td>
   <td><code>x = x ^ y</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators#Bitwise_OR_assignment">位元 OR 賦值</a></td>
   <td><code>x |= y</code></td>
   <td><code>x = x | y</code></td>
  </tr>
 </tbody>
</table>

<h4 id="解構">解構</h4>

<p>為了進行更複雜的賦值，<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">解構賦值</a>是 JavaScript 用來從陣列或物件中提取資料的語法。</p>

<pre class="brush: js notranslate">var foo = ['one', 'two', 'three'];

// 不使用解構
var one   = foo[0];
var two   = foo[1];
var three = foo[2];

// 使用解構
var [one, two, three] = foo;</pre>

<h3 id="比較運算子">比較運算子</h3>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">比較運算子</a> 會比較 運算元 並基於比較的結果回傳邏輯值。 運算元可以是數字，字串，邏輯，或物件的值。 字串的比較是基於字典序的， 使用 Unicode 的值。 在多數情況下，假如兩個運算元不具有相同型態， JavaScript 會嘗試將它們轉換成相同型態。這個行為通常是將運算元以數學形式對待。 在某些的轉換型態的例外中會使用到 <code>===</code> 及 <code>!==</code> 運算子， 它們會嚴格地進行相等或不相等的比較。 這些運算子不會在確認相等與否前嘗試轉換運算元的型態。 下面的表解釋了比較運算子:</p>

<pre class="brush: js notranslate">var var1 = 3;
var var2 = 4;
</pre>

<table class="standard-table">
 <caption>比較運算子</caption>
 <thead>
  <tr>
   <th scope="col">運算子</th>
   <th scope="col">描述</th>
   <th scope="col">會回傳True的例子</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality">等於</a> (<code>==</code>)</td>
   <td>假如運算元等價就回傳True。</td>
   <td><code>3 == var1</code>
    <p><code>"3" == var1</code></p>
    <code>3 == '3'</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Inequality">不等於</a> (<code>!=</code>)</td>
   <td>假如運算元等價就回傳True。</td>
   <td><code>var1 != 4<br>
    var2 != "3"</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Identity">嚴格等於</a> (<code>===</code>)</td>
   <td>假如運算元具有相同型態且等價則回傳True。參考 {{jsxref("Object.is")}} 及 <a href="/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness" title="/en-US/docs/Web/JavaScript/Guide/Sameness">JS中的等價性</a>。</td>
   <td><code>3 === var1</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Nonidentity">嚴格不等於</a> (<code>!==</code>)</td>
   <td>假如運算元具有相同型態但不等價，或是具有不同型態，回傳True。</td>
   <td><code>var1 !== "3"<br>
    3 !== '3'</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_operator">大於</a> (<code>&gt;</code>)</td>
   <td>假如左方運算元大於右方運算元，回傳True。</td>
   <td><code>var2 &gt; var1<br>
    "12" &gt; 2</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_or_equal_operator">大於或等於</a> (<code>&gt;=</code>)</td>
   <td>假如左方運算元大於或等於右方運算元，回傳True。</td>
   <td><code>var2 &gt;= var1<br>
    var1 &gt;= 3</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than_operator">小於</a> (<code>&lt;</code>)</td>
   <td>假如左方運算元小於右方運算元，回傳True。</td>
   <td><code>var1 &lt; var2<br>
    "2" &lt; 12</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than_or_equal_operator">小於或等於</a> (<code>&lt;=</code>)</td>
   <td>假如左方運算元小於或等於右方運算元，回傳True。</td>
   <td><code>var1 &lt;= var2<br>
    var2 &lt;= 5</code></td>
  </tr>
 </tbody>
</table>

<div class="note">
<p><strong>筆記: </strong>(<strong>=&gt;)不是運算子，是</strong> <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">箭頭函式。</a></p>
</div>

<h3 id="算術運算子">算術運算子</h3>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">算術運算子</a> 以 數值 (文字或變數也可以)作為其運算元，並回傳單一數值。最常見的算術運算元是 加法 (<code>+</code>)，減法 (<code>-</code>)， 乘法 (<code>*</code>)，及除法 (<code>/</code>)。 這些運算子在大多數程式語言中功能相同 (比較特別的是，在除數為0時 {{jsxref("Infinity")}})。例如:</p>

<pre class="brush: js notranslate">1 / 2; // 0.5
1 / 2 == 1.0 / 2.0; // 會是 true
</pre>

<p>除了標準的算術運算子外 (+, -, * /)， JavaScript 提供以下表中的算術運算子:</p>

<table class="fullwidth-table">
 <caption>算術運算子</caption>
 <thead>
  <tr>
   <th scope="col">運算子</th>
   <th scope="col">描述</th>
   <th scope="col">範例</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder">取餘數</a> (<code>%</code>)</td>
   <td>二元運算子。回傳兩個運算元相除後的餘數。</td>
   <td>12 % 5 回傳 2.</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment">增加</a> (<code>++</code>)</td>
   <td>一元運算子。 將運算元增加1。假如使用在運算元之前 (<code>++x</code>)，會運算元回傳增加1後的值;假如使用在運算元之後。 (<code>x++</code>)<code>，</code> 會回傳運算元加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><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement">減少</a> (<code>--</code>)</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><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_negation">(一元運算子)減號</a> (<code>-</code>)</td>
   <td>一元運算子。回傳運算元的負數。</td>
   <td>假如x是3，-x 回傳 -3。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus">(一元運算子)加號</a> (<code>+</code>)</td>
   <td>一元運算子。嘗試將運算元轉換成數字，假如它還不是數字的話。</td>
   <td><code>+"3"</code> <code>回傳 3</code>。<br>
    <code>+true</code> 回傳 <code>1.</code></td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation">指數運算子</a> (<code>**</code>) {{experimental_inline}}</td>
   <td>計算以 a 為底的 <code>b</code> 次方， 也就是, a<code><sup>b</sup></code></td>
   <td><code>2 ** 3</code> <code>回傳 8</code>.<br>
    <code>10 ** -1</code> 回傳 <code>0.1</code>.</td>
  </tr>
 </tbody>
</table>

<h3 id="位元運算子">位元運算子</h3>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">位元運算子</a> 把運算元當作 32 位元的集合來看待 (0和1)， 而不是十進位，十六進位，或八進位。例如，十進位數字 9 以二進位表示就是  1001。 位元運算子將運算元以上述二進位的形式處理，但是回傳 Javascript 中的數字類型值。</p>

<p>下列表總結了 JavaScript' 中的位元運算子。</p>

<table class="standard-table">
 <caption>位元運算子</caption>
 <thead>
  <tr>
   <th scope="col">運算子</th>
   <th scope="col">用法</th>
   <th scope="col">描述</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_AND">位元 AND</a></td>
   <td><code>a &amp; b</code></td>
   <td>回傳兩個運算元對於每個bit做AND的結果。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_OR">位元 OR</a></td>
   <td><code>a | b</code></td>
   <td>回傳兩個運算元對於每個bit做OR的結果。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">位元 XOR</a></td>
   <td><code>a ^ b</code></td>
   <td>回傳兩個運算元對於每個bit做XOR的結果。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_NOT">位元 NOT</a></td>
   <td><code>~ a</code></td>
   <td>將運算元中的每個bit反轉(1-&gt;0,0-&gt;1)。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Left_shift">左移</a></td>
   <td><code>a &lt;&lt; b</code></td>
   <td>將 <code>a</code> 的每個bit向左移動 <code>b</code> 個bits，空餘的位數以0填滿。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Right_shift">有號右移</a></td>
   <td><code>a &gt;&gt; b</code></td>
   <td>將 <code>a</code> 的每個bit向右移動 <code>b</code> 個bits，空餘位數以最高位補滿。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Unsigned_right_shift">以0填充的右移</a></td>
   <td><code>a &gt;&gt;&gt; b</code></td>
   <td>將 <code>a</code> 的每個bit向右移動 <code>b</code> 個bits，空餘的位數以0填滿。</td>
  </tr>
 </tbody>
</table>

<h4 id="Bitwise_Logical_Operators" name="Bitwise_Logical_Operators">位元邏輯運算子</h4>

<p>概念上，位元邏輯運算子運作過程如下:</p>

<ul>
 <li>運算元被轉換為32 bits 的整數以二進位形式表示 (0 和 1)。大於 32 bits 的數字將被捨棄多出來的位元。例如， 下列整數大於32個bit但是會被轉換為32個bit的整數:
  <pre class="notranslate">轉換之前:  11100110111110100000000000000110000000000001
轉換之後:              10100000000000000110000000000001</pre>
 </li>
 <li>第一個運算元中的每個bit分別對應到第二個運算元的每個bit: 第一個 bit 對 第一個 bit, 第二個 bit 對 第二個 bit， 以此類推。</li>
 <li>運算子會對於 bit 進行運算， 結果也是基於bit 來決定的。</li>
</ul>

<p>例如， 9 的二元表示法是 1001， 15 的二元表示法是 1111。因此，在使用位元運算子的時候，結果如下:</p>

<table class="standard-table">
 <caption>位元運算子範例</caption>
 <thead>
  <tr>
   <th scope="col">運算式</th>
   <th scope="col">結果</th>
   <th scope="col">二元描述式</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>15 &amp; 9</code></td>
   <td><code>9</code></td>
   <td><code>1111 &amp; 1001 = 1001</code></td>
  </tr>
  <tr>
   <td><code>15 | 9</code></td>
   <td><code>15</code></td>
   <td><code>1111 | 1001 = 1111</code></td>
  </tr>
  <tr>
   <td><code>15 ^ 9</code></td>
   <td><code>6</code></td>
   <td><code>1111 ^ 1001 = 0110</code></td>
  </tr>
  <tr>
   <td><code>~15</code></td>
   <td><code>-16</code></td>
   <td><code>~</code><code>00000000...</code><code>00001111 = </code><code>1111</code><code>1111</code><code>...</code><code>11110000</code></td>
  </tr>
  <tr>
   <td><code>~9</code></td>
   <td><code>-10</code></td>
   <td><code>~</code><code>00000000</code><code>...</code><code>0000</code><code>1001 = </code><code>1111</code><code>1111</code><code>...</code><code>1111</code><code>0110</code></td>
  </tr>
 </tbody>
</table>

<p>注意，在使用 位元NOT 運算子時， 所有的32個bit都被進行NOT了，包含最左邊用來描述正負數的位元(two's-complement representation)。</p>

<h4 id="Bitwise_Shift_Operators" name="Bitwise_Shift_Operators">位元移動運算子</h4>

<p>位元移動運算子需要兩個運算元: 第一個是運算的目標，第二個是要移動的位元數。移動的方向取決於使用的運算子。</p>

<p>移動運算子會將運算元轉換成32 bits的整數，並且會回傳與左方運算元相同的型態。</p>

<p>移動運算子在下表被列出.</p>

<table class="fullwidth-table">
 <caption>位元移動運算子</caption>
 <thead>
  <tr>
   <th scope="col">運算子</th>
   <th scope="col">描述</th>
   <th scope="col">範例</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#&lt;&lt;_(Left_shift)">左移</a><br>
    (<code>&lt;&lt;</code>)</td>
   <td>這個運算子會將第 一個運算元的每個bit向左移動 第二個運算元所指定的bit數量。左邊超出的位數會被捨棄，右邊空出的位數以0補齊。</td>
   <td><code>9&lt;&lt;2</code> 得到 36，因為1001 向左移動 2 bits 會得到 100100， 也就是二進位的 36。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#>>_(Sign-propagating_right_shift)">有號右移</a> (<code>&gt;&gt;</code>)</td>
   <td>這個運算子會將第 一個運算元的每個bit向右移動 第二個運算元所指定的bit數量。右邊超出的位數會被捨棄，左邊空出的位數以最高位補齊。</td>
   <td><code>9&gt;&gt;2</code> 得到 2，因為 1001 向右移動 2 bits 會得到 10，也就是二進位的 2。 相同的， <code>-9&gt;&gt;2</code> 會得到 -3，因為最高位用來表示正負號的bit被保留了。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#>>>_(Zero-fill_right_shift)">以0填充的右移</a> (<code>&gt;&gt;&gt;</code>)</td>
   <td>這個運算子會將第 一個運算元的每個bit向右移動 第二個運算元所指定的bit數量。右邊超出的位數會被捨棄，左邊空出的位數以0補齊。</td>
   <td><code>19&gt;&gt;&gt;2 得到</code> 4， 因為 10011 向右移動 2 bits 會得到 100，是二進位的 4。對於非負的數字而言， 以0填充的右移 會得到和 有號右移相同的結果。</td>
  </tr>
 </tbody>
</table>

<h3 id="邏輯運算子">邏輯運算子</h3>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators">邏輯運算子</a> 通常被用於布林(邏輯)值; 使用於 布林(邏輯)值時， 它們會回傳布林型態的值。 然而，<code>&amp;&amp;</code> 和 <code>||</code> 運算子實際上是回傳兩指定運算元之一，因此用於非布林型態值時，它可能會回傳一個非布林型態的值。 邏輯運算子將在下表中被詳細解釋。</p>

<table class="fullwidth-table">
 <caption>Logical operators</caption>
 <thead>
  <tr>
   <th scope="col">Operator</th>
   <th scope="col">Usage</th>
   <th scope="col">Description</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND">邏輯 AND</a><code> </code>(<code>&amp;&amp;</code>)</td>
   <td><code>運算式1 &amp;&amp; 運算式2</code></td>
   <td>假如<code> 運算式1</code> 可以被轉換成 false的話，回傳 <code>運算式1</code>; 否則，回傳 <code>運算式2</code>。 因此，<code>&amp;&amp;</code>只有在 兩個運算元都是True 時才會回傳 True，否則回傳<code> false</code>。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR">邏輯 OR </a>(<code>||</code>)</td>
   <td><code>運算式1 || 運算式2</code></td>
   <td>假如<code> 運算式1</code> 可以被轉換成 true的話，回傳 <code>運算式1</code>; 否則，回傳 <code>運算式2</code>。 因此，<code>||</code>在 兩個運算元有任一個是True 時就會回傳 True，否則回傳<code> false</code>。</td>
  </tr>
  <tr>
   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT">邏輯 NOT </a>(<code>!</code>)</td>
   <td><code>!運算式</code></td>
   <td>假如單一個運算元能被轉換成True時，回傳<code>false</code> ， 不然回傳 <code>true</code>。</td>
  </tr>
 </tbody>
</table>

<p>可以被轉換為 false 的運算式是 null， 0， NaN， 空字串 ("")，或 未定義。</p>

<p>下面是 <code>&amp;&amp;</code> (邏輯 AND) 運算子 的範例。</p>

<pre class="brush: js notranslate">var a1 =  true &amp;&amp; true;     // t &amp;&amp; t 回傳 true
var a2 =  true &amp;&amp; false;    // t &amp;&amp; f 回傳 false
var a3 = false &amp;&amp; true;     // f &amp;&amp; t 回傳 false
var a4 = false &amp;&amp; (3 == 4); // f &amp;&amp; f 回傳 false
var a5 = "Cat" &amp;&amp; "Dog";    // t &amp;&amp; t 回傳 Dog
var a6 = false &amp;&amp; "Cat";    // f &amp;&amp; t 回傳 false
var a7 = "Cat" &amp;&amp; false;    // t &amp;&amp; f 回傳 false
</pre>

<p>下列是 || (邏輯 OR) 運算子的範例。</p>

<pre class="brush: js notranslate">var o1 =  true || true;     // t || t 回傳 true
var o2 = false || true;     // f || t 回傳 true
var o3 =  true || false;    // t || f 回傳 true
var o4 = false || (3 == 4); // f || f 回傳 false
var o5 = 'Cat' || 'Dog';    // t || t 回傳 Cat
var o6 = false || 'Cat';    // f || t 回傳 Cat
var o7 = 'Cat' || false;    // t || f 回傳 Cat
</pre>

<p>下列是 ! (邏輯 NOT) 運算子的範例。</p>

<pre class="brush: js notranslate">var n1 = !true;  // !t 回傳 false
var n2 = !false; // !f 回傳 true
var n3 = !'Cat'; // !t 回傳 false
</pre>

<h4 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">短路解析</h4>

<p>邏輯運算式是由左向右解析的， 他們會以下列規則嘗試進行 短路解析:</p>

<ul>
 <li><code>false</code> &amp;&amp;<em> 任何東西  </em> 是 false 的短路解析。</li>
 <li><code>true</code> || <em>任何東西  </em> 是 true 的短路解析。</li>
</ul>

<p>這些規則保證 解析總是正確的。 值得注意的地方是，剩餘部分的運算式並沒有被解析，所以不會占用任何效能。</p>

<h3 id="字串運算子">字串運算子</h3>

<p>除了作為比較運算子之外， 運算子 (+) 也能用於字串，將兩字串接在一起，並回傳接在一起後的結果。</p>

<p>例如，</p>

<pre class="brush: js notranslate">console.log('我的 ' + '字串'); // 會印出 字串 "我的字串"。</pre>

<p>簡化的設定運算子 += 也能用於串接字串。</p>

<p>例如，</p>

<pre class="brush: js notranslate">var mystring = '字';
mystring += '母'; // 得到 "字母" 並賦與給變數 mystring.</pre>

<h3 id="條件（三元）運算子">條件（三元）運算子</h3>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator">條件運算子</a> 是 JavaScript 中唯一需要三個運算元的運算子。 這個運算子接受兩個運算元作為值且一個運算元作為條件。 語法是:</p>

<pre class="syntaxbox notranslate"><em>條件</em> ? <em>值1</em> : <em>值2</em>
</pre>

<p>如果 <em>條件</em> 為 true，運算子回傳 <em>值1，</em> 否則回傳 <em>值2。</em> 你可以在任何使用標準運算子的地方改用 條件運算子。</p>

<p>例如，</p>

<pre class="brush: js notranslate">var status = (age &gt;= 18) ? '成人' : '小孩';
</pre>

<p>這個陳述句會將 "成人" 賦與給變數 <code>status</code> 假如 <code>age</code> 大於等於18。 否則，會將 "小孩" 賦與給變數 <code>status</code>。</p>

<h3 id="Comma_operator" name="Comma_operator">逗號運算子</h3>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator">逗點運算子</a> (<code>,</code>) 作用是解析兩個運算元並回傳後面那個運算元的值。 這個運算子通常用於for迴圈內部，讓多個變數能在每次迴圈中被更新。</p>

<p>例如，假如 <code>a</code> 是一個有十個物件在裡面的二維陣列， 下面的程式中就使用了逗點運算子來同時更新兩個變數。 這段程式碼會印出陣列中所有對角線上的物件:</p>

<pre class="brush: js notranslate">for (var i = 0, j = 9; i &lt;= j; i++, j--)
  console.log('a[' + i + '][' + j + ']= ' + a[i][j]);
</pre>

<h3 id="一元運算子">一元運算子</h3>

<p>一元運算 是只需要一個運算元的運算。</p>

<h4 id="delete" name="delete"><code>delete</code></h4>

<p><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code> 運算子會刪除物件，物件的性質，或是陣列中指定 index 的物件。 語法是:</p>

<pre class="brush: js notranslate">delete 物件名稱;
delete 物件名稱.性質;
delete 物件名稱[索引];
delete 性質; // 只有在 with 陳述句中可以使用
</pre>

<p><code>物件名稱</code> 是物件的名稱， 性質 是物件中的一個特性， 索引 是用來表示物件在陣列中位置的一個整數。</p>

<p>第四種形式只有在 <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> 陳述句中可用， 用來刪除物件中的一個特性。</p>

<p>你可以用 <code>delete</code> 運算子來刪除隱式宣告的變數， 但不適用於使用 var 宣告的變數。</p>

<p>假如 <code>delete</code> 運算子使用成功， 它會將物件 或是 物件的特性設定為 <code>未定義。</code> <code>delete</code> 運算子會在運算成功時回傳 true ，失敗時回傳 <code>false</code> 。</p>

<pre class="brush: js notranslate">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>

<h5 id="刪除陣列元素">刪除陣列元素</h5>

<p>在你刪除了陣列中的一個元素後， 陣列的長度並不會改變。 例如， 假如你<code>刪除 a[3]</code>， <code>a[4]</code> 依然是 <code>a[4]</code> 而 <code>a[3]</code> 為 未定義。</p>

<p>當使用 <code>delete</code> 運算子刪除陣列中的一個元素後， 那個元素便不再存在於陣列中了。 在下面的程式中， <code>trees[3]</code> 被用 delete 移除了。然而， <code>trees[3]</code> 的記憶體位址仍可用並且會回傳 未定義。</p>

<pre class="brush: js notranslate">var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];
if (3 in trees) {
  // 不會執行到這裡
}
</pre>

<p>假如你希望給予陣列元素 未定義 的值， 你可以直接使用 <code>undefined</code> 關鍵字而不是使用 delete 運算子。 下列範例中， <code>trees[3]</code> 被指定了 <code>undefined</code>， 然而陣列元素依然存在:</p>

<pre class="brush: js notranslate">var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees[3] = undefined;
if (3 in trees) {
  // 會執行這裡
}
</pre>

<h4 id="typeof" name="typeof"><code>typeof</code></h4>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof"><code>typeof</code> 運算子</a> 能以下列任一方式使用:</p>

<pre class="syntaxbox notranslate">typeof 運算元
typeof (運算元)
</pre>

<p><code>typeof</code> 運算子會回傳代表運算元類型的 字串。 <code>運算元能是字串，變數，關鍵字，或是會回傳型態的物件。</code> 括號是可有可無的。</p>

<p>假設你定義了以下這些變數:</p>

<pre class="brush: js notranslate">var myFun = new Function('5 + 2');
var shape = 'round';
var size = 1;
var today = new Date();
</pre>

<p><code>typeof</code> 運算子會回傳下列結果:</p>

<pre class="brush: js notranslate">typeof myFun;       // 回傳 "function"
typeof shape;       // 回傳 "string"
typeof size;        // 回傳 "number"
typeof today;       // 回傳 "object"
typeof doesntExist; // 回傳 "undefined"
</pre>

<p>對於 <code>true</code> 和 <code>null關鍵字，</code> <code>typeof</code> 運算子會回傳下列結果:</p>

<pre class="brush: js notranslate">typeof true; // 回傳 "boolean"
typeof null; // 回傳 "object"
</pre>

<p>對於字串或數字， <code>typeof</code> 運算子會回傳下列結果:</p>

<pre class="brush: js notranslate">typeof 62;            // 回傳 "number"
typeof 'Hello world'; // 回傳 "string"
</pre>

<p>對於特性，<code>typeof</code> 運算子會回傳 特性的值的類型:</p>

<pre class="brush: js notranslate">typeof document.lastModified; // 回傳 "string"
typeof window.length;         // 回傳 "number"
typeof Math.LN2;              // 回傳 "number"
</pre>

<p>對於 方法 及 函式， <code>typeof</code> 運算子會回傳下列結果:</p>

<pre class="brush: js notranslate">typeof blur;        // 回傳 "function"
typeof eval;        // 回傳 "function"
typeof parseInt;    // 回傳 "function"
typeof shape.split; // 回傳 "function"
</pre>

<p>對於內建定義的物件， <code>typeof</code> 運算子會回傳下列結果:</p>

<pre class="brush: js notranslate">typeof Date;     // 回傳 "function"
typeof Function; // 回傳 "function"
typeof Math;     // 回傳 "object"
typeof Option;   // 回傳 "function"
typeof String;   // 回傳 "function"
</pre>

<h4 id="void" name="void"><code>void</code></h4>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/void"><code>void</code> 運算子 </a>能以下列任一方式使用:</p>

<pre class="syntaxbox notranslate">void (運算式)
void 運算式
</pre>

<p><code>void</code> 運算子會解析運算式而不回傳任何值。 <code>運算式</code> 是 JavaScript 中要解析的對象。 括號是可有可無的，但是建議使用。</p>

<p>你可以使用 <code>void</code> 運算子來解析超連結中的運算式。 運算式會被解析而不會在當前頁面被印出。</p>

<p>下列範例是一個在點擊時甚麼都不做的超連結。 當使用者點擊連結時， <code>void(0)</code> 被解析為 未定義， 而甚麼都不會發生。</p>

<pre class="brush: html notranslate">&lt;a href="javascript:void(0)"&gt;點擊這裡，甚麼都不會發生&lt;/a&gt;
</pre>

<p>下列範例是一個在使用者點擊時傳送表單的超連結。</p>

<pre class="brush: html notranslate">&lt;a href="javascript:void(document.form.submit())"&gt;
點擊以送出&lt;/a&gt;</pre>

<h3 id="關係運算子">關係運算子</h3>

<p>關係運算子比較兩運算元並基於比較結果回傳布林值。</p>

<h4 id="in"><code>in</code></h4>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/in"><code>in </code>運算子</a> 在指定性質存在於物件中時回傳 true 。 語法是:</p>

<pre class="brush: js notranslate">性質名稱 in 物件名稱
</pre>

<p>性質名稱 可以是 字串或數字，或是陣列的索引， 且<code> </code>物件名稱 是物件的名稱。</p>

<p>下列範例示範了 <code>in</code> 運算子的一些用法。</p>

<pre class="brush: js notranslate">// 陣列
var trees = ['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 是陣列的性質之一)

// 內建物件
'PI' in Math;          // 回傳 true
var myString = new String("coral");
'length' in myString;  // 回傳 true

// 自訂義物件
var mycar = { make: 'Honda', model: 'Accord', year: 1998 };
'make' in mycar;  // 回傳 true
'model' in mycar; // 回傳 true
</pre>

<h4 id="instanceof" name="instanceof"><code>instanceof</code></h4>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/instanceof"><code>instanceof</code> 運算子</a> 在 指定物件 具有 指定的物件型態 時回傳 true。 語法是:</p>

<pre class="syntaxbox notranslate">物件名稱 instanceof 物件類型
</pre>

<p><code>物件名稱</code> 是用來與 物件類型 比較的物件的名字， 物件類型 是物件的類型， 例如 {{jsxref("Date")}} 或 {{jsxref("Array")}}。</p>

<p>當你需要在程式執行中確認物件的形態時，你可以使用 ins<code>tanceof</code> 運算子。 例如，當捕捉到例外時， 你可以依照例外的類型來決定用來處理意外的程式碼。</p>

<p>例如，下列程式碼使用 <code>instanceof</code> 來判斷變數 <code>theDay</code> 是不是 <code>Date</code> 類型的物件。 因為 <code>theDay</code> 是 <code>Date</code> 類型的物件， 所以if 陳述中的陳述句會被執行。</p>

<pre class="brush: js notranslate">var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // 會被執行的陳述
}
</pre>

<h3 id="運算子優先級">運算子優先級</h3>

<p>運算子優先級決定運算子被使用於運算元的先後順序。 你也可以使用括號來強制指定優先級。</p>

<p>下列表格列出了運算子的優先級， 從高到低。</p>

<table class="standard-table">
 <caption>運算子優先級</caption>
 <thead>
  <tr>
   <th scope="col">運算子類型</th>
   <th scope="col">屬於該類別的運算子</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>成員</td>
   <td><code>. []</code></td>
  </tr>
  <tr>
   <td>呼叫/建立 實例</td>
   <td><code>() new</code></td>
  </tr>
  <tr>
   <td>反向/增加</td>
   <td><code>! ~ - + ++ -- typeof void delete</code></td>
  </tr>
  <tr>
   <td>乘法/除法</td>
   <td><code>* / %</code></td>
  </tr>
  <tr>
   <td>加法/減法</td>
   <td><code>+ -</code></td>
  </tr>
  <tr>
   <td>位元移動</td>
   <td><code>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</code></td>
  </tr>
  <tr>
   <td>關係運算子</td>
   <td><code>&lt; &lt;= &gt; &gt;= in instanceof</code></td>
  </tr>
  <tr>
   <td>相等性</td>
   <td><code>== != === !==</code></td>
  </tr>
  <tr>
   <td>位元 and</td>
   <td><code>&amp;</code></td>
  </tr>
  <tr>
   <td>位元 xor</td>
   <td><code>^</code></td>
  </tr>
  <tr>
   <td>位元 or</td>
   <td><code>|</code></td>
  </tr>
  <tr>
   <td>邏輯 and</td>
   <td><code>&amp;&amp;</code></td>
  </tr>
  <tr>
   <td>邏輯 or</td>
   <td><code>||</code></td>
  </tr>
  <tr>
   <td>條件運算子</td>
   <td><code>?:</code></td>
  </tr>
  <tr>
   <td>指定運算子</td>
   <td><code>= += -= *= /= %= &lt;&lt;= &gt;&gt;= &gt;&gt;&gt;= &amp;= ^= |=</code></td>
  </tr>
  <tr>
   <td>逗點運算子</td>
   <td><code>,</code></td>
  </tr>
 </tbody>
</table>

<p>這個表格更詳細的版本，解釋了運算子的更多細節和關聯性， 可以在 <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table">JavaScript 參考</a> 中被找到。</p>

<h2 id="運算式">運算式</h2>

<p>運算式是任何一段可以取得一個值的程式碼。</p>

<p>任何合乎語法的運算式都能取得一個值，概念上， 有兩種不同型態的運算式: 有副作用的 (例如: 將一個值指定給一個變數) 以及只為了取得值而解析的運算式。</p>

<p>運算式 <code>x = 7</code> 是上述的第一種類型。 這個使用 =<em> </em>運算子的運算式會將數值 7 賦與給 x。 運算式本身也會被解析為 7。</p>

<p>運算式 <code>3 + 4</code> 是上述的第二種類型。 這個運算式使用 + 運算子把 3 和 4 加起來，而不指定給任何變數。<br>
 <br>
 JavaScript 運算式有下列幾種種類:</p>

<ul>
 <li>算術: 解析出數字， 例如 3.14159. (通常使用 {{ web.link("#Arithmetic_operators", "算術運算子") }}.)</li>
 <li>字串: 解析出字串， 例如 "Fred" or "234"。 (通常使用 {{ web.link("#String_operators", "字串運算子") }}.)</li>
 <li>邏輯: 解析出 True 或 False (通常與 {{ web.link("#Logical_operators", "邏輯運算子") }} 相關。)</li>
 <li>主流運算式: JavaScript 基本的關鍵字及運算式。</li>
 <li>左側運算式: 左側是指定值的對象。</li>
</ul>

<h3 id="主流運算式">主流運算式</h3>

<p>JavaScript 基本的關鍵字及運算式。</p>

<h4 id="this" name="this"><code>this</code></h4>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this"><code>this</code> 關鍵字</a> 能取得當前所在物件。 一般而言， <code>this</code> 能取得呼叫處所在的物件。 你可以使用 點 或是 中括號 來取用該物件中的特性:</p>

<pre class="syntaxbox notranslate">this['特性名稱']
this.特性名稱
</pre>

<p>以下定義一個叫做 <code>validate</code> 的函式，比較物件中特性 <code>value 與傳入的兩變數</code>:</p>

<pre class="brush: js notranslate">function validate(obj, lowval, hival){
  if ((obj.value &lt; lowval) || (obj.value &gt; hival))
    console.log('不可用的值!');
}
</pre>

<p>你可以在表單的 <code>onChange</code> event handler 中呼叫 <code>validate</code> 函式， 並以 <code>this</code> 來傳入表單的元素， 範例如下:</p>

<pre class="brush: html notranslate">&lt;p&gt;請輸入一介於18 與 99 的數字:&lt;/p&gt;
&lt;input type="text" name="age" size=3 onChange="validate(this, 18, 99);"&gt;
</pre>

<h4 id="分組運算子">分組運算子</h4>

<p>分組運算子 <code>( )</code> 控制了運算子的優先順序。 例如，你可以覆寫先乘除，後加減的優先順序，使其變成先加減，後乘除。</p>

<pre class="brush:js notranslate">var a = 1;
var b = 2;
var c = 3;

// 預設運算級
a + b * c     // 7
// 預設的結果
a + (b * c)   // 7

// 現在複寫運算級
// 變成先進行加法，後乘法了
(a + b) * c   // 9

// 結果
a * c + b * c // 9
</pre>

<h4 id="解析">解析</h4>

<p>解析是 JavaScript 中的一個實驗性功能， 在未來版本的 ECMAScript 計畫被導入。有兩種不同類型的解析:</p>

<dl>
 <dt>{{experimental_inline}} {{jsxref("Operators/Array_comprehensions", "[for (x of y) x]")}}</dt>
 <dd>陣列解析。</dd>
 <dt>{{experimental_inline}} {{jsxref("Operators/Generator_comprehensions", "(for (x of y) y)")}}</dt>
 <dd>產生器解析。</dd>
</dl>

<p>解析在許多程式語言中都存在，允許你快速地基於現存陣列產生新的陣列，例如:</p>

<pre class="brush:js notranslate">[for (i of [ 1, 2, 3 ]) i*i ];
// [ 1, 4, 9 ]

var abc = [ 'A', 'B', 'C' ];
[for (letters of abc) letters.toLowerCase()];
// [ 'a', 'b', 'c' ]</pre>

<h3 id="左側運算式">左側運算式</h3>

<p>左側是指定值的對象。</p>

<h4 id="new" name="new"><code>new</code></h4>

<p>你可以使用 <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> 運算子</a> 來建立一個使用者自定義物件或內建物件的實例。 用法如下:</p>

<pre class="brush: js notranslate">var 物件名稱 = new 物件型態([參數1, 參數2, ..., 參數N]);
</pre>

<h4 id="super">super</h4>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super 關鍵字</a> 用於呼叫物件的父物件中的函式。 在使用 <a href="/en-US/docs/Web/JavaScript/Reference/Classes">類別</a> 來呼叫父類別的建構子時很實用，例如:</p>

<pre class="syntaxbox notranslate">super([參數]); // 呼叫父物件的建構子.
super.父物件的函式([參數]);
</pre>

<h4 id="展開運算子">展開運算子</h4>

<p><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">展開運算子</a>能將運算式展開於需要多個參數的地方 (如函式呼叫) 或是需要多個元素 (如陣列字串常數) 的地方。</p>

<p><strong>範例:</strong> 現在你想要用已存在的一個陣列做為新的一個陣列的一部份，當字串常數不再可用而你必須使用指令式編程，也就是使用，一連串的 <code>push</code>, <code>splice</code>, <code>concat</code>，等等。 展開運算子能讓過程變得更加簡潔:</p>

<pre class="brush: js notranslate">var parts = ['肩膀', '膝蓋'];
var lyrics = ['頭', ...parts, '和', '腳趾'];</pre>

<p>相同的，展開運算子也適用於函式呼叫:</p>

<pre class="brush: js notranslate">function f(x, y, z) { }
var args = [0, 1, 2];
f(...參數);</pre>

<div>{{PreviousNext("Web/JavaScript/Guide/Functions", "Web/JavaScript/Guide/Numbers_and_dates")}}</div>