recursal/MDN huggingface dataset:
Number.prototype.toExponential()
================================

**`toExponential()`** method 用來將數字轉成「科學記數法」格式。

語法
--


```js
numObj.toExponential([fractionDigits])
```

### 參數

| 參數 | 可選 | 默認值 | 類型 | 說明 |
| --- | --- | --- | --- | --- |
| `fractionDigits` | ● | 默認盡可能將數字完整顯示 | `Number`（正整數） | 小數點後的位數。需為 0 至 20 之間。 |

### 回傳值

一 string，將數字以「科學計數法」格式表示出來

### Exceptions

`RangeError`

若 `fractionDigits` 超出範圍（可接受的範圍是 0 ～ 20 之間的正整數）觸發 `RangeError`。

`TypeError` (en-US)

若參數 `fractionDigits` 不是 `Number`，則觸發`TypeError` (en-US)。

Description
-----------

If the `fractionDigits` argument is omitted, the number of digits after the decimal point defaults to the number of digits necessary to represent the value uniquely.

If you use the `toExponential()` method for a numeric literal and the numeric literal has no exponent and no decimal point, leave whitespace(s) before the dot that precedes the method call to prevent the dot from being interpreted as a decimal point.

If a number has more digits than requested by the `fractionDigits` parameter, the number is rounded to the nearest number represented by `fractionDigits` digits. See the discussion of rounding in the description of the `toFixed()` method, which also applies to `toExponential()`.

範例
--

### Using `toExponential`


```js
var numObj = 77.1234;

console.log(numObj.toExponential()); // logs 7.71234e+1
console.log(numObj.toExponential(4)); // logs 7.7123e+1
console.log(numObj.toExponential(2)); // logs 7.71e+1
console.log((77.1234).toExponential()); // logs 7.71234e+1
console.log((77).toExponential()); // logs 7.7e+1
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.prototype.toexponential |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* `Number.prototype.toFixed()`
* `Number.prototype.toPrecision()` (en-US)
* `Number.prototype.toString()` (en-US)
建構子函數的使用
========

還有一個選擇，你可以按照這兩個步驟來建立物件︰

1. 編寫建構子函數以完成物件類型的定義。
2. 使用 new 建立物件的實體。

若要定義物件類型，就指定物件類型的名稱、屬性、方法並建立函數。舉例來說，假設你想要給 car 建立物件類型。你希望這個物件的類型稱作 `car`，而且你還希望他有 make、model、year 這些屬性。要做到這些，你需要編寫出以下的函數︰


```js
function car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
```


注意 `this` 是用來把傳送給函數的值代入給物件的屬性。

現在你可以建立稱作 `mycar` 的物件如下所示︰


```js
mycar = new car("Eagle", "Talon TSi", 1993);
```


這個語句建立 `mycar` 並且把指定的值代入給他自己的屬性。然後 `mycar.make` 的值是字串 "Eagle"，`mycar.year` 是整數 1993，依此類推。

你可以藉由呼叫 `new` 來建立許多個 `car` 的物件。例如，


```js
kenscar = new car("Nissan", "300ZX", 1992);
vpgscar = new car("Mazda", "Miata", 1990);
```


物件可以有另一個物件本身的屬性。例如，假設你定義稱為 `person` 的物件如下︰


```js
function person(name, age, sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}
```


然後實體化兩個新的 person 物件如下︰


```js
rand = new person("Rand McKinnon", 33, "M");
ken = new person("Ken Jones", 39, "M");
```


然後你可以改寫 car 的定義，加入用來接受 `person` 物件的 owner 屬性，如下︰


```js
function car(make, model, year, owner) {
  this.make = make;
  this.model = model;
  this.year = year;
  this.owner = owner;
}
```


若要實體化新的物件，你可以如下使用︰


```js
car1 = new car("Eagle", "Talon TSi", 1993, rand);
car2 = new car("Nissan", "300ZX", 1992, ken);
```


注意，當建立新的物件的時候，傳入的並不是字面表達字串或整數值，上面的語句把 `rand` 和 `ken` 物件當作參數傳給 owners。然後如果你希望找出 car2 的 owner 的名稱，你可以如下存取屬性︰


```js
car2.owner.name
```


注意，你永遠可以給之前定義的物件加入屬性。例如，語句


```js
car1.color = "black";
```


把 `color` 屬性加入給 car1，並且把 "black" 的值代入給新加入的屬性。然而，這樣並不能影響到其他的任何物件。若要給所有同樣類型的物件加入新的屬性，你必須把新的屬性加入到 car 物件類型的定義。
一元正號運算子（+）
==========

一元正號運算子（`+`）置於運算元之前並取其數值。如果可以，亦會將之轉為數字。

嘗試一下
----

語法
--


```js
+x
```

詳細說明
----

一元負號運算子（`-`）也可以轉換非數字，但正號運算子卻是將運算元轉換為數字的最快和首選方法。

它不會對該運算元進行任何其他操作。

它可以將字串轉為整數和浮點數（如果字串值符合）；亦可使用在非字串的運算元，例如 `true`、`false`、`null`。

正號運算子支持十進制和十六進制整數（`0x` 前綴）、負數（雖然不適用於十六進制）格式。

若用於 BigInt 類型的值，會觸發 TypeError。

如果無法解析值，它會回傳 `NaN`。

範例
--

### 使用於數字


```js
const x = 1;
const y = -1;

console.log(+x);
// 1
console.log(+y);
// -1
```

### 使用於非數字上


```js
+true  // 1
+false // 0
+null  // 0
+[]    // 0
+function (val) { return val; } // NaN
+1n    // throws TypeError: Cannot convert BigInt value to number
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-unary-plus-operator |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相減運算子
* 相除運算子
* 相乘運算子
* 餘數運算子 (en-US)
* 相乘運算子
* 指數運算子
* 遞減運算子
* 負號運算子
super
=====

super 關鍵字被使用於通過函式存取父層

`super.prop` 與 `super[expr]` 表達有效在 method definition 與 classes 與 object literals (en-US).

語法
--
```

super([arguments]); // calls the parent constructor.
super.functionOnParent([arguments]);
```

描述
--

當使用建構子，`super` 關鍵字必須出現在`this` 關鍵字之前使用，`super` 關鍵字也可以使用在呼叫函式與父對象

範例
--

### 在類別中使用 `super`

這個程式碼片段從 classes sample (live demo). 這裏的 `super()` 被呼叫去避免複製到建構子的 `Rectangle` 與 `Square` 的共通部分。


```js
class Rectangle {
  constructor(height, width) {
    this.name = "Rectangle";
    this.height = height;
    this.width = width;
  }
  sayName() {
    console.log("Hi, I am a ", this.name + ".");
  }
  get area() {
    return this.height \* this.width;
  }
  set area(value) {
    this.area = value;
  }
}

class Square extends Rectangle {
  constructor(length) {
    this.height; // ReferenceError, super needs to be called first!

    // Here, it calls the parent class's constructor with lengths
    // provided for the Rectangle's width and height
    super(length, length);

    // Note: In derived classes, super() must be called before you
    // can use 'this'. Leaving this out will cause a reference error.
    this.name = "Square";
  }
}
```

### Super-calling 靜態方法

你也可以使用在靜態方法.


```js
class Rectangle {
  constructor() {}
  static logNbSides() {
    return "I have 4 sides";
  }
}

class Square extends Rectangle {
  constructor() {}
  static logDescription() {
    return super.logNbSides() + " which are all equal";
  }
}
Square.logDescription(); // 'I have 4 sides which are all equal'
```

### 刪除 super 屬性將拋出錯誤

你不能使用 delete operator 以及 `super.prop` 以及 `super[expr]` 去刪除父層的類別屬性, 不然他會丟出一個錯誤 `ReferenceError` (en-US).


```js
class Base {
  constructor() {}
  foo() {}
}
class Derived extends Base {
  constructor() {}
  delete() {
    delete super.foo; // this is bad
  }
}

new Derived().delete(); // ReferenceError: invalid delete involving 'super'.
```

### `super.prop` 不能複寫在不能複寫的屬性

當定義不可寫屬性，例如 `Object.defineProperty`, `super` 不能複寫這個屬性的值.


```js
class X {
  constructor() {
    Object.defineProperty(this, "prop", {
      configurable: true,
      writable: false,
      value: 1,
    });
  }
}

class Y extends X {
  constructor() {
    super();
  }
  foo() {
    super.prop = 2; // Cannot overwrite the value.
  }
}

var y = new Y();
y.foo(); // TypeError: "prop" is read-only
console.log(y.prop); // 1
```

### 使用 `super.prop` 在對象符號

Super 可以使用在 object initializer / literal (en-US) 符號. 在這個範例, 有兩個對象定義在一個方法. 在第二個對象裡面, `super` 呼叫了第一個對象的方法. 這個動作幫助 `Object.setPrototypeOf()` (en-US) 讓我們可以設定原型 `obj2` to `obj1`, 所以 `super` 可以發現 `method1` 在 `obj1`裡被找到.


```js
var obj1 = {
  method1() {
    console.log("method 1");
  },
};

var obj2 = {
  method2() {
    super.method1();
  },
};

Object.setPrototypeOf(obj2, obj1);
obj2.method2(); // logs "method 1"
```

規格
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-super-keyword |

Browser compatibility
---------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參考
--

* Classes
* Anurag Majumdar - Super & Extends in JavaScript
遞增運算子（++）
=========

遞增運算子（`++`）遞增（加一）它的運算元並將結果回傳。

嘗試一下
----

語法
--


```js
x++
++x
```

詳細說明
----

若將遞增運算子作為後綴（例如 `x++`），則會先回傳原本的值，再進行遞增。

若作為前綴（例如 `++x`），則會先進行遞增，再將遞增後的結果回傳。

範例
--

### 遞增運算子置於後綴


```js
let x = 3;
y = x++;

// y = 3
// x = 4
```

### 遞增運算子置於前綴


```js
let a = 2;
b = ++a;

// a = 3
// b = 3
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-postfix-increment-operator |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相減運算子
* 相除運算子
* 餘數運算子 (en-US)
* 相乘運算子
* 指數運算子
* 遞減運算子
* 負號運算子
* 正號運算子
屬性的刪除
=====

你可以使用 `delete` 運算子移除屬性。下面的代碼示範如何移除屬性︰


```js
// 建立新的物件 myobj，以及兩個屬性 a 和 b。
myobj = new Object();
myobj.a = 5;
myobj.b = 12;

// 移除一個屬性，只剩 b 屬性留在 myobj 裡。
delete myobj.a;
```


你也可以使用 `delete` 來刪除全域變數，只要這個變數不是使用 `var` 關鍵字宣告的話︰


```js
g = 17;
delete g;
```


參閱 delete 取得更多資訊。

* « 前頁
* 次頁 »
遞減運算子（--）
=========

遞減運算子（`--`）遞減（減一）它的運算元並將結果回傳。

嘗試一下
----

語法
--


```js
x--
--x
```

詳細說明
----

若將遞減運算子作為後綴（例如 `x--`），則會先回傳原本的值，在進行遞減。

若作為前綴（例如 `--x`），則會先進行遞減，在將遞減後的結果回傳。

範例
--

### 遞減運算子置於後綴


```js
let x = 3;
y = x--;

// y = 3
// x = 2
```

### 遞減運算子置於前綴


```js
let a = 2;
b = --a;

// a = 1
// b = 1
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-postfix-decrement-operator |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相減運算子
* 相除運算子
* 餘數運算子 (en-US)
* 相乘運算子
* 指數運算子
* 遞增運算子
* 負號運算子
* 正號運算子
相減運算子（-）
========

相減運算子（`-`）是用來將兩個值進行相減，並得出它們的差值。

嘗試一下
----

語法
--


```js
x - y
```

範例
--

### 數字相減


```js
5 - 3; // 2
3 - 5; // -2
```

### 非數字之間的相減


```js
"foo" - 3; // NaN
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-subtraction-operator-minus |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相除運算子
* 相乘運算子
* 餘數運算子 (en-US)
* 指數運算子
* 遞增運算子
* 遞減運算子
* 負號運算子
* 正號運算子
相乘運算子（\*）
=========

相乘運算子（`*`）是用來取得兩個運算元的乘積。

嘗試一下
----

語法
--


```js
x \* y
```

範例
--

### 乘以數字


```js
2 \* 2; // 4
-2 \* 2; // -4
```

### 乘以無限（Infinity）


```js
Infinity \* 0; // NaN
Infinity \* Infinity; // Infinity
```

### 乘以非數字


```js
"foo" \* 2; // NaN
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-multiplicative-operators |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相減運算子
* 相除運算子
* 餘數運算子 (en-US)
* 指數運算子
* 遞增運算子
* 遞減運算子
* 負號運算子
* 正號運算子
相加運算子（+）
========

相加運算子（`+`）用來處理數字的相加或是進行字串的串聯。

嘗試一下
----

語法
--


```js
x + y
```

範例
--

### 數字相加


```js
// Number + Number -> addition
1 + 2; // 3
// Boolean + Number -> addition
true + 1; // 2
// Boolean + Boolean -> addition
false + false; // 0
```

### 字串串聯


```js
// String + String -> concatenation
"foo" + "bar"; // "foobar"
// Number + String -> concatenation
5 + "foo"; // "5foo"
// String + Boolean -> concatenation
"foo" + false; // "foofalse"
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-addition-operator-plus |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相減運算子
* 相除運算子
* 相乘運算子
* 餘數運算子 (en-US)
* 指數運算子
* 遞增運算子
* 遞減運算子
* 負號運算子
* 正號運算子
await
=====

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since April 2017.

* Learn more
* See full compatibility
* Report feedback
await 運算子可被用來等待 `Promise`，只能在 `async function`內使用。語法
--
```

[rv] = await expression;
```


`expression`

等待解析的 `Promise` 物件或任何值。

`rv = 回傳值`

回傳 Promise 物件的 resolved 值，或當該值不是 Promise 物件時，回傳該值本身。

描述
--

此 await 表示法會暫停 async 函式執行，等待 Promise 物件的解析，並在 promise 物件的值被 resolve 時回復 async 函式的執行。await 接著回傳這個被 resolve 的值。如果回傳值不是一個 Promise 物件，則會被轉換為 resolved 狀態的 Promise 物件。

如果 Promise 物件被 rejected，則 await 會丟出 rejected 的值。

範例
--

若將 Promise 物件傳給 await 運算式，它會等待 Promise 解析並回傳 resolve 後的值。


```js
function resolveAfter2Seconds(x) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(x);
    }, 2000);
  });
}

async function f1() {
  var x = await resolveAfter2Seconds(10);
  console.log(x); // 10
}
f1();
```


若傳給 await 的值並非一個 Promise 物件，它會將該值轉換為 resolved Promise，並等待之。


```js
async function f2() {
  var y = await 20;
  console.log(y); // 20
}
f2();
```


若 Promise 被 reject，則丟出 reject 後的異常值。


```js
async function f3() {
  try {
    var z = await Promise.reject(30);
  } catch (e) {
    console.log(e); // 30
  }
}
f3();
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-async-function-definitions |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `async function`
* `async function expression` (en-US)
* `AsyncFunction` (en-US) object
運算子優先序
======

運算子優先序（Operator precedence）決定了運算子彼此之間被語法解析的方式，優先序較高的運算子會成為優先序較低運算子的運算元（operands）。

嘗試一下
----

相依性(Associativity)
------------------

當優先序相同時，使用相依性決定運算方向。範例如下：
```

a OP b OP c
```


左相依性 (Left-associativity) ，表示處理順序為從左至右 `(a OP b) OP c`，反之，右相依性(right-associativity) 表示處理順序為從右至左 `a OP (b OP c)`。賦值運算符 (Assignment operators) 為右相依性，範例如下：


```js
a = b = 5;
```


`a` 和 `b` 的預期結果為 5，因為賦值運算符 (Assignment operator) 為右相依性，因此從右至左返回值。一開始 `b` 被設定為 5，接著 `a` 也被設定為 5。

表格(Table)
---------

下方表格列出運算子的相依性，從高 (19) 到低 (1)。

| 優先性Precedence | 運算子名稱Operator type | 相依性Associativity | 運算子Individual operators |
| --- | --- | --- | --- |
| 19 | Grouping (en-US) | 無 | `( … )` |
| 18 | Member Access (en-US) | 從左至右 | `… . …` |
| Computed Member Access (en-US) | 從左至右 | `… [ … ]` |
| `new` (with argument list) | 無 | `new … ( … )` |
| 呼叫函式 | 從左至右 | `… ( … )` |
| 可選串連（Optional chaining） | 從左至右 | `?.` |
| 17 | `new` (without argument list) | 從右至左 | `new …` |
| 16 | 字尾遞增 | 無 | `… ++` |
| 字尾遞減 | `… --` |
| 15 | Logical NOT (en-US) | 從右至左 | `! …` |
| Bitwise NOT (en-US) | `~ …` |
| Unary Plus | `+ …` |
| Unary Negation | `- …` |
| 字首遞增 | `++ …` |
| 字首遞減 | `-- …` |
| `typeof` | `typeof …` |
| `void` (en-US) | `void …` |
| `delete` | `delete …` |
| `await` | `await …` |
| 14 | Exponentiation | 從右至左 | `… ** …` |
| 13 | Multiplication | 從左至右 | `… * …` |
| Division | `… / …` |
| Remainder (en-US) | `… % …` |
| 12 | Addition | 從左至右 | `… + …` |
| Subtraction | `… - …` |
| 11 | Bitwise Left Shift (en-US) | 從左至右 | `… << …` |
| Bitwise Right Shift (en-US) | `… >> …` |
| Bitwise Unsigned Right Shift (en-US) | `… >>> …` |
| 10 | Less Than (en-US) | 從左至右 | `… < …` |
| Less Than Or Equal (en-US) | `… <= …` |
| Greater Than (en-US) | `… > …` |
| Greater Than Or Equal (en-US) | `… >= …` |
| `in` (en-US) | `… in …` |
| `instanceof` (en-US) | `… instanceof …` |
| 9 | Equality (en-US) | 從左至右 | `… == …` |
| Inequality (en-US) | `… != …` |
| Strict Equality (en-US) | `… === …` |
| Strict Inequality (en-US) | `… !== …` |
| 8 | Bitwise AND (en-US) | 從左至右 | `… & …` |
| 7 | Bitwise XOR (en-US) | 從左至右 | `… ^ …` |
| 6 | Bitwise OR (en-US) | 從左至右 | `… | …` |
| 5 | Logical AND (en-US) | 從左至右 | `… && …` |
| 4 | Logical OR (en-US) | 從左至右 | `… || …` |
| Nullish Coalescing (en-US) | 從左至右 | `… ?? …` |
| 3 | 條件運算 | 從右至左 | `… ? … : …` |
| 2 | 賦值 | 從右至左 | `… = …` |
| `… += …` |
| `… -= …` |
| `… **= …` |
| `… *= …` |
| `… /= …` |
| `… %= …` |
| `… <<= …` |
| `… >>= …` |
| `… >>>= …` |
| `… &= …` |
| `… ^= …` |
| `… |= …` |
| `… &&= …` |
| `… ||= …` |
| `… ??= …` |
| 1 | Comma / Sequence (en-US) | 從左至右 | `… , …` |
一元負號運算子（-）
==========

一元負號運算子（`-`）置於運算元之前，並將運算元轉為其負值。

嘗試一下
----

語法
--


```js
-x
```

範例
--

### 轉換數字


```js
const x = 3;
const y = -x;

// y = -3
// x = 3
```

### 轉換非數字

一元負號運算子可以將非數字轉為數字。


```js
const x = "4";
const y = -x;

// y = -4
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-unary-minus-operator |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相減運算子
* 相除運算子
* 相乘運算子
* 餘數運算子 (en-US)
* 相乘運算子
* 指數運算子
* 遞減運算子
* 正號運算子
typeof
======

摘要
--

typeof 運算子會傳回一個字串值, 指出未經運算 (unevaluated) 的運算元所代表的型別。

| 運算子 |
| --- |
| 實作於: | JavaScript 1.1 |
| ECMA 版本: | ECMA-262 (以及 ECMA-357 for E4X objects) |

語法
--

`typeof` 之後面跟著它的唯一運算元:
```

typeof operand
```

參數
--

`operand` 表示式代表傳入的物件或原始型別。

說明
--

下表摘要列出了 `typeof 可能的傳回值`:

| 型別 | 傳回 |
| --- | --- |
| Undefined | `"undefined"` |
| Null | `"object"` |
| Boolean | `"boolean"` |
| Number | `"number"` |
| String | `"string"` |
| 主機端物件 (由 JS 執行環境提供) | *視實作方式而異* |
| Function 物件 (實作 ECMA-262 所定義的 [[Call]]) | `"function"` |
| E4X XML 物件 | "xml" |
| E4X XMLList 物件 | "xml" |
| 所有其它物件 | `"object"` |

範例
--

### 一般情況


```js
// Numbers
typeof 37 === "number";
typeof 3.14 === "number";
typeof Math.LN2 === "number";
typeof Infinity === "number";
typeof NaN === "number"; // 雖然是 "Not-A-Number"
typeof Number(1) === "number"; // 但是不要使用這種方式!

// Strings
typeof "" === "string";
typeof "bla" === "string";
typeof typeof 1 === "string"; // typeof 一律會傳回一個字串
typeof String("abc") === "string"; // 但是不要使用這種方式!

// Booleans
typeof true === "boolean";
typeof false === "boolean";
typeof Boolean(true) === "boolean"; // 但是不要使用這種方式!

// Undefined
typeof undefined === "undefined";
typeof blabla === "undefined"; // 一個 undefined 變數

// Objects
typeof { a: 1 } === "object";
typeof [1, 2, 4] === "object"; // 請使用 Array.isArray 或者 Object.prototype.toString.call 以區分正規運算式和陣列
typeof new Date() === "object";

typeof new Boolean(true) === "object"; // 這樣會令人混淆。不要這樣用!
typeof new Number(1) === "object"; // 這樣會令人混淆。不要這樣用!
typeof new String("abc") === "object"; // 這樣會令人混淆。不要這樣用!

// Functions
typeof function () {} === "function";
typeof Math.sin === "function";
```

### `null`


```js
typeof null === "object"; // 自從有 JavaScript 開始就是這樣了
```


自從 JavaScript 一開始出現, JavaScript 的值就總以型別標簽跟著一個值的方式表示。物件的型別標簽是 0. 而 `null` 這個值是使用 NULL 指標 (在大部份平台上是 0x00) 來表示. 因此, null 看起來像是一個以 0 為型別標簽的值, 並使得 `typeof` 傳回不甚正確的結果. (參考來源)

這個問題已計畫在下一版 ECMAScript 予以修正 (會以 opt-in 方式提供). 屆時它將會做出如 `typeof null === 'null'` 的正確回傳結果。

**備註：** 此修正計畫已被拒絕

### 正規表示式 (Regular expressions)

可呼叫的正規表示式在某些瀏覽器上面必須借助非正式插件 (need reference to say which).


```js
typeof /s/ === "function"; // Chrome 1-12 ... // 不符合 ECMAScript 5.1 (譯註: 在新版 Chrome 已修正為 'object')
typeof /s/ === "object"; // Firefox 5+ ... // 符合 ECMAScript 5.1
```

### 其它怪異輸入 (quirks)

#### 舊版 Internet Explorer 請留意 alert 函數

在 IE 6, 7 和 8, `typeof alert === 'object'`

**備註：** 這並不怪異。這是實情。在許多較舊的 IE 中, 主機端物件的確是物件, 而非函數

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-typeof-operator |

參照
--

* instanceof (en-US)
相除運算子（/）
========

相除運算子（`/`）是用來將兩個值進行相除並取得其商數。其中左運算元是被除數；右運算元是除數。

嘗試一下
----

語法
--


```js
x / y
```

範例
--

### 基本的除法


```js
1 / 2; // 0.5

Math.floor(3 / 2); // 1

1.0 / 2.0; // 0.5
```

### 除以零


```js
2.0 / 0; // Infinity

2.0 / 0.0; // Infinity, because 0.0 === 0

2.0 / -0.0; // -Infinity
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-multiplicative-operators |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相減運算子
* 相乘運算子
* 餘數運算子 (en-US)
* 指數運算子
* 遞增運算子
* 遞減運算子
* 負號運算子
* 正號運算子
條件運算子
=====

**條件 (三元) 運算子** 是 JavaScript 唯一用到三個運算元的運算子：在一個條件後面會跟著一個問號 (`?`)，如果條件是 truthy (en-US)，在冒號(`:`)前的表達式會被執行，如果條件是 falsy (en-US)，在冒號後面的表達式會被執行，這個運算子常常被用來當作 `if` 的簡潔寫法.

嘗試一下
----

語法
--
```

condition ? exprIfTrue : exprIfFalse
```

### 參數

`condition`

值用來做為條件的表達式

`exprIfTrue`

如果 `condition` 的值是 truthy (en-US) (等於或是可轉換為 `true`) , `exprIfTrue` 會被執行

`exprIfFalse`

如果 `condition` 的值是 falsy (en-US) (等於或是可轉換為 `false`) , `exprIfFalse` 會被執行

描述
--

除了 `false`, 可能是 falsy 的表達式有 `null`, `NaN`, `0`, 空字串 (`""`) 和 `undefined`. 如果`condition` 是他們其中之一 , 那麼條件表達式的結果會是 `exprIfFalse` 的執行結果.

一個簡單的範例:


```js
var age = 26;
var beverage = age >= 21 ? "Beer" : "Juice";
console.log(beverage); // "Beer"
```


一個常用來處理 `null` 的用法 :


```js
function greeting(person) {
  var name = person ? person.name : "stranger";
  return "Howdy, " + name;
}

console.log(greeting({ name: "Alice" })); // "Howdy, Alice"
console.log(greeting(null)); // "Howdy, stranger"
```

### 條件鏈

條件 (三元) 運算子是右相依性的 (right-associative), 代表他可以以下面的方式鏈結 , 類似於 `if … else if … else if … else` 的鏈結方法 :


```js
function example(…) {
    return condition1 ? value1
         : condition2 ? value2
         : condition3 ? value3
         : value4;
}

// Equivalent to:

function example(…) {
    if (condition1) { return value1; }
    else if (condition2) { return value2; }
    else if (condition3) { return value3; }
    else { return value4; }
}
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-conditional-operator |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* if statement
* Nullish coalescing operator (en-US)
* Optional chaining
* Making decisions in your code — conditionals
* Expressions and operators
指數運算子（\*\*）
===========

指數運算子（`**`）會回傳以第一個數字作為底數；第二個數字做為指數的運算結果。

它類同於 `Math.pow`，不一樣的是 `**` 可以用於 BigInt 的計算而 `Math.pow` 不行。

嘗試一下
----

語法
--


```js
x \*\* y
```

簡介
--

指數運算子是 right-associative：`a ** b ** c` 相當於 `a ** (b ** c)`。

在絕大多數的程式語言，例如 PHP、Python……等等，指數運算的優先順序比一元運算子（ `+` 或 `-` ）較高。但並非所有程式語言均是如此。

舉例來說，在 Bash，`**` 的優先順序就低於一元運算子。

在 Javascript，模棱兩可的求冪運算式。說得清楚一點，`+/-/~/!/delete/void/typeof` 這類一元運算子均不能置於底數之前，否則會出現 `SyntaxError`。


```js
-2 \*\* 2;
// 在 Bash 的結果為 4；其他語言則為 -4
// 在 JavaScript 則是被視為語意不明。

-(2 \*\* 2);
// 在 Javascript 就會得出 -4。這種寫法的語意就很明確
```


注意，在部分語言之中，指數運算採用插入符號 `^` ，但是在 Javascript ，`^` 則是用於XOR 位元邏輯運算子 (en-US).

範例
--

### 指數的基本運算


```js
2 \*\* 3; // 8
3 \*\* 2; // 9
3 \*\* 2.5; // 15.588457268119896
10 \*\* -1; // 0.1
NaN \*\* 2; // NaN
```

### 連續使用


```js
2 \*\* (3 \*\* 2); // 512
2 \*\* (3 \*\* 2); // 512
(2 \*\* 3) \*\* 2; // 64
```

### 與一元運算子一同使用

反轉指數運算結果之正負：


```js
-(2 \*\* 2); // -4
```


計算底數為負數的指數運算：


```js
(-2) \*\* 2; // 4
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-exp-operator |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* 相加運算子
* 相減運算子
* 相除運算子
* 相乘運算子
* 餘數運算子 (en-US)
* 遞增運算子
* 遞減運算子
* 負號運算子
* 正號運算子
debugger
========

**debugger 的宣告**會執行可用的除錯功能，例如設定斷點。如果沒有可用的除錯功能，這個宣告沒有任何作用。

語法
--
```

debugger;
```

示例
--

以下示例示範了插入 debugger 宣告的程式碼，它會在函式被呼叫、而且有除錯器的時候執行除錯器。


```js
function potentiallyBuggyCode() {
  debugger;
  // 執行並驗證一些潛在的問題、或是單步執行之類的。
}
```


呼叫除錯器時，程式會在 debugger 宣告處暫停執行。它有點像是程式碼的斷點。

![Paused at a debugger statement.](/zh-TW/docs/Web/JavaScript/Reference/Statements/debugger/screen_shot_2014-02-07_at_9.14.35_am.png)

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-debugger-statement |

瀏覽器相容性
------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

參見
--

* JavaScript 除錯
* Firefox 開發工具的的除錯器
do...while 語法
=============

`do...while` 語法會反覆執行直到指定條件的求值結果為 false 為止。`do...while` 語法如下︰


```js
do
  statement
while (condition);
```


`statement` 會在檢測條件之前就先執行一次。若要執行多個語句，就使用區塊語法（`{ ... }`）把語句群組化。如果 `condition` 為 true，就會再執行一次語句。每回執行以後，就會檢測條件。當條件為 false 時，就停止執行並把控制權轉移給 `do...while` 後面的語句。

範例
--

在以下範例中，do 循環至少會反覆執行一次，並一直反覆到 i 不再小於 5 為止。


```js
do {
  i += 1;
  document.write(i);
} while (i < 5);
```