recursal/MDN huggingface dataset:
NaN
===

全域屬性 **`NaN`** 表示「非數值」（Not-A-Number）的數值。

| `NaN` 的屬性特性 |
| --- |
| 可寫 | 否 |
| 可列舉 | 否 |
| 可配置 | 否 |

嘗試一下
----

語法
--
```

NaN
```

描述
--

`NaN` 的屬性屬於*全域物件*。

如同 `Number.NaN` (en-US) 一般，`NaN` 的初始數值是「非數值」。在當今的瀏覽器中，`NaN` 屬性不可設定（non-configurable）也不可覆寫（non-writable）。雖然可能有例外，也請不要覆蓋它。

寫程式很少會直接動用 `NaN`。通常是在 `Math` 函式計算失敗（`Math.sqrt(-1)`）或函式解析數字失敗（`parseInt("blabla")`）後才會回傳。

### 偵測是否為 `NaN`

`NaN` 不等於（`==`、`!=`、`===`、`!==`）任何值，包括 NaN 本身。請使用 `Number.isNaN()` (en-US) 或 `isNaN()` 來確認某個數值是否為 NaN。Or perform a self-comparison: NaN, and only NaN, will compare unequal to itself.


```js
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true

function valueIsNaN(v) {
  return v !== v;
}
valueIsNaN(1); // false
valueIsNaN(NaN); // true
valueIsNaN(Number.NaN); // true
```


但請注意 `isNaN()` 與 `Number.isNaN()` 之間是有區別的：前者會在目前數字是 `NaN` 的時候回傳 `true`，或在裡面包藏一個號碼後變成 `NaN`；而後者，只有在數值是 `NaN` 的時候才會回傳 `true`。

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-nan |

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

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

參見
--

* `Number.NaN` (en-US)
* `Number.isNaN()` (en-US)
* `isNaN()`
ArrayBuffer
===========

**`ArrayBuffer`** 物件是一種表示通用、固定大小的原始二進制資料緩衝。想要直接操作一個 `ArrayBuffer` 物件的內容是不可能的。若要讀寫該緩衝的內容則必須透過視圖，可以選擇建立一個 `DataView` (en-US) 視圖物件或是一個限定其成員為某種型別的 `TypedArray` (en-US) 視圖物件，它們皆能以特定的型別解讀、修改 `ArrayBuffer`。

語法
--


```js
new ArrayBuffer(length)
```

### 參數

`length`

要建立的緩衝陣列大小，以位元組（byte）計算。

### 回傳值

為一個新建立的指定大小 `ArrayBuffer` 物件，其內容皆初始化為 0。

### Exceptions

A `RangeError` is thrown if the `length` is larger than `Number.MAX_SAFE_INTEGER` (en-US) (>= 2 \*\* 53) or negative.

說明
--

The `ArrayBuffer` constructor creates a new `ArrayBuffer` of the given length in bytes.

### 從既有的資料取得 ArrayBuffer

* From a Base64 string (en-US)
* 從本地端檔案
屬性
--

`ArrayBuffer.length`

The `ArrayBuffer` constructor's length property whose value is 1.

`get ArrayBuffer[@@species]` (en-US)

The constructor function that is used to create derived objects.

`ArrayBuffer.prototype` (en-US)

Allows the addition of properties to all `ArrayBuffer` objects.

方法
--

`ArrayBuffer.isView(arg)` (en-US)

Returns `true` if `arg` is one of the ArrayBuffer views, such as typed array objects (en-US) or a `DataView` (en-US). Returns `false` otherwise.

`ArrayBuffer.transfer(oldBuffer [, newByteLength])` (en-US) 
實驗性質

Returns a new `ArrayBuffer` whose contents are taken from the `oldBuffer`'s data and then is either truncated or zero-extended by `newByteLength`.

`ArrayBuffer` 實例
----------------

所有的 `ArrayBuffer` 物件實例皆繼承自 `ArrayBuffer.prototype` (en-US).

### 屬性

`ArrayBuffer.prototype[@@toStringTag]`

The initial value of the `@@toStringTag` (en-US) property is the string `"ArrayBuffer"`. This property is used in `Object.prototype.toString()` (en-US).

`ArrayBuffer.prototype.byteLength` (en-US)

The read-only size, in bytes, of the `ArrayBuffer`. This is established when the array is constructed and cannot be changed.

### 方法

`ArrayBuffer.prototype.slice()` (en-US)

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

範例
--

In this example, we create a 8-byte buffer with a `Int32Array` (en-US) view referring to the buffer:


```js
var buffer = new ArrayBuffer(8);
var view = new Int32Array(buffer);
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer-objects |

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

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

相容性備註
-----

Starting with ECMAScript 2015, `ArrayBuffer` constructors require to be constructed with a `new` operator. Calling an `ArrayBuffer` constructor as a function without `new`, will throw a `TypeError` (en-US) from now on.


```js
var dv = ArrayBuffer(10);
// TypeError: calling a builtin ArrayBuffer constructor
// without new is forbidden
```



```js
var dv = new ArrayBuffer(10);
```

參見
--

* `TypedArray` (en-US)
* `SharedArrayBuffer` (en-US)
Boolean
=======

**`Boolean`** 是布林值的包覆器。

語法
--
```

new Boolean([value])
```

### 參數

`value` 選擇性

這個`Boolean`物件的初始值。

說明
--

傳入的第一個參數值，如果需要的話，會被轉換成布林值。如果沒傳值，或者是`0`、`-0`、`null` (en-US)、`false`、`NaN`、`undefined` (en-US)、空字串(`""`)的話，這個物件的值會被初始化成`false`。大多數情況下，DOM 物件 `document.all` (en-US) 被傳入後，也會將其初始化為`false`。至於其他的值，包含所有物件或`"false"`字串，都會使其初始化為`true`。

不要將原始型別的布林值和這個布林物件搞混，它們並不相同。

在判斷式中，任何物件只要不是 `undefined` (en-US) 或 `null` (en-US) ，儘管是值為`false` 的 `Boolean` 物件，都會被轉換成`true`。舉例來說，下列的 `if` 判斷式中的布林值即為`true`：


```js
var x = new Boolean(false);
if (x) {
  // this code is executed
}
```


以上這個行為和`Boolean`原始型別沒有關連，反倒是下面的 `if` 判斷式會正確地將其視為`false`：


```js
var x = false;
if (x) {
  // this code is not executed
}
```


不要用`Boolean`物件將非布林值轉換成布林值。反而要將`Boolean`視為函式去轉換非布林值：


```js
var x = Boolean(expression); // 較好
var x = new Boolean(expression); // 不要用
```


如果你要指定任何物件，包括值為`false`的`Boolean`物件，作為`Boolean`物件的初始值，則該`Boolean`物件的值依舊為`true`。


```js
var myFalse = new Boolean(false); // 初始值給false，實際上為true
var g = new Boolean(myFalse); // 想當然耳，true
var myString = new String("Hello"); // 字串物件，'Hello'
var s = new Boolean(myString); // 依舊為true
```


不要使用`Boolean`物件代替`Boolean`的原始型別！

屬性
--

`Boolean.length`

長度永遠為 1。

`Boolean.prototype` (en-US)

原型為`Boolean`的建構式。

方法
--

全域的`Boolean`物件自身沒有任何方法，它只有從原型鏈繼承而來的方法。

`Boolean` 實體
------------

所有 `Boolean` 實體會繼承 `Boolean.prototype` (en-US) 。和所有建構式一樣，原型物件會指派給實體那些繼承的屬性和方法。

### 方法

`Boolean.prototype.toString()` (en-US)

Returns a string of either `true` or `false` depending upon the value of the object. Overrides the `Object.prototype.toString()` (en-US) method.

`Boolean.prototype.valueOf()` (en-US)

Returns the primitive value of the `Boolean` object. Overrides the `Object.prototype.valueOf()` (en-US) method.

範例
--

### 用 `false` 作為初始值建立 `Boolean` 物件


```js
var bNoParam = new Boolean();
var bZero = new Boolean(0);
var bNull = new Boolean(null);
var bEmptyString = new Boolean("");
var bfalse = new Boolean(false);
```

### 用 `true` 作為初始值建立 `Boolean` 物件


```js
var btrue = new Boolean(true);
var btrueString = new Boolean("true");
var bfalseString = new Boolean("false");
var bSuLin = new Boolean("Su Lin");
var bArrayProto = new Boolean([]);
var bObjProto = new Boolean({});
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean-objects |

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

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

參見
--

* `Boolean.prototype` (en-US)
* Boolean
* Boolean data type (Wikipedia)
Set.prototype.clear()
=====================

**`clear()`** 方法會從一個 `Set` 物件中移除其所有元素。

嘗試一下
----

語法
--


```js
mySet.clear();
```

### 回傳值

`undefined` (en-US)。

範例
--

### 使用 `clear` 方法


```js
var mySet = new Set();
mySet.add(1);
mySet.add("foo");

mySet.size; // 2
mySet.has("foo"); // true

mySet.clear();

mySet.size; // 0
mySet.has("bar"); // false
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.clear |

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

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

參見
--

* `Set`
* `Set.prototype.delete()`
Set.prototype.values()
======================

**`values()`** 方法回傳一個 `Iterator` 物件，包含著 `Set` 物件中所有元素，由插入順序排序。

**`keys()`** 是這個方法的替身（為了與 `Map` 物件保持相似性）；他運行的完全一模一樣，回傳 `Set` 中元素的 **values**。

嘗試一下
----

語法
--


```js
mySet.values();
```

### 回傳值

一個 `Iterator` 物件，包含著 `Set` 物件中所有元素，由插入順序排序。

範例
--

### 使用 `values()`


```js
var mySet = new Set();
mySet.add("foo");
mySet.add("bar");
mySet.add("baz");

var setIter = mySet.values();

console.log(setIter.next().value); // "foo"
console.log(setIter.next().value); // "bar"
console.log(setIter.next().value); // "baz"
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.values |

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

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

參見
--

* `Set.prototype.entries()`
Set.prototype.has()
===================

**`has()`** 方法對一個指定值元素在 `Set` 物件中的存在與否回傳一個布林值。

嘗試一下
----

語法
--


```js
mySet.has(value);
```

### 參數

`value`

要測試是否存在在 `Set` 中的值。

### 回傳值

回傳 `true` 如果給定值存在在 `Set` 物件中；反之回傳 `false`。

**備註：** 技術上來說，`has()` 使用了 `sameValueZero` 算法來判斷給定元素的存在與否。

範例
--

### 使用 `has` 方法


```js
var mySet = new Set();
mySet.add("foo");

mySet.has("foo"); // returns true
mySet.has("bar"); // returns false

var set1 = new Set();
var obj1 = { key1: 1 };
set1.add(obj1);

set1.has(obj1); // returns true
set1.has({ key1: 1 }); // returns false because they are different object references
set1.add({ key1: 1 }); // now set1 contains 2 entries
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.has |

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

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

參見
--

* `Set`
* `Set.prototype.add()`
* `Set.prototype.delete()`
Set.prototype.entries()
=======================

**`entries()`** 方法回傳一個 `Iterator` 物件，其包含著一個由插入順序排序，`Set` 物件中每個元素的 **`[value, value]`** 陣列。儘管對 `Set` 物件來說沒有像 `Map` 一樣的 `key` 概念，為了確保這個 API 運作的與 `Map` 相似，每個 *entry* 都有同樣的值同時作為其 *key* 和 *value* ，因此回傳的是一個 **`[value, value]`** 的陣列。

嘗試一下
----

語法
--


```js
mySet.entries()
```

### 回傳值

一個新的 `Iterator` 物件，包含著一個由插入順序排序，`Set` 物件中每個元素的 **`[value, value]`** 陣列。

範例
--

### 使用 `entries()`


```js
var mySet = new Set();
mySet.add("foobar");
mySet.add(1);
mySet.add("baz");

var setIter = mySet.entries();

console.log(setIter.next().value); // ["foobar", "foobar"]
console.log(setIter.next().value); // [1, 1]
console.log(setIter.next().value); // ["baz", "baz"]
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.entries |

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

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

參見
--

* `Set.prototype.keys()` (en-US)
* `Set.prototype.values()`
Set.prototype.add()
===================

**`add()`** 會在一個 `Set` 物件的尾端加上一個指定 `value` 的新元素。

嘗試一下
----

語法
--


```js
mySet.add(value);
```

### 參數

`value`

要被加到 `Set` 物件中的值。

### 回傳值

`Set` 物件本身。

範例
--

### 使用 `add` 方法


```js
var mySet = new Set();

mySet.add(1);
mySet.add(5).add("some text"); // chainable

console.log(mySet);
// Set [1, 5, "some text"]
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.add |

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

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

參見
--

* `Set`
* `Set.prototype.delete()`
* `Set.prototype.has()`
Set.prototype.delete()
======================

**`delete()`** 方法會一個 `Set` 物件中移除指定元素。

嘗試一下
----

語法
--


```js
mySet.delete(value);
```

### 參數'

`value`

要從 `Set` 物件中移除的值。

### 回傳值

`true` 如果成功從 `Set` 物件中移除；反之 `false`。

範例
--

### 使用 `delete` 方法


```js
var mySet = new Set();
mySet.add("foo");

mySet.delete("bar"); // Returns false. No "bar" element found to be deleted.
mySet.delete("foo"); // Returns true. Successfully removed.

mySet.has("foo"); // Returns false. The "foo" element is no longer present.
```


下方展示了如何從一個 Set 中移除物件。


```js
var setObj = new Set(); // Create a New Set.

setObj.add({ x: 10, y: 20 }); // Add object in the set.

setObj.add({ x: 20, y: 30 }); // Add object in the set.

// Delete any point with `x > 10`.
setObj.forEach(function (point) {
  if (point.x > 10) {
    setObj.delete(point);
  }
});
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-set.prototype.delete |

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

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

參見
--

* `Set`
* `Set.prototype.clear()`
Object.keys()
=============

**`Object.keys()`** 方法會回傳一個由指定物件所有可列舉之屬性組成的陣列，該陣列中的的排列順序與使用 `for...in` 進行迭代的順序相同（兩者的差異在於 `for-in` 迴圈還會迭代出物件自其原型鏈所繼承來的可列舉屬性）。

語法
--


```js
Object.keys(obj)
```

### 參數

`obj`

物件，用以回傳其可列舉屬性。

### 回傳值

回傳一個包含給定物件內所有可列舉屬性的字串陣列。

描述
--

`Object.keys()` 回傳一個陣列，陣列中的各元素為直屬於 `obj` ，對應可列舉屬性名的字串。回傳結果的排序，與手動對物件屬性作迴圈迭代的結果排序相同。

範例
--


```js
var arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

// 類似陣列的物件
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.keys(obj)); // console: ['0', '1', '2']

// 擁有隨機 key 排序，類似陣列的物件
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(an_obj)); // console: ['2', '7', '100']

// getFoo 不是可列舉的屬性
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = 1;

console.log(Object.keys(my_obj)); // console: ['foo']
```


如果想取得物件的所有屬性，包括非可列舉的屬性，請參閱 `Object.getOwnPropertyNames()` (en-US).

備註
--

在 ES5 中，如果這個方法的參數不是一個標準物件(例如原始型別)，將會產生 `TypeError` (en-US)錯誤。而在 ES2015，非物件的參數將會強制轉換成物件。


```js
Object.keys("foo");
// TypeError: "foo" is not an object (ES5 code)

Object.keys("foo");
// ["0", "1", "2"] (ES2015 code)
```

Polyfill
--------

如需在原生不支援、較舊的環境中增加 `Object.keys` 的相容性，請複製以下片段：


```js
// From https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Global\_Objects/Object/keys
if (!Object.keys) {
  Object.keys = (function () {
    "use strict";
    var hasOwnProperty = Object.prototype.hasOwnProperty,
      hasDontEnumBug = !{ toString: null }.propertyIsEnumerable("toString"),
      dontEnums = [
        "toString",
        "toLocaleString",
        "valueOf",
        "hasOwnProperty",
        "isPrototypeOf",
        "propertyIsEnumerable",
        "constructor",
      ],
      dontEnumsLength = dontEnums.length;

    return function (obj) {
      if (
        typeof obj !== "object" &&
        (typeof obj !== "function" || obj === null)
      ) {
        throw new TypeError("Object.keys called on non-object");
      }

      var result = [],
        prop,
        i;

      for (prop in obj) {
        if (hasOwnProperty.call(obj, prop)) {
          result.push(prop);
        }
      }

      if (hasDontEnumBug) {
        for (i = 0; i < dontEnumsLength; i++) {
          if (hasOwnProperty.call(obj, dontEnums[i])) {
            result.push(dontEnums[i]);
          }
        }
      }
      return result;
    };
  })();
}
```


請注意以上的代碼片段在 IE7 中( IE8 也有可能 )，從不同的 window 傳入物件將包含非可列舉的 key 。

較精簡的瀏覽器 Polyfill，請參閱 Javascript - Object.keys Browser Compatibility.

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.keys |

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

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

參見
--

* Enumerability and ownership of properties (en-US)
* `Object.prototype.propertyIsEnumerable()` (en-US)
* `Object.create()`
* `Object.getOwnPropertyNames()` (en-US)
* `Object.values()` (en-US) 
實驗性質
* `Object.entries()` (en-US) 
實驗性質
Object.getPrototypeOf()
=======================

**`Object.getPrototypeOf()`** 回傳指定物件的原型，換句話說，就是取得該物件的 `[[Prototype]]` 屬性的值).

表達式
---
```

Object.getPrototypeOf(obj)
```

### 參數

`obj`

欲取得原型的物件。

範例
--


```js
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
```

備註
--

如果 `obj` 參數在 ES5 並不是物件時會拋出 `TypeError` (en-US) 例外，同樣狀況在 ES6 時該參數將會被強制轉換成 `Object` (en-US)。


```js
Object.getPrototypeOf("foo");
// TypeError: "foo" is not an object (ES5 code)
Object.getPrototypeOf("foo");
// String.prototype (ES6 code)
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.getprototypeof |

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

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

Opera 註
-------

雖然舊版的 Opera 並不支援 `Object.getPrototypeOf()`，但是 Opera 從 Opera 10.50 支援非標準的 `Object.prototype.__proto__` (en-US) 屬性。

參見
--

* `Object.prototype.isPrototypeOf()` (en-US)
* `Object.setPrototypeOf()` (en-US) 
實驗性質
* `Object.prototype.__proto__` (en-US)
* John Resig 的文章－－《 getPrototypeOf 》
* `Reflect.getPrototypeOf()` (en-US)
Object.preventExtensions()
==========================

**`Object.preventExtensions()`** 用來避免物件被新增新的屬性。

語法
--


```js
Object.preventExtensions(obj)
```

### 參數

`obj`

要被用作無法擴充的物件。

描述
--

物件如果可以被增加新的屬性，我們稱它可以被擴充(extensible)。`Object.preventExtensions()` 標註物件使它無法被擴充，所以在它被標註為無法擴充當下，它將無法再增加新的屬性。不過注意一點，在一般狀況下，被標註為無法擴充的物件，其屬性仍可被刪除(*deleted*)。嘗試去增加屬性將會導致失敗，可能會沒有結果產生，或是傳回一個 `TypeError` (en-US) (最常見，但並不是一定，當在strict mode (en-US))。

`Object.preventExtensions()` 只有避免物件被增加屬性，屬性仍可以被增加至 `object prototype`。不過，呼叫 `Object.preventExtensions()` 使用在物件上，就可以使其 `Object.prototype.__proto__` (en-US) 
已棄用
 屬性無法被擴充。

如果能把可擴充物件，轉成無法擴充物件，在 ECMAScript 5 規範中，它並沒有任何方法轉回來。

範例
--


```js
// Object.preventExtensions 傳回一個被無法擴充的物件
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2; // true

// 預設下，物件可以被擴充
var empty = {};
Object.isExtensible(empty); // === true

// ...但是以下情況之後，無法再被變更。
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// Object.defineProperty throws 當為無法擴充的物件增加屬性
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // throws a TypeError

// 在 strict mode 中，嘗試去新增屬性給無法擴充物件，將 throws 出一個 TypeError。
function fail() {
  "use strict";
  nonExtensible.newProperty = "FAIL"; // throws a TypeError
}
fail();

// EXTENSION (only works in engines supporting \_\_proto\_\_
// (which is deprecated. Use Object.getPrototypeOf instead)):
// A non-extensible object's prototype is immutable.
var fixed = Object.preventExtensions({});
fixed.__proto__ = { oh: "hai" }; // throws a TypeError
```

筆記
--

在 ES5 中，如果給祝個方法的參數為非物件，它將造成一個 `TypeError` (en-US) 。不過在 ES6 中，非物件參數會被正常處理。另外，如果它原本就是個無法擴充物件，就只是回傳本身。


```js
Object.preventExtensions(1);
// TypeError: 1 is not an object (ES5 code)

Object.preventExtensions(1);
// 1 (ES6 code)
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.preventextensions |

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

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

參見
--

* `Object.isExtensible()` (en-US)
* `Object.seal()` (en-US)
* `Object.isSealed()` (en-US)
* `Object.freeze()`
* `Object.isFrozen()` (en-US)
* `Reflect.preventExtensions()` (en-US)
Object.prototype.hasOwnProperty()
=================================

**`hasOwnProperty()`** 回傳物件是否有該屬性的布林值。

表達式
---


```js
obj.hasOwnProperty(prop)
```

### 參數

`prop`

屬性名稱。

說明
--

每個為 `Object` (en-US) 後代的物件都繼承 `hasOwnProperty` 方法。這個方法可以被使用來決定物件是否擁有特定的直接屬性；跟 `in` (en-US) 不一樣，這個方法並未檢查物件的原型鏈。

範例
--

### 使用 `hasOwnProperty` 測試屬性是否存在

這個範例顯示 `o` 物件是否擁有名為 `prop` 的屬性:


```js
o = new Object();
o.prop = "exists";

function changeO() {
  o.newprop = o.prop;
  delete o.prop;
}

o.hasOwnProperty("prop"); // 回傳 true
changeO();
o.hasOwnProperty("prop"); // 回傳 false
```

### 直接與繼承的屬性

這個範例區分直接屬性和從原型鍊繼承的屬性：


```js
o = new Object();
o.prop = "exists";
o.hasOwnProperty("prop"); // 回傳 true
o.hasOwnProperty("toString"); // 回傳 false
o.hasOwnProperty("hasOwnProperty"); // 回傳 false
```

### 遍歷物件的屬性

這個範例顯示如何不執行繼承的屬性去遍歷物件的屬性。注意 `for...in` 已經遍歷了可以被列舉的項目，所以不該基於缺乏不可列舉的屬性(如下)而假設 `hasOwnProperty` 被嚴格地限制在列舉的項目（如同 `Object.getOwnPropertyNames()` (en-US)）。


```js
var buz = {
  fog: "stack",
};

for (var name in buz) {
  if (buz.hasOwnProperty(name)) {
    console.log("this is fog (" + name + ") for sure. Value: " + buz[name]);
  } else {
    console.log(name); // toString or something else
  }
}
```

### `將 hasOwnProperty` 作為屬性

JavaScript 並未保護 `hasOwnProperty`；因此，如果一個物件擁有一樣的屬性名稱，為了獲得正確的結果需要使用 *external* `hasOwnProperty`：


```js
var foo = {
  hasOwnProperty: function () {
    return false;
  },
  bar: "Here be dragons",
};

foo.hasOwnProperty("bar"); // 總是回傳 false

// 使用其他物件的 hasOwnProperty 和 call it with 'this' set to foo
({}).hasOwnProperty.call(foo, "bar"); // true

// 從物件的原型使用 hasOwnProperty 也是可行的
Object.prototype.hasOwnProperty.call(foo, "bar"); // true
```


註：在最後一個例子中並未創建任何新的物件。

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.hasownproperty |

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

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

參見
--

* Enumerability and ownership of properties (en-US)
* `Object.getOwnPropertyNames()` (en-US)
* `for...in`
* `in` (en-US)
* JavaScript Guide: Inheritance revisited (en-US)
String.prototype.trim()
=======================

**`trim()`** 方法會移除字串起始及結尾處的空白字元。
 本文中的空白字元指所有空格字元（如：空格、欄標、無間斷空格等等）及換行字元（如：換行、回車等等）。

嘗試一下
----

語法
--


```js
trim()
```

### 回傳值

回傳一個新的字串，其為把 `str` 起始及結尾處的空白字元移除後的值。

如果 `str` 的起始及結尾處沒有任何的空白字元，此方法不會拋出任何例外，且仍然會回傳一個新的字串（本質上為 `str` 的複製）。

如果只是想要去除字串起始處或結尾處其中之一的空白字元，那麼可以選擇使用 `trimStart()` (en-US) 或者 `trimEnd()` (en-US)。

Polyfill
--------

在任何其他的程式碼被執行之前，先執行以下的程式碼，它將會在瀏覽器本身未支援 `trim()` 的方法時創造它。


```js
if (!String.prototype.trim) {
  String.prototype.trim = function () {
    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
  };
}
```

範例
--

### 如何使用 `trim()`

以下例子會印出小寫的字串 `'foo'`：


```js
var orig = " foo ";
console.log(orig.trim()); // 'foo'
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.trim |

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

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

參見
--

* `String.prototype.trimStart()` (en-US)
* `String.prototype.trimEnd()` (en-US)
String.prototype.concat()
=========================

**`concat()`** 會將呼叫此方法的字串以及作為參數傳遞進此方法的字串串接在一起，並將串接結果作為一個新的字串回傳。

嘗試一下
----

語法
--


```js
concat(str1)
concat(str1, str2)
concat(str1, str2, ... , strN)
```

### 參數

`strN`

要串接到 `str` 的字串，可以傳入一個至多個。

### 回傳值

此方法會回傳一個新的字串，由呼叫此方法的字串及作為參數傳入的字串組合而成。

描述
--

`concat()` 會將那些作為參數的字串串接在呼叫此方法的字串後面，並作為一個新的字串回傳。
 對於原先的字串、或是回傳的字串做修改，不會讓他們的值互相影響。

如果傳入的參數不是字串型別，那在串接前會先將該參數轉換成字串。

效能
--

 對於字串的串接，強烈建議直接使用運算子 assignment operators (en-US) 來達成，
 像是 `+` 及 `+=`，而不是使用 `concat()` 方法。

範例
--

### 如何使用 concat()

以下的例子示範如何將那些給定的字串組合成新的字串。


```js
let hello = "Hello, ";
console.log(hello.concat("Kevin", ". Have a nice day."));
// Hello, Kevin. Have a nice day.

let greetList = ["Hello", " ", "Venkat", "!"];
"".concat(...greetList); // "Hello Venkat!"

"".concat({}); // [object Object]
"".concat([]); // ""
"".concat(null); // "null"
"".concat(true); // "true"
"".concat(4, 5); // "45"
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.concat |

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

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

參見
--

* `Array.prototype.concat()`
* Assignment operators (en-US)
String.prototype.toLowerCase()
==============================

**`toLowerCase()`** 函式会回传将字符串转换为英文小写字母后的结果。

嘗試一下
----

语法
--


```js
str.toLowerCase()
```

### 回传值

回传一组将原字串英文内容转换成英文小写字母后的结果。

描述
--

The `toLowerCase()` 函式会回传一组将原字符串英文内容转换成英文小写字母后的结果。 `toLowerCase()` 并不会影响到原字符串 `str` 的内容值。

范例
--

### 使用 `toLowerCase()`


```js
console.log("ALPHABET".toLowerCase()); // 'alphabet'
```

规范
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolowercase |

浏览器相容性
------

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

參見
--

* `String.prototype.toLocaleLowerCase()` (en-US)
* `String.prototype.toLocaleUpperCase()` (en-US)
* `String.prototype.toUpperCase()` (en-US)
String.prototype.padStart()
===========================

**實驗性質:** **這是一個實驗中的功能 (en-US)**  
此功能在某些瀏覽器尚在開發中，請參考兼容表格以得到不同瀏覽器用的前輟。

**`padStart()`** 會將用給定用於填充的字串，以重複的方式，插入到目標字串的起頭(左側)，直到目標字串到達指定長度。

Syntax
------


```js
str.padStart(targetLength [, padString])
```

### Parameters

`targetLength`

目標字串被填充後的長度。如果此參數小於原字串的長度，那將直接返回原字串。

`padString` 選擇性

用來填充的字串。如果填充字串太長，則由左側開始，擷取所需要的長度。此參數預設值是空白 " " (U+0020).

### Return value

目標字串被填充到指定長度後，所得的新字串。

Examples
--------


```js
"abc".padStart(10); // " abc"
"abc".padStart(10, "foo"); // "foofoofabc"
"abc".padStart(6, "123465"); // "123abc"
```

規範
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.padstart |

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

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

參見
--

* `String.padEnd()` (en-US)