Int8Array() constructor - JavaScript

Int8Array() constructor
=======================

**`Int8Array()`** 형식화 배열(TypedArray)의 생성자는 2의 보수 8비트의 부호있는 정수의 배열을 생성합니다.
 배열의 내용은 0으로 초기화됩니다. 배열이 생성되면 객체의 메서드를 사용하거나 표준 배열 인덱스 구문(즉, 대괄호 표기법 사용)을 사용하여
 배열의 요소를 참조할 수 있습니다.

구문
--

```js
new Int8Array()
new Int8Array(length)
new Int8Array(typedArray)
new Int8Array(object)

new Int8Array(buffer)
new Int8Array(buffer, byteOffset)
new Int8Array(buffer, byteOffset, length)
```

**참고:** `Int8Array()`는 오직 `new`
 로만 생성할 수 있습니다. `new` 없이 호출을 시도하면 `TypeError` 예외가 발생합니다.

### 매개변수

`TypedArray`를 참고하세요.

### 예외

`TypedArray`를 참고하세요.

예제
--

### Int8Array를 생성하기 위한 각기 다른 여러 방법

```js
// 길이로부터 생성
const int8 = new Int8Array(2);
int8[0] = 42;
console.log(int8[0]); // 42
console.log(int8.length); // 2
console.log(int8.BYTES\_PER\_ELEMENT); // 1

// 배열로부터 생성
const x = new Int8Array([21, 31]);
console.log(x[1]); // 31

// 다른 TypedArray로부터 생성
const y = new Int8Array(x);
console.log(y[0]); // 21

// ArrayBuffer로부터 생성
const buffer = new ArrayBuffer(8);
const z = new Int8Array(buffer, 1, 4);
console.log(z.byteOffset); // 1

// 순회로부터 생성
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const int8FromIterable = new Int8Array(iterable);
console.log(int8FromIterable);
// Int8Array [1, 2, 3]
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

브라우저 호환성
--------

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

같이 보기
-----

* `core-js`에서 `Int8Array` 폴리필
* JavaScript 형식화 배열
* `ArrayBuffer`
* `DataView`


TypeError() constructor - JavaScript

TypeError() constructor
=======================

**`TypeError`** 생성자는 객체는 일반적으로 값이 기대하던 자료형이 아니라서 연산을 할 수 없을 때 발생하는 오류를 생성합니다.

구문
--

```js
new TypeError()
new TypeError(message)
new TypeError(message, options)
new TypeError(message, fileName)
new TypeError(message, fileName, lineNumber)

TypeError()
TypeError(message)
TypeError(message, options)
TypeError(message, fileName)
TypeError(message, fileName, lineNumber)
```

**참고:** `TypeError()` `new`를 사용하거나 혹은 사용하지 않고 호출이 사용합니다. 두 방법 모두 새로운 `TypeError`를 생성합니다.

### 매개변수

`message` Optional

사람이 읽을 수 있는 오류에 대한 설명

`options` Optional

다음의 속성을 가지는 객체.

`cause` Optional

 오류의 특정 원인을 가리키는 속성.
 오류를 잡아서 좀 더 상세하거나 유용한 오류 메시지와 함께 예외를 다시 발생시킬 때 이 속성을 원래 오류를 전달하는데 사용할 수 있습니다.

`fileName` Optional
비표준

예외가 발생한 코드를 담고 있는 파일 이름

`lineNumber` Optional
비표준

예외가 발상한 코드의 줄 수

예제
--

### TypeError 처리하기

```js
try {
  null.f();
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "null has no properties"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### TypeError 생성하기

```js
try {
  throw new TypeError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof TypeError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "TypeError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

브라우저 호환성
--------

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

같이 보기
-----

* `Error`


Promise.prototype.finally() - JavaScript

Promise.prototype.finally()
===========================

**`finally()`** 메소드는 `Promise` 객체를 반환합니다. Promise가 처리되면 충족되거나 거부되는지 여부에 관계없이 지정된 콜백 함수가 실행됩니다. 이것은 Promise가 성공적으로 수행 되었는지 거절되었는지에 관계없이 `Promise`가 처리 된 후에 코드가 무조건 한 번은 실행되는 것을 제공합니다.

이것은 Promise의 `then()`과 `catch()` (en-US) 핸들러에서의 코드 중복을 피하게 합니다.

문법
--

```js
p.finally(onFinally);

p.finally(function () {
  // settled (fulfilled or rejected)
});
```

### Parameters

`onFinally`

`Promise`가 처리된 후 `Function` 이 호출됩니다.

### Return value

`finally` 핸들러는 `onFinally` 라는 지정된 함수의 `Promise`가 반환됩니다.

설명
--

`finally()` 메서드는 결과에 관계없이 promise가 처리되면 무언가를 프로세싱 또는 정리를 수행하려는 경우에 유용합니다.

`finally()` 메서드는 `.then(onFinally, onFinally)` 를 호출하는 것과 매우 비슷하지만 몇 가지 차이점이 있습니다:

* 함수를 인라인으로 만들 때, 두 번 선언해야 하지 않고 한 번만 전달하거나 그것을 위한 변수를 만들 수 있습니다.
* `finally` 콜백은 어떠한 인수도 전달받지 않습니다, 왜냐하면 promise가 이행되었는지 또는 거부되었는지를 판단할 수 없기 때문입니다. promise의 왜 거부되었는지 또는 이행되었을때 반환되는 값이 필요하지 않거나 제공할 필요가 없을 때 활용합니다.
* Promise.reject (3) .finally (() => {}) Promise.reject (3) .finally (() => {}) (약속 안 함) )는 3으로 거부됩니다.
* `Promise.resolve(2).then(() => {}, () => {})`(`undefined`로 해결될) 와 달리, `Promise.resolve(2).finally(() => {})` 는 값 `2`로 해결됩니다.
* 유사하게 `Promise.reject(3).then(() => {}, () => {})` (`undefined`로 거부될)와는 달리 `Promise.reject(3).finally(() => {})` 는 값 `3`로 거부됩니다.

**참고:** `finally` 콜백에서 `throw` (또는 거부된 promise를 반환)하면 `throw()`를 호출 할 때 지정된 거부 이유로 새롭게 만들어진 promise를 반환합니다.

예제
--

```js
let isLoading = true;

fetch(myRequest)
  .then(function (response) {
    var contentType = response.headers.get("content-type");
    if (contentType && contentType.includes("application/json")) {
      return response.json();
    }
    throw new TypeError("Oops, we haven't got JSON!");
  })
  .then(function (json) {
    /\* process your JSON further \*/
  })
  .catch(function (error) {
    console.log(error);
  })
  .finally(function () {
    isLoading = false;
  });
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.finally |

브라우저 호환성
--------

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

더보기
---

* `Promise`
* `Promise.prototype.then()`
* `Promise.prototype.catch()` (en-US)


Promise.allSettled() - JavaScript

Promise.allSettled()
====================

**`Promise.allSettled()`** 메서드는 주어진 모든 프로미스를 이행하거나 거부한 후, 각 프로미스에 대한 결과를 나타내는 객체 배열을 반환합니다.

일반적으로 서로의 성공 여부에 관련 없는 여러 비동기 작업을 수행해야 하거나, 항상 각 프로미스의 실행 결과를 알고 싶을 때 사용합니다.

그에 비해, `Promise.all()`이 반환한 프로미스는 서로 연관된 작업을 수행하거나, 하나라도 거부 당했을 때 즉시 거부하고 싶을 때 적합합니다.

시도해보기
-----

문법
--

```js
Promise.allSettled(iterable);
```

### 인자

`iterable`

멤버가 모두 `Promise`인, 배열(`Array`)과 같은 이터러블 객체입니다.

### 반환 값

지정된 Promise 컬렉션의 모든 Promise가 성공적으로 이행되거나 거부되어 완료되면, **보류 중**인 Promise는 **비동기적**으로 이행됩니다. 그 때, 반환된 Promise의 핸들러는 원래 프로미스 집합에 있는 각 프로미스의 결과를 포함하는 배열을 입력으로 전달합니다.

단, `Promise.allSettled()`는 빈 이터러블 객체를 인자로 전달받았을 **경우에만** 빈 배열로써 **이미 이행된** 객체를 반환합니다.

반환된 각 객체별로 `status`를 확인할 수 있습니다. 만약 `fulfilled` 상태라면 `value`를, `rejected` 상태라면면 `reason` 속성을 확인할 수 있습니다. value나 reason을 통해 각 Promise가 어떻게 이행(또는 거부)됐는지 알 수 있습니다.

예제
--

### Promise.allSettled의 사용

#### `Promise.prototype.then()`

```js
Promise.allSettled([
  Promise.resolve(33),
  new Promise((resolve) => setTimeout(() => resolve(66), 0)),
  99,
  Promise.reject(new Error("an error")),
]).then((values) => console.log(values));

// [
// {status: "fulfilled", value: 33},
// {status: "fulfilled", value: 66},
// {status: "fulfilled", value: 99},
// {status: "rejected", reason: Error: an error}
// ]
```

#### `await`

```js
const values = await Promise.allSettled([
  Promise.resolve(33),
  new Promise((resolve) => setTimeout(() => resolve(66), 0)),
  99,
  Promise.reject(new Error("an error")),
]);
console.log(values);

// [
// {status: "fulfilled", value: 33},
// {status: "fulfilled", value: 66},
// {status: "fulfilled", value: 99},
// {status: "rejected", reason: Error: an error}
// ]
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.allsettled |

브라우저 호환성
--------

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

같이 보기
-----

* core-js에서 사용가능한 `Promise.allSettled`의 폴리필
* Promises
* Using promises
* Graceful asynchronous programming with promises
* `Promise`
* `Promise.all()`


Promise.race() - JavaScript

Promise.race()
==============

**`Promise.race()`** 메소드는 Promise 객체를 반환합니다. 이 프로미스 객체는 iterable 안에 있는 프로미스 중에 가장 먼저 완료된 것의 결과값으로 그대로 이행하거나 거부합니다.

시도해보기
-----

구문
--

```js
Promise.race(iterable);
```

### 매개변수

`iterable`

`Array`와 같은 iterable 객체. iterable을 참고하세요.

### 반환값

주어진 iterable에서 처음으로 이행하거나 거부한 프로미스의 값을 **비동기적으로** 전달받는 **대기 중**인 `Promise`.

설명
--

`race` 함수는 인자로 주어진 iterable의 프로미스 중 가장 먼저 완료(settle)되는 것과 같은 방식으로 완료(이행/거부)되고, 같은 결과값을 전달하는 `Promise`를 반환합니다.

전달받은 iterable이 비어 있을 경우, 반환한 프로미스는 영원히 대기 상태가 됩니다.

Iterable에 프로미스가 아닌 값이나 이미 완료된 프로미스가 포함되어 있을 경우, `Promise.race`는 전달받은 iterable에서 처음으로 등장하는 이러한 값을 결과값으로 이행합니다.

예제
--

### `Promise.race`의 비동기성

다음 예제에서 `Promise.race`의 비동기성을 확인할 수 있습니다.

```js
// Promise.race를 최대한 빨리 완료시키기 위해
// 이미 이행된 프로미스로 배열을 만들어 인자로 전달
var resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)];

var p = Promise.race(resolvedPromisesArray);
// 실행 즉시 p의 값을 기록
console.log(p);

// 호출 스택을 비운 다음 실행하기 위해 setTimeout을 사용
setTimeout(function () {
  console.log("the stack is now empty");
  console.log(p);
});

// 로그 출력 결과 (순서대로):
// Promise { <state>: "pending" }
// the stack is now empty
// Promise { <state>: "fulfilled", <value>: 33 }
```

비어 있는 iterable을 전달하면 반환한 프로미스는 영원히 대기 상태가 됩니다.

```js
var foreverPendingPromise = Promise.race([]);
console.log(foreverPendingPromise);
setTimeout(function () {
  console.log("the stack is now empty");
  console.log(foreverPendingPromise);
});

// 로그 출력 결과 (순서대로):
// Promise { <state>: "pending" }
// the stack is now empty
// Promise { <state>: "pending" }
```

Iterable에 프로미스가 아닌 값이나 이미 완료된 프로미스가 포함되어 있을 경우, `Promise.race`는 전달받은 iterable에서 처음으로 등장하는 이러한 값을 결과값으로 이행합니다.

```js
var foreverPendingPromise = Promise.race([]);
var alreadyFulfilledProm = Promise.resolve(666);

var arr = [foreverPendingPromise, alreadyFulfilledProm, "프로미스 아님"];
var arr2 = [foreverPendingPromise, "프로미스 아님", Promise.resolve(666)];
var p = Promise.race(arr);
var p2 = Promise.race(arr2);

console.log(p);
console.log(p2);
setTimeout(function () {
  console.log("the stack is now empty");
  console.log(p);
  console.log(p2);
});

// 로그 출력 결과 (순서대로):
// Promise { <state>: "pending" }
// Promise { <state>: "pending" }
// the stack is now empty
// Promise { <state>: "fulfilled", <value>: 666 }
// Promise { <state>: "fulfilled", <value>: "프로미스 아님" }
```

### `setTimeout`과 함께 `Promise.race` 사용 예

```js
var p1 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve("하나"), 500);
});
var p2 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve("둘"), 100);
});

Promise.race([p1, p2]).then(function (value) {
  console.log(value); // "둘"
  // 둘 다 이행하지만 p2가 더 빠르므로
});

var p3 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve("셋"), 100);
});
var p4 = new Promise(function (resolve, reject) {
  setTimeout(() => reject(new Error("넷")), 500);
});

Promise.race([p3, p4]).then(
  function (value) {
    console.log(value); // "셋"
    // p3이 더 빠르므로 이행함
  },
  function (reason) {
    // 실행되지 않음
  },
);

var p5 = new Promise(function (resolve, reject) {
  setTimeout(() => resolve("다섯"), 500);
});
var p6 = new Promise(function (resolve, reject) {
  setTimeout(() => reject(new Error("여섯")), 100);
});

Promise.race([p5, p6]).then(
  function (value) {
    // 실행되지 않음
  },
  function (error) {
    console.log(error.message); // "여섯"
    // p6이 더 빠르므로 거부함
  },
);
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.race |

브라우저 호환성
--------

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

같이 보기
-----

* `Promise`
* `Promise.all()`


Promise.resolve() - JavaScript

Promise.resolve()
=================

**`Promise.resolve(value)`** 메서드는 주어진 값으로 이행하는 `Promise.then` 객체를 반환합니다. 그 값이 프로미스인 경우, 해당 프로미스가 반환됩니다. 그 값이 thenable(예, `"then" 메소드` 가 있음)인 경우, 반환된 프로미스는 그 thenable을 "따르며", 그 최종 상태를 취합니다. 그렇지 않으면 반환된 프로미스는 그 값으로 이행합니다. 이 함수는 프로미스형의 객체(무언가를 결정하는 프로미스를 결정하는 프로미스 등)의 중첩된 레이어를 단일 레이어로 펼칩니다.

**경고:** **주의**: 스스로를 결정하는 thenable 에서 `Promise.resolve` 를 호출하면 안됩니다. 이는 무한히 중첩된 프로미스를 펼치려고하므로 무한 재귀를 유발할 것입니다. Angular 에서 `async` Pipe 를 함께 사용한 예제입니다. 자세한 내용은 여기에서 확인하세요.

시도해보기
-----

구문
--

```js
Promise.resolve(value);
```

### 파라미터

value

이 `Promise`에 의해 결정되는 인수. `Promise` 또는 이행할 thenable 일수도 있습니다.

### 반환 값

주어진 값으로 이행된 `Promise` 또는 값이 promise 객체인 경우, 값으로 전달된 promise.

설명
--

정적 `Promise.resolve` 함수는 이행된 `Promise` 를 반환합니다.

예시
--

### 정적 `Promise.resolve` 메소드 사용

```js
Promise.resolve("Success").then(
  function (value) {
    console.log(value); // "Success"
  },
  function (value) {
    // 호출되지 않음
  },
);
```

### 배열 이행

```js
var p = Promise.resolve([1, 2, 3]);
p.then(function (v) {
  console.log(v[0]); // 1
});
```

### 또 다른 `Promise` 이행

```js
var original = Promise.resolve(33);
var cast = Promise.resolve(original);
cast.then(function (value) {
  console.log("value: " + value);
});
console.log("original === cast ? " + (original === cast));

// 로그 순서:
// original === cast ? true
// value: 33
```

로그의 순서가 반대인 이유는 `then` 핸들러가 비동기로 호출되기 때문입니다. 여기에서 `then` 이 동작하는 방식에 대해 확인하세요.

### thenable 이행 및 오류 발생

```js
// thenable 객체 이행
var p1 = Promise.resolve({
  then: function (onFulfill, onReject) {
    onFulfill("fulfilled!");
  },
});
console.log(p1 instanceof Promise); // true, 객체는 Promise 로 변환됨

p1.then(
  function (v) {
    console.log(v); // "fulfilled!"
  },
  function (e) {
    // 호출되지 않음
  },
);

// thenable 이 콜백 이전에 오류를 throw
// Promise 거부
var thenable = {
  then: function (resolve) {
    throw new TypeError("Throwing");
    resolve("Resolving");
  },
};

var p2 = Promise.resolve(thenable);
p2.then(
  function (v) {
    // 호출되지 않음
  },
  function (e) {
    console.log(e); // TypeError: Throwing
  },
);

// thenable 이 콜백 이후에 오류를 throw
// Promise 이행
var thenable = {
  then: function (resolve) {
    resolve("Resolving");
    throw new TypeError("Throwing");
  },
};

var p3 = Promise.resolve(thenable);
p3.then(
  function (v) {
    console.log(v); // "Resolving"
  },
  function (e) {
    // 호출되지 않음
  },
);
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.resolve |

브라우저 호환성
--------

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

함께 보기
-----

* `Promise`


Promise.reject() - JavaScript

Promise.reject()
================

**`Promise.reject(reason)`** 메서드는 주어진 이유(reason)로 거부된 `Promise` 객체를 반환합니다.

구문
--

```js
Promise.reject(reason);
```

### 매개변수

reason

이 `Promise`를 거부한 이유.

설명
--

정적 `Promise.reject` 함수는 거부된 `Promise`를 반환합니다. 디버깅 목적 및 까다로운 오류를 잡기 위해, `reason`을 `Error`생성자의 인스턴스로 만들면 유용합니다.

예
-

### 정적 Promise.reject() 메서드 사용

```js
Promise.reject("Testing static reject").then(
  function (reason) {
    // 호출되지 않음
  },
  function (reason) {
    console.log(reason); // "Testing static reject"
  },
);

Promise.reject(new Error("fail")).then(
  function (error) {
    // 호출되지 않음
  },
  function (error) {
    console.log(error); // Stacktrace
  },
);
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.reject |

브라우저 호환성
--------

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

참조
--

* `Promise`
* BlueBird Promise 라이브러리를 사용해 선택된 오류 잡기


Promise.prototype.then() - JavaScript

Promise.prototype.then()
========================

**`then()`** 메서드는 `Promise` (en-US)를 리턴하고 두 개의 콜백 함수를 인수로 받습니다. 하나는 `Promise`가 **이행**했을 때, 다른 하나는 **거부**했을 때를 위한 콜백 함수입니다.

시도해보기
-----

**참고:** 매개변수 중 하나 이상을 생략했거나 함수가 아닌 값을 전달한 경우, `then`은 핸들러가 없는 것이 되지만 오류를 발생하지는 않습니다. `then` 바로 이전의 `Promise`가 `then`에 핸들러가 없는 상태로 완료(이행이나 거부)했을 경우, 추가 핸들러가 없는 `Promise`가 생성되며, 원래 `Promise`의 마지막 상태를 그대로 물려받습니다.

구문
--

```js
p.then(onFulfilled, onRejected);

p.then(function(value) {
  // 이행
}, function(reason) {
  // 거부
});
```

### 매개변수

`onFulfilled`

`Promise`가 수행될 때 호출되는 `Function`으로, **이행 값(fulfillment value)** 하나를 인수로 받습니다.

`onRejected`

`Promise`가 거부될 때 호출되는 `Function`으로, **거부 이유(rejection reason)** 하나를 인수로 받습니다.

### 반환값

`Promise`가 이행하거나 거부했을 때, 각각에 해당하는 핸들러 함수(`onFulfilled`나 `onRejected`)가 **비동기적으로** 실행됩니다. 핸들러 함수는 다음 규칙을 따라 실행됩니다.

* 함수가 값을 반환할 경우, `then`에서 반환한 프로미스는 그 반환값을 자신의 결과값으로 하여 이행합니다.
* 값을 반환하지 않을 경우, `then`에서 반환한 프로미스는 `undefined`를 결과값으로 하여 이행합니다.
* 오류가 발생할 경우, `then`에서 반환한 프로미스는 그 오류를 자신의 결과값으로 하여 거부합니다.
* 이미 이행한 프로미스를 반환할 경우, `then`에서 반환한 프로미스는 그 프로미스의 결과값을 자신의 결과값으로 하여 이행합니다.
* 이미 거부한 프로미스를 반환할 경우, `then`에서 반환한 프로미스는 그 프로미스의 결과값을 자신의 결과값으로 하여 거부합니다.
* **대기 중**인 프로미스를 반환할 경우, `then`에서 반환한 프로미스는 그 프로미스의 이행 여부와 결과값을 따릅니다.

다음 예제에서 `then` 메서드의 비동기성을 확인할 수 있습니다.

```js
// 이행한 프로미스를 받으면 'then' 블록도 바로 실행되지만,
// 핸들러는 아래 console.log에서와 같이 비동기적으로 실행됨
const resolvedProm = Promise.resolve(33);

let thenProm = resolvedProm.then((value) => {
  console.log(
    "이 부분은 호출 스택 이후에 실행됩니다. 전달받은 값이자 반환값은 " +
      value +
      "입니다.",
  );
  return value;
});
// thenProm의 값을 즉시 기록
console.log(thenProm);

// setTimeout으로 함수 실행을 호출 스택이 빌 때까지 미룰 수 있음
setTimeout(() => {
  console.log(thenProm);
});

// 로그 출력 결과 (순서대로):
// Promise {[[PromiseStatus]]: "pending", [[PromiseValue]]: undefined}
// "이 부분은 호출 스택 이후에 실행됩니다. 전달받은 값이자 반환값은 33입니다."
// Promise {[[PromiseStatus]]: "resolved", [[PromiseValue]]: 33}
```

설명
--

`then`과 `Promise.prototype.catch()` (en-US) 메서드는 프로미스를 반환하기 때문에, 체이닝이 가능합니다. 이를 *합성*이라고도 합니다.

예제
--

### `then` 메서드 사용

```js
var p1 = new Promise(function (resolve, reject) {
  resolve("성공!");
  // 또는
  // reject("오류!");
});

p1.then(
  function (value) {
    console.log(value); // 성공!
  },
  function (reason) {
    console.log(reason); // 오류!
  },
);
```

### 체이닝

`then` 메서드는 `Promise`를 리턴하기 때문에, 이어지는 `then` 호출들을 손쉽게 연결할 수 있습니다.

`then`에 핸들러로 전달된 함수가 프로미스를 반환할 경우, 이와 동등한 프로미스가 메서드 체인의 그다음 `then`에 노출됩니다. 아래 예제에서는 `setTimeout` 함수로 비동기 코드를 흉내냅니다.

```js
Promise.resolve("foo")
  // 1. "foo"를 받고 "bar"를 추가한 다음 그 값으로 이행하여 다음 then에 넘겨줌
  .then(function (string) {
    return new Promise(function (resolve, reject) {
      setTimeout(function () {
        string += "bar";
        resolve(string);
      }, 1);
    });
  })
  // 2. "foobar"를 받고 그대로 다음 then에 넘겨준 뒤,
  // 나중에 콜백 함수에서 가공하고 콘솔에 출력
  .then(function (string) {
    setTimeout(function () {
      string += "baz";
      console.log(string);
    }, 1);
    return string;
  })
  // 3. 이 부분의 코드는 이전의 then 블록 안의 (가짜) 비동기 코드에서
  // 실제로 문자열을 가공하기 전에 실행됨
  .then(function (string) {
    console.log(
      "마지막 Then: 앗... 방금 then에서 프로미스 만들고 반환하는 걸 까먹어서 " +
        "출력 순서가 좀 이상할지도 몰라요",
    );

    // 'baz' 부분은 setTimeout 함수로 비동기적으로 실행되기 때문에
    // 이곳의 string에는 아직 'baz' 부분이 없음
    console.log(string);
  });

// 로그 출력 결과 (순서대로):
// 마지막 Then: 앗... 방금 then에서 프로미스 만들고 반환하는 걸 까먹어서 출력 순서가 좀 이상할지도 몰라요
// foobar
// foobarbaz
```

`then` 핸들러에서 값을 그대로 반환한 경우에는 `Promise.resolve(<핸들러에서 반환한 값>)`을 반환하는 것과 같습니다.

```js
var p2 = new Promise(function (resolve, reject) {
  resolve(1);
});

p2.then(function (value) {
  console.log(value); // 1
  return value + 1;
}).then(function (value) {
  console.log(value + " - 동기적으로 짜도 돌아감");
});

p2.then(function (value) {
  console.log(value); // 1
});
```

함수에서 오류가 발생하거나 거부한 프로미스를 반환한 경우 `then`에서는 거부한 프로미스를 반환합니다.

```js
Promise.resolve()
  .then(() => {
    // .then()에서 거부한 프로미스를 반환함
    throw new Error("으악!");
  })
  .then(
    () => {
      console.log("실행되지 않는 코드");
    },
    (error) => {
      console.error("onRejected 함수가 실행됨: " + error.message);
    },
  );
```

이외의 모든 경우에는 곧 이행할(비동기적으로 실행되는) 프로미스를 반환합니다. 다음 예제에서는 바로 이전의 프로미스가 거부했음에도 첫 번째 `then`에서는 `42`의 값을 갖는 곧 이행할 프로미스를 반환합니다.

```js
Promise.reject()
  .then(
    () => 99,
    () => 42,
  ) // onRejected에서는 42를 곧 이행할 프로미스로 감싸서 반환함
  .then((solution) => console.log(solution + "로 이행함")); // 42로 이행함
```

실제 개발 시에는 아래와 같이 거부한 프로미스를 `then`의 2단 핸들러보다는 `catch`를 사용해 처리하는 경우가 많습니다.

```js
Promise.resolve()
  .then(() => {
    // .then()에서 거부한 프로미스를 반환함
    throw new Error("으악!");
  })
  .catch((error) => {
    console.error("onRejected 함수가 실행됨: " + error.message);
  })
  .then(() => {
    console.log("처음 then의 프로미스가 거부했지만 그래도 이 코드는 실행됨");
  });
```

체이닝을 이용해 프로미스 기반 함수 위에 다른 프로미스 기반 함수를 구현할 수도 있습니다.

```js
function fetch\_current\_data() {
  // fetch() API는 프로미스를 반환합니다. 이 함수도
  // API가 비슷하지만, 이 함수의 프로미스는
  // 추가 작업을 거친 이후에 이행값을 반환합니다.
  return fetch("current-data.json").then((response) => {
    if (response.headers.get("content-type") != "application/json") {
      throw new TypeError();
    }
    var j = response.json();
    // j 가공하기
    return j; // fetch\_current\_data().then()을 통해
    // 이행값을 사용할 수 있음
  });
}
```

`onFulfilled`가 프로미스를 반환할 경우, `then`의 반환값 역시 그 프로미스에 의해 이행/거부합니다.

```js
function resolveLater(resolve, reject) {
  setTimeout(function () {
    resolve(10);
  }, 1000);
}
function rejectLater(resolve, reject) {
  setTimeout(function () {
    reject(new Error("오류"));
  }, 1000);
}

var p1 = Promise.resolve("foo");
var p2 = p1.then(function () {
  // 1초 뒤에 10으로 이행할 프로미스 반환
  return new Promise(resolveLater);
});
p2.then(
  function (v) {
    console.log("이행", v); // "이행", 10
  },
  function (e) {
    // 실행되지 않음
    console.log("거부", e);
  },
);

var p3 = p1.then(function () {
  // 1초 뒤에 '오류'로 거부할 프로미스 반환
  return new Promise(rejectLater);
});
p3.then(
  function (v) {
    // 실행되지 않음
    console.log("이행", v);
  },
  function (e) {
    console.log("거부", e); // "거부", '오류'
  },
);
```

### `window.setImmediate` (en-US)의 프로미스 기반 폴리필

`Function.prototype.bind()` `Reflect.apply` (`Reflect.apply()`) 메서드를 사용하여 (취소할 수 없는) setImmedate와 비슷한 함수를 생성합니다.

```js
const nextTick = (() => {
  const noop = () => {}; // literally
  const nextTickPromise = () => Promise.resolve().then(noop);

  const rfab = Reflect.apply.bind; // (thisArg, fn, thisArg, [...args])
  const nextTick = (fn, ...args) => (
    fn !== undefined
      ? Promise.resolve(args).then(rfab(null, fn, null))
      : nextTickPromise(),
    undefined
  );
  nextTick.ntp = nextTickPromise;

  return nextTick;
})();
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.prototype.then |

브라우저 호환성
--------

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

참조
--

* `Promise`
* `Promise.prototype.catch()` (en-US)


Promise.all() - JavaScript

Promise.all()
=============

**`Promise.all()`** 메서드는 순회 가능한 객체에 주어진 모든 프로미스가 이행한 후, 혹은 프로미스가 주어지지 않았을 때 이행하는 `Promise`를 반환합니다. 주어진 프로미스 중 하나가 거부하는 경우, 첫 번째로 거절한 프로미스의 이유를 사용해 자신도 거부합니다.

시도해보기
-----

구문
--

```js
Promise.all(iterable);
```

### 매개변수

`iterable`

`Array`와 같이 순회 가능한(iterable) 객체.

### 반환 값

* 매개변수로 주어진 순회 가능한 객체가 비어 있으면 **이미 이행한** `Promise`.
* 객체에 프로미스가 없으면, **비동기적으로 이행하는** `Promise`. 단, Google Chrome 58은 **이미 이행한** 프로미스를 반환합니다.
* 그렇지 않은 경우, **대기 중**인 `Promise`. 결과로 반환하는 프로미스는 인자의 모든 프로미스가 이행하거나 어떤 프로미스가 거부할 때 (호출 스택이 비는 즉시) **비동기적으로** 이행/거부합니다. "`Promise.all`의 동기성/비동기성" 예제를 참고하세요. 반환하는 프로미스의 이행 값은 매개변수로 주어진 프로미스의 순서와 일치하며, 완료 순서에 영향을 받지 않습니다.
설명
--

이 메서드는 여러 프로미스의 결과를 집계할 때 유용하게 사용할 수 있습니다. 일반적으로 다음 코드를 계속 실행하기 전에 서로 연관된 비동기 작업 여러 개가 모두 이행되어야 하는 경우에 사용됩니다.

입력 값으로 들어온 프로미스 중 **하나라도** 거부 당하면 `Promise.all()`은 즉시 거부합니다. 이에 비해, `Promise.allSettled()`가 반환하는 프로미스는 이행/거부 여부에 관계없이 주어진 프로미스가 모두 완료될 때까지 기다립니다. 결과적으로, 주어진 이터러블의 모든 프로미스와 함수의 결과 값을 최종적으로 반환합니다.

### 이행

반환한 프로미스의 이행 결과값은 (프로미스가 아닌 값을 포함하여) 매개변수로 주어진 순회 가능한 객체에 포함된 **모든** 값을 담은 배열입니다.

* 빈 객체를 전달한 경우, (동기적으로) 이미 이행한 프로미스를 반환합니다.
* 전달받은 모든 프로미스가 이미 이행되어 있거나 프로미스가 없는 경우, 비동기적으로 이행하는 프로미스를 반환합니다.
### 거부

주어진 프로미스 중 하나라도 거부하면, 다른 프로미스의 이행 여부에 상관없이 첫 번째 거부 이유를 사용해 거부합니다.

예제
--

### `Promise.all` 사용하기

`Promise.all`은 배열 내 모든 값의 이행(또는 첫 번째 거부)을 기다립니다.

```js
var p1 = Promise.resolve(3);
var p2 = 1337;
var p3 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("foo");
  }, 100);
});

Promise.all([p1, p2, p3]).then((values) => {
  console.log(values); // [3, 1337, "foo"]
});
```

순회 가능한 객체에 프로미스가 아닌 값이 들어있다면 무시하지만, 이행 시 결과 배열에는 포함합니다.

```js
// 매개변수 배열이 빈 것과 동일하게 취급하므로 이행함
var p = Promise.all([1, 2, 3]);
// 444로 이행하는 프로미스 하나만 제공한 것과 동일하게 취급하므로 이행함
var p2 = Promise.all([1, 2, 3, Promise.resolve(444)]);
// 555로 거부하는 프로미스 하나만 제공한 것과 동일하게 취급하므로 거부함
var p3 = Promise.all([1, 2, 3, Promise.reject(555)]);

// setTimeout()을 사용해 스택이 빈 후에 출력할 수 있음
setTimeout(function () {
  console.log(p);
  console.log(p2);
  console.log(p3);
});

// 출력
// Promise { <state>: "fulfilled", <value>: Array[3] }
// Promise { <state>: "fulfilled", <value>: Array[4] }
// Promise { <state>: "rejected", <reason>: 555 }
```

### `Promise.all`의 동기성/비동기성

다음 예제는 `Promise.all`의 비동기성(주어진 인자가 빈 경우엔 동기성)을 보입니다.

```js
// Promise.all을 최대한 빨리 완료시키기 위해
// 이미 이행된 프로미스로 배열을 만들어 인자로 전달
var resolvedPromisesArray = [Promise.resolve(33), Promise.resolve(44)];

var p = Promise.all(resolvedPromisesArray);
// 실행 즉시 p의 값을 기록
console.log(p);

// 호출 스택을 비운 다음 실행하기 위해 setTimeout을 사용
setTimeout(function () {
  console.log("the stack is now empty");
  console.log(p);
});

// 로그 출력 결과 (순서대로):
// Promise { <state>: "pending" }
// the stack is now empty
// Promise { <state>: "fulfilled", <value>: Array[2] }
```

`Promise.all()`이 거부하는 경우에도 동일한 일이 발생합니다:

```js
var mixedPromisesArray = [Promise.resolve(33), Promise.reject(44)];
var p = Promise.all(mixedPromisesArray);
console.log(p);
setTimeout(function () {
  console.log("the stack is now empty");
  console.log(p);
});

// 출력
// Promise { <state>: "pending" }
// the stack is now empty
// Promise { <state>: "rejected", <reason>: 44 }
```

그러나, `Promise.all`은 주어진 순회 가능한 객체가 비어있는 경우에만 동기적으로 이행됩니다.

```js
var p = Promise.all([]); // 즉시 이행함
var p2 = Promise.all([1337, "hi"]); // 프로미스가 아닌 값은 무시하지만 비동기적으로 실행됨
console.log(p);
console.log(p2);
setTimeout(function () {
  console.log("the stack is now empty");
  console.log(p2);
});

// 출력
// Promise { <state>: "fulfilled", <value>: Array[0] }
// Promise { <state>: "pending" }
// the stack is now empty
// Promise { <state>: "fulfilled", <value>: Array[2] }
```

### `Promise.all()` 실패 우선성

`Promise.all()`은 배열 내 요소 중 어느 하나라도 거부하면 즉시 거부합니다. 예를 들어, 일정 시간이 지난 이후 이행하는 네 개의 프로미스와, 즉시 거부하는 하나의 프로미스를 전달한다면 `Promise.all()`도 즉시 거부합니다.

```js
var p1 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("하나"), 1000);
});
var p2 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("둘"), 2000);
});
var p3 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("셋"), 3000);
});
var p4 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("넷"), 4000);
});
var p5 = new Promise((resolve, reject) => {
  reject(new Error("거부"));
});

// .catch 사용:
Promise.all([p1, p2, p3, p4, p5])
  .then((values) => {
    console.log(values);
  })
  .catch((error) => {
    console.log(error.message);
  });

// 콘솔 출력값:
// "거부"
```

발생할 수 있는 거부를 사전에 처리해 동작 방식을 바꿀 수 있습니다.

```js
var p1 = new Promise((resolve, reject) => {
  setTimeout(() => resolve("p1\_지연\_이행"), 1000);
});

var p2 = new Promise((resolve, reject) => {
  reject(new Error("p2\_즉시\_거부"));
});

Promise.all([
  p1.catch((error) => {
    return error;
  }),
  p2.catch((error) => {
    return error;
  }),
]).then((values) => {
  console.log(values[0]); // "p1\_지연\_이행"
  console.log(values[1]); // "Error: p2\_즉시\_거부"
});
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise.all |

브라우저 호환성
--------

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

같이 보기
-----

* `Promise`
* `Promise.race()`


Promise() 생성자 - JavaScript

Promise() 생성자
=============

**`Promise`** 생성자는 주로 프로미스를 지원하지 않는 함수를 감쌀 때 사용합니다.

시도해보기
-----

구문
--

```js
new Promise(executor);
```

### 매개변수

`executor`

`resolve` 및 `reject` 인수를 전달할 실행 함수. 실행 함수는 프로미스 구현에 의해 `resolve`와 `reject` 함수를 받아 즉시 실행됩니다(실행 함수는 `Promise` 생성자가 생성한 객체를 반환하기도 전에 호출됩니다). `resolve` 및 `reject` 함수는 호출할 때 각각 프로미스를 이행하거나 거부합니다. 실행 함수는 보통 어떤 비동기 작업을 시작한 후 모든 작업을 끝내면 `resolve`를 호출해 프로미스를 이행하고, 오류가 발생한 경우 `reject`를 호출해 거부합니다. 실행 함수에서 오류를 던지면 프로미스는 거부됩니다. 실행 함수의 반환값은 무시됩니다.

예제
--

`Promise` 객체는 `new` 키워드와 생성자를 사용해 만듭니다. 생성자는 매개변수로 "실행 함수"를 받습니다. 이 함수는 매개 변수로 두 가지 함수를 받아야 하는데, 첫 번째 함수(`resolve`)는 비동기 작업을 성공적으로 완료해 결과를 값으로 반환할 때 호출해야 하고, 두 번째 함수(`reject`)는 작업이 실패하여 오류의 원인을 반환할 때 호출하면 됩니다. 두 번째 함수는 주로 오류 객체를 받습니다.

```js
const myFirstPromise = new Promise((resolve, reject) => {
  // do something asynchronous which eventually calls either:
  //
  // resolve(someValue) // fulfilled
  // or
  // reject("failure reason") // rejected
});
```

함수에 프로미스 기능을 추가하려면, 간단하게 프로미스를 반환하도록 하면 됩니다.

```js
function myAsyncFunction(url) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open("GET", url);
    xhr.onload = () => resolve(xhr.responseText);
    xhr.onerror = () => reject(xhr.statusText);
    xhr.send();
  });
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-promise-constructor |

브라우저 호환성
--------

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

같이 보기
-----

* 프로미스 사용하기


DataView.prototype.getInt32() - JavaScript

DataView.prototype.getInt32()
=============================

`DataView` 인스턴스의 **`getInt32()`** 메서드는 이 `DataView`의 지정된 바이트 오프셋에서
 4바이트를 읽고 이를 32비트 부호 있는 정수로 해석합니다.

시도해보기
-----

구문
--

```js
getInt32(byteOffset)
getInt32(byteOffset, littleEndian)
```

### 매개변수

`byteOffset`

데이터를 읽을 데이터 뷰의 시작점으로부터의 오프셋(바이트).

`littleEndian` Optional

리틀 엔디언 혹은 빅 엔디언 형식으로 32비트 정수를 저장할지
 여부를 나타냅니다. `false` 혹은 `undefined`이라면 빅 엔디안 값을 읽습니다.

### 반환 값

부호 있는 32비트 정수.

### 에러 발생

`RangeError`

데이터 뷰의 끝을 넘어서 읽을 수 있는 `byteOffset`이 설정된 경우 발생합니다.

설명
--

정렬 제약 조건은 없으며, 임의의 오프셋에서 멀티바이트 값을 가져올 수 있습니다.

예제
--

### getInt32 메서드 사용하기

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.getInt32(1); // 0
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getint32 |

브라우저 호환성
--------

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

같이 보기
-----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getInt16() - JavaScript

DataView.prototype.getInt16()
=============================

`DataView` 인스턴스의 **`getInt16()`** 메서드는 이 `DataView`의 지정된 바이트 오프셋에서
 2바이트를 읽고 이를 16비트 부호 있는 정수로 해석합니다.

시도해보기
-----

구문
--

```js
getInt16(byteOffset)
getInt16(byteOffset, littleEndian)
```

### 매개변수

`byteOffset`

데이터를 읽을 데이터 뷰의 시작점으로부터의 오프셋(바이트).

`littleEndian` Optional

리틀 엔디언 혹은 빅 엔디언 형식으로 16비트 정수를 저장할지
 여부를 나타냅니다. `false` 혹은 `undefined`이라면 빅 엔디안 값을 읽습니다.

### 반환 값

부호있는 16비트 정수.

### 에러 발생

`RangeError`

데이터 뷰의 끝을 넘어서 읽을 수 있는 `byteOffset`이 설정된 경우 발생합니다.

설명
--

정렬 제약 조건은 없으며, 임의의 오프셋에서 멀티바이트 값을 가져올 수 있습니다.

예제
--

### getInt16 메서드 사용하기

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.getInt16(1); // 0
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getint16 |

브라우저 호환성
--------

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

같이 보기
-----

* `DataView`
* `ArrayBuffer`


DataView() 생성자 - JavaScript

DataView() 생성자
==============

**`DataView()`** 생성자는 새로운 `DataView` 객체를 생성합니다.

시도해보기
-----

구문
--

```js
    new DataView(buffer [, byteOffset [, byteLength]])
```

### 매개변수

`buffer`

새로운 `DataView` 객체의 저장소로 사용할 `ArrayBuffer` 또는 `SharedArrayBuffer`
Experimental
.

`byteOffset` Optional

새로운 뷰가 참조할 첫 번째 바이트로의 바이트 단위 오프셋. 지정하지 않을 경우 버퍼 뷰는 첫 번째 바이트부터 시작합니다.

`byteLength` Optional

바이트 배열의 요소 수. 지정하지 않을 경우 뷰의 길이는 버퍼의 길이와 같아집니다.

### 반환 값

지정한 데이터 버퍼를 나타내는 새로운 `DataView` 객체.

`DataView` 객체는 배열 버퍼의 "인터프리터"라고 생각하면 좀 더 쉽습니다. `DataView`는 읽기와 쓰기 모두에서 버퍼에 잘 맞도록 숫자를 올바르게 변환하는 법, 즉 정수/부동소수점 실수 변환, 엔디언 등 이진 형식으로 나타낸 숫자의 처리법을 알고 있습니다.

### 예외

`RangeError`

`byteOffset` 또는 `byteLength` 매개변수가 버퍼의 끝을 벗어남.예를 들어, 버퍼가 16바이트 길이인데 `byteOffset`을 8로, `byteLength`를 10으로 설정할 경우 총 길이 18로서 2바이트를 초과하므로 오류가 발생합니다.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview-constructor |

브라우저 호환성
--------

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

같이 보기
-----

* `DataView`


DataView.prototype.getInt8() - JavaScript

DataView.prototype.getInt8()
============================

`DataView` 인스턴스의 **`getInt8()`** 메서드는 이 `DataView`의 지정된 바이트 오프셋에서
 1바이트를 읽고 이를 8비트 부호 있는 정수로 해석합니다.

시도해보기
-----

구문
--

```js
getInt8(byteOffset)
```

### 매개변수

`byteOffset`

데이터를 읽을 데이터 뷰의 시작점으로부터의 오프셋(바이트).

### 반환 값

부호 있는 8비트 정수 숫자.

### 에러 발생

`RangeError`

데이터 뷰의 끝을 넘어서 읽을 수 있는 `byteOffset`이 설정된 경우 발생합니다.

설명
--

정렬 제약 조건은 없으며, 임의의 오프셋에서 멀티바이트 값을 가져올 수 있습니다.

예제
--

### getInt8 메서드 사용하기

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.getInt8(1); // 0
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getint8 |

브라우저 호환성
--------

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

같이 보기
-----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getUint32() - JavaScript

DataView.prototype.getUint32()
==============================

`DataView` 인스턴스의 **`getUint32()`** 메서드는 이 `DataView`의 지정된 바이트 오프셋에서
 4바이트를 읽고 이를 32비트 부호 없는 정수로 해석합니다.

시도해보기
-----

구문
--

```js
getUint32(byteOffset)
getUint32(byteOffset, littleEndian)
```

### 매개변수

`byteOffset`

데이터를 읽을 뷰의 시작 부분으로부터의 오프셋(바이트 단위)입니다.

`littleEndian` Optional

 16비트 정수가 리틀 엔디안 혹은 빅 앤디안 형삭으로 저장되는지 여부를
 나타냅니다. 만약 `false` 혹은 `undefined`라면 빅 엔디언 값을 읽습니다.

### 반환 값

32비트 부호없는 정수.

### 발생하는 에러

`RangeError`

뷰의 끝을 넘어 읽는 수도 있는 `byteOffset`이 설정된 경우 발생합니다.

설명
--

정렬 제약 조건은 없으며, 임의의 오프셋에서 멀티바이트 값을 가져올 수 있습니다.

예제
--

### getUint32 메서드 사용하기

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.getUint32(1); // 0
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getuint32 |

브라우저 호환성
--------

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

같이 보기
-----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getUint16() - JavaScript

DataView.prototype.getUint16()
==============================

`DataView` 인스턴스의 **`getUint16()`** 메서드는 이 `DataView`의 지정된 바이트 오프셋에서
 2바이트를 읽고 이를 16비트 부호 없는 정수로 해석합니다.

시도해보기
-----

구문
--

```js
getUint16(byteOffset)
getUint16(byteOffset, littleEndian)
```

### 매개변수

`byteOffset`

데이터를 읽을 뷰의 시작 부분으로부터의 오프셋(바이트 단위)입니다.

`littleEndian` Optional

 16비트 정수가 리틀 엔디안 혹은 빅 앤디안 형삭으로 저장되는지 여부를
 나타냅니다. 만약 `false` 혹은 `undefined`라면 빅 엔디언 값을 읽습니다.

### 반환 값

16비트 부호없는 정수.

### 발생하는 에러

`RangeError`

뷰의 끝을 넘어 읽는 수도 있는 `byteOffset`이 설정된 경우 발생합니다.

설명
--

정렬 제약 조건은 없으며, 임의의 오프셋에서 멀티바이트 값을 가져올 수 있습니다.

예제
--

### getUint16 메서드 사용하기

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.getUint16(1); // 0
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getuint16 |

브라우저 호환성
--------

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

같이 보기
-----

* `DataView`
* `ArrayBuffer`


DataView.prototype.getUint8() - JavaScript

DataView.prototype.getUint8()
=============================

`DataView` 인스턴스의 **`getUint8()`** 메서드는 이 `DataView`의 지정된 바이트 오프셋에서
 1바이트를 읽고 이를 8비트 부호 없는 정수로 해석합니다.

시도해보기
-----

구문
--

```js
getUint8(byteOffset)
```

### 매개변수

`byteOffset`

데이터를 읽을 뷰의 시작 부분으로부터의 오프셋(바이트 단위)입니다.

### 반환 값

부호 없는 8비트 정수.

### 발생하는 에러

`RangeError`

뷰의 끝을 넘어 읽는 수도 있는 `byteOffset`이 설정된 경우 발생합니다.

설명
--

정렬 제약 조건은 없으며, 임의의 오프셋에서 멀티바이트 값을 가져올 수 있습니다.

예제
--

### getUint8 메서드 사용하기

```js
const buffer = new ArrayBuffer(8);
const dataview = new DataView(buffer);
dataview.getUint8(1); // 0
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview.prototype.getuint8 |

브라우저 호환성
--------

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

같이 보기
-----

* `DataView`
* `ArrayBuffer`


Number.MIN_SAFE_INTEGER - JavaScript

Number.MIN\_SAFE\_INTEGER
=========================

**`Number.MIN_SAFE_INTEGER`** 정적 데이터 속성은 JavaScript에서 안전한 최소 정수값 혹은 (-(253 - 1))을 나타냅니다.

이보다 더 작은 정수값을 표현하기 위해서는 `BigInt` 사용을 고려하시기 바랍니다.

시도해보기
-----

값
-

`-9007199254740991` (-9,007,199,254,740,991, or about -9 quadrillion).

| Property attributes of `Number.MIN_SAFE_INTEGER` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

배정밀도 부동소수점 형식
 은 소수점을 나타내는 비트가 52비트밖에 없으므로 -(253 – 1) 와 253 – 1 사이의 정수만 안전하게 표현할 수 있습니다. 여기서 안전하다는 것은 정수를 정확하게 표현하고 정확하게 비교할 수 있는 능력을 의미합니다.

예를 들어 `Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2`는 수학적으로는 맞지 않지만 참으로 평가됩니다. 자세한 내용은 `Number.isSafeInteger()`를 참조하세요.

`MIN_SAFE_INTEGER`는 `Number`의 정적 속성이기 때문에, 직접 생성한 `Number` 객체의 속성이 아니라 `Number.MIN_SAFE_INTEGER` 형식으로 사용해야 합니다.

예제
--

### MIN\_SAFE\_INTEGER 사용하기

```js
Number.MIN\_SAFE\_INTEGER; // -9007199254740991
-(2 \*\* 53 - 1); // -9007199254740991
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_safe\_integer |

브라우저 호환성
--------

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

같이 보기
-----

* Polyfill of `Number.MIN_SAFE_INTEGER` in `core-js`
* `Number.MAX_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`


Number.prototype.toString() - JavaScript

Number.prototype.toString()
===========================

**`toString()`** 메서드는 특정한 `Number` 객체를 나타내는 문자열을 반환합니다.

시도해보기
-----

구문
--

```js
numObj.toString([radix]);
```

### 매개변수

`radix` Optional

수의 값을 나타내기 위해 사용되기 위한 기준을 정하는 2와 36사이의 정수. (진수를 나타내는 기수의 값.)

### 반환 값

`Number` 객체를 명시하는 문자열.

### 예외

`RangeError`

만약 `toString()` 에 `2` 와 `36` 의 사잇 값이 아닌 `radix` 가 주어지면, `RangeError` 에러가 발생합니다.

설명
--

`Number` 객체는 `Object` 객체의 `toString()`메소드를 오버라이딩하며, `Object.prototype.toString()` 를 상속받지 않습니다. `Number` 객체에서 `toString()` 메소드는 특정 진수로 객체를 표현한 문자열을 환원합니다.

`toString()` 메소드는 메소드의 첫 번째 아규먼트를 파싱하여, 메소드는 특정 기수(radix)를 기준으로 한 진수 값의 문자열을 환원하기 위한 시도를 합니다. 진수를 나타내는 기수 값(radix) 이 10 이상의 값일 때는, 알파벳의 글자는 9보다 큰 수를 나타냅니다. 예를 들면, 16진수(base 16)는, 알파벳 f 까지 사용하여 표현됩니다.

만약에 `radix`값 이 지정되지 않으면, 임의로 10진수로 가정하게 됩니다.

또, `numObj`가 음수라면, - 부호는 유지됩니다. 이는 기수(radix) 값이 2일 경우에라도 적용됩니다. 리턴된 문자열은 - 부호가 앞에 있는 `numObj` 의 양의 2진수 표시이지, `numObj`의 두 개의 조합이 아니기 때문입니다.

`numObj` 가 정수가 아니면, 점(.) 부호는 소수 자리와 분리하기 위해 사용됩니다.

예제
--

### `toString` 사용

```js
var count = 10;

console.log(count.toString()); // displays '10'
console.log((17).toString()); // displays '17'
console.log((17.2).toString()); // displays '17.2'

var x = 6;

console.log(x.toString(2)); // displays '110'
console.log((254).toString(16)); // displays 'fe'

console.log((-10).toString(2)); // displays '-1010'
console.log((-0xff).toString(2)); // displays '-11111111'
```

명세
--

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

브라우저 호환성
--------

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

같이 보기
-----

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`


Number.NEGATIVE_INFINITY - JavaScript

Number.NEGATIVE\_INFINITY
=========================

**`Number.NEGATIVE_INFINITY`** 속성은 음의 무한대를 나타냅니다.

시도해보기
-----

| Property attributes of `Number.NEGATIVE_INFINITY` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`Number.NEGATIVE_INFINITY`의 값은 전역 객체 `Infinity` 속성의 부호를 바꾼 값과 동일합니다.

`NEGATIVE_INFINITY`는 수학에서의 무한대와 약간 다릅니다.

* `POSITIVE_INFINITY`를 포함한 아무 양의 수와 `NEGATIVE_INFINITY`를 곱한 결과는 `NEGATIVE_INFINITY`입니다.
* `NEGATIVE_INFINITY`를 포함한 아무 음의 수와 `NEGATIVE_INFINITY`를 곱한 결과는 `POSITIVE_INFINITY`입니다.
* 아무 양의 수를 `NEGATIVE_INFINITY`로 나눈 결과는 음의 부호를 가진 0입니다.
* 아무 음의 수를 `NEGATIVE_INFINITY`로 나눈 결과는 0입니다.
* 0을 `NEGATIVE_INFINITY`로 나눈 결과는 `NaN`입니다.
* `NaN`에 `NEGATIVE_INFINITY`를 곱한 결과는 `NaN`입니다.
* `NEGATIVE_INFINITY`를, `NEGATIVE_INFINITY`를 제외한 아무 음의 수로 나눈 결과는 `POSITIVE_INFINITY`입니다.
* `NEGATIVE_INFINITY`를, `POSITIVE_INFINITY`를 제외한 아무 양의 수로 나눈 결과는 `NEGATIVE_INFINITY`입니다.
* `NEGATIVE_INFINITY`를 `NEGATIVE_INFINITY` 또는 `POSITIVE_INFINITY`로 나눈 결과는 `NaN`입니다.

`Number.NEGATIVE_INFINITY`를 사용해 성공 시 유한수를 반환하는 식의 결과를 판별할 수 있습니다. 그러나 이런 경우 `isFinite()`를 사용하는 편이 더 적합합니다.

`NEGATIVE_INFINITY`는 `Number`의 정적 속성이기 때문에, 직접 생성한 `Number` 객체의 속성이 아니라 `Number.NEGATIVE_INFINITY`의 형식으로 사용해야 합니다.

예제
--

### `NEGATIVE_INFINITY` 사용하기

다음 코드에서 `smallNumber`는 JavaScript의 최솟값보다 작은 값을 할당받습니다. `if` 문이 실행되면, `smallNumber`의 값이 `-Infinity`이므로 `smallNumber`는 계산에 좀 더 적합한 값을 다시 할당합니다.

```js
var smallNumber = -Number.MAX\_VALUE \* 2;

if (smallNumber === Number.NEGATIVE\_INFINITY) {
  smallNumber = returnFinite();
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.negative\_infinity |

브라우저 호환성
--------

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

같이 보기
-----

* `Number.POSITIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`


Number.prototype.toPrecision() - JavaScript

Number.prototype.toPrecision()
==============================

**`toPrecision()`** 메서드는 `Number` 객체를 지정된 정밀도로 나타내는 문자열을 반환한다.

시도해보기
-----

문법
--

```js
numObj.toPrecision([precision]);
```

### 파라미터

`precision`

선택적 파라미터. 유효 자릿수를 지정하는 정수.

### 반환 값

고정 소수점 또는 지수 표기법의 `Number` 객체를 정밀 유효 숫자로 반올림 한 문자열입니다. `toPrecision()`에도 적용되는 `Number.prototype.toFixed()` 메서드에 대한 설명에서 반올림에 대한 설명을 참조하세요.

`precision(정밀도)` 인수가 생략되면 `Number.prototype.toString()`처럼 작동합니다. `precision(정밀도)` 인수가 정수가 아닌 값이면 가장 가까운 정수로 반올림됩니다.

### 예외

`RangeError`

`precision(정밀도)`가 1에서 100 사이가 아닌 경우 `RangeError`가 발생합니다. 구현은 더 큰 값과 더 작은 값을 지원할 수 있습니다. ECMA-262는 최대 21 자리의 정밀도 만을 요구합니다.

예제
--

### `toPrecision` 사용

```js
var numObj = 5.123456;

console.log(numObj.toPrecision()); // logs '5.123456'
console.log(numObj.toPrecision(5)); // logs '5.1235'
console.log(numObj.toPrecision(2)); // logs '5.1'
console.log(numObj.toPrecision(1)); // logs '5'

numObj = 0.000123;

console.log(numObj.toPrecision()); // logs '0.000123'
console.log(numObj.toPrecision(5)); // logs '0.00012300'
console.log(numObj.toPrecision(2)); // logs '0.00012'
console.log(numObj.toPrecision(1)); // logs '0.0001'

// 일부 상황에서는 지수 표기법이 반환 될 수 있습니다
console.log((1234.5).toPrecision(2)); // logs '1.2e+3'
```

명세
--

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

브라우저 호환성
--------

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

See also
--------

* `Number.prototype.toFixed()`
* `Number.prototype.toExponential()`
* `Number.prototype.toString()`


Number.prototype.toExponential() - JavaScript

Number.prototype.toExponential()
================================

**`toExponential()`** 메서드는 숫자를 지수 표기법으로 표기해 반환합니다.

시도해보기
-----

구문
--

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

### 매개변수

`fractionDigits` Optional

소수점 이하로 표현할 자릿수입니다. 기본값은 주어진 값을 나타내는데 필요한 자릿수입니다.

### 반환 값

주어진 `Number` 값을 숫자 한자리와 소수점, 소수점 이하 `fractionDigits` 자릿수만큼 반올림하여 지수 표기법으로 나타낸 문자열을 반환합니다.

### 예외

`RangeError`

`fractionDigits`가 너무 작거나 너무 크면 `RangeError` 에러가 발생합니다. `fractionDigits`가 0에서 20 사이의 값이면 `RangeError` 에러는 발생하지 않습니다. 구현에 따라 더 크거나 작은 값도 사용 할 수 있습니다.

`TypeError`

`Number`가 아닌 객체가 이 메서드를 실행시키면 `RangeError` 에러가 발생합니다.

설명
--

`fractionDigits` 매개변수를 생략하면, 기본적으로 주어진 값을 특정하기 위해 필요한 자릿수만큼이 소수점 이하 자릿수가 됩니다.

지수나 소수점이 없는 숫자 리터럴에 `toExponential()` 메서드를 사용하려면, 점 앞에 공백을 두어 점이 소수점으로 해석되는 것을 막도록 합니다.

주어진 값의 자릿수가 `fractionDigits` 매개변수보다 크다면, 주어진 값은 `fractionDigits`에 가까운 자릿수로 반올림되어 표현됩니다. `toFixed()` 메서드의 반올림에 관한 설명이 `toExponential()` 메서드에도 마찬가지로 적용됩니다.

예제
--

### `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()`
* `Number.prototype.toString()`


Number.parseInt() - JavaScript

Number.parseInt()
=================

**`Number.parseInt()`** 메서드는 문자열 인자를 파싱하여 특정 진수(수의 진법 체계에서 기준이 되는 값)의 정수를 반환합니다.

시도해보기
-----

구문
--

```js
Number.parseInt(string);
Number.parseInt(string, radix);
```

### 매개변수

`string`

파싱할 값입니다. 문자열이 아닐 경우 `ToString` 추상 연산을 사용해 문자열로 변환합니다. 문자열의 선행 공백은 무시합니다.

`radix` Optional

`string`의 진수를 나타내는 `2`부터 `36`까지의 정수입니다.

`radix`를 생략하거나 `0`을 지정한 경우, `string`이 `0x` 또는 `0X`로 시작하는 경우 `16`을 지정한 것으로 취급하고, 그 외의 경우 `10`으로 취급합니다.

### 반환 값

주어진 `string`에서 파싱한 정수입니다.

다음과 같은 경우에는 `NaN`을 반환합니다.

* `radix`가 2보다 작거나 36보다 큰 경우.
* 공백이 아닌 첫 문자를 숫자로 변환할 수 없는 경우.
설명
--

### Number.parseInt vs parseInt

`Number.parseInt()`는 전역 `parseInt()` 함수와 같은 기능을 가지고 있습니다.

```js
Number.parseInt === parseInt; // true
```

`Number.parseInt()`는 ECMAScript 2015에서 전역 객체의 모듈화를 위해 추가됐습니다. 상세한 정보와 예제는 `parseInt()`를 참고하세요.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parseint |

브라우저 호환성
--------

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

같이 보기
-----

* `core-js`의 `Number.parseInt` 폴리필
* 이 메서드가 속한 `Number` 객체
* 전역 `parseInt()` 메서드


Number.parseFloat() - JavaScript

Number.parseFloat()
===================

**`Number.parseFloat()`** 메서드는 주어진 값을 필요한 경우 문자열로 변환한 후 부동소수점 실수로 파싱해 반환합니다. 숫자를 파싱할 수 없는 경우 `NaN`을 반환합니다.

시도해보기
-----

구문
--

```js
Number.parseFloat(string);
```

### 매개변수

`string`

파싱할 값입니다. 문자열이 아닐 경우 `ToString` 추상 연산을 사용해 문자열로 변환합니다. 문자열의 선행 공백은 무시합니다.

### 반환 값

주어진 문자열에서 파싱한 부동소수점 실수입니다.

공백이 아닌 첫 글자를 숫자로 변환할 수 없는 경우 `NaN`을 반환합니다.

설명
--

### Number.parseFloat vs parseFloat

`Number.parseFloat()`은 전역 `parseFloat()` 함수와 같은 기능을 가지고 있습니다.

```js
Number.parseFloat === parseFloat; // true
```

`Number.parseFloat()`은 ECMAScript 2015에서 전역 객체의 모듈화를 위해 추가됐습니다. 상세한 정보와 예제는 `parseFloat()`를 참고하세요.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.parsefloat |

브라우저 호환성
--------

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

같이 보기
-----

* `core-js`의 `Number.parseFloat` 폴리필
* 이 메서드가 속한 `Number` 객체
* 전역 `parseFloat()` 메서드


Number.MAX_VALUE - JavaScript

Number.MAX\_VALUE
=================

**`Number.MAX_VALUE`** 속성은 JavaScript가 표현할 수 있는 제일 큰 양의 숫자 값을 나타냅니다.

시도해보기
-----

| Property attributes of `Number.MAX_VALUE` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`MAX_VALUE`의 값은 약 `1.79E+308`, 2^1024입니다. `MAX_VALUE`보다 큰 값은 `Infinity`로 표현됩니다.

`MAX_VALUE`는 `Number`의 정적 속성이기 때문에, 직접 생성한 `Number` 객체의 속성이 아니라 `Number.MAX_VALUE` 형식으로 사용해야 합니다.

예제
--

### `MAX_VALUE` 사용하기

다음 코드는 두 개의 수를 곱합니다. 만약 결과가 `MAX_VALUE` 이하면 `func1`을 호출하고, 그렇지 않으면 `func2`를 호출합니다.

```js
if (num1 \* num2 <= Number.MAX\_VALUE) {
  func1();
} else {
  func2();
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_value |

브라우저 호환성
--------

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

참고
--

* `Number.MIN_VALUE`


Number.POSITIVE_INFINITY - JavaScript

Number.POSITIVE\_INFINITY
=========================

**`Number.POSITIVE_INFINITY`** 속성은 양의 무한대를 나타냅니다.

시도해보기
-----

| Property attributes of `Number.POSITIVE_INFINITY` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`Number.POSITIVE_INFINITY`의 값은 전역 객체 `Infinity` 속성의 값과 동일합니다.

`POSITIVE_INFINITY`는 수학에서의 무한대와 약간 다릅니다.

* `POSITIVE_INFINITY`를 포함한 아무 양의 수와 `POSITIVE_INFINITY`를 곱한 결과는 `POSITIVE_INFINITY`입니다.
* `NEGATIVE_INFINITY`를 포함한 아무 음의 수와 `POSITIVE_INFINITY`를 곱한 결과는 `NEGATIVE_INFINITY`입니다.
* 아무 양의 수를 `POSITIVE_INFINITY`로 나눈 결과는 0입니다.
* 아무 음의 수를 `POSITIVE_INFINITY`로 나눈 결과는 음의 부호를 가진 0입니다.
* 0을 `POSITIVE_INFINITY`로 나눈 결과는 `NaN`입니다.
* `NaN`에 `POSITIVE_INFINITY`를 곱한 결과는 `NaN`입니다.
* `POSITIVE_INFINITY`를, `NEGATIVE_INFINITY`를 제외한 아무 음의 수로 나눈 결과는 `NEGATIVE_INFINITY`입니다.
* `POSITIVE_INFINITY`를, `POSITIVE_INFINITY`를 제외한 아무 양의 수로 나눈 결과는 `NEGATIVE_INFINITY`입니다.
* `POSITIVE_INFINITY`를 `NEGATIVE_INFINITY` 또는 `POSITIVE_INFINITY`로 나눈 결과는 `NaN`입니다.

`Number.POSITIVE_INFINITY`를 사용해 성공 시 유한수를 반환하는 식의 결과를 판별할 수 있습니다. 그러나 이런 경우 `isFinite()`를 사용하는 편이 더 적합합니다.

`POSITIVE_INFINITY`는 `Number`의 정적 속성이기 때문에, 직접 생성한 `Number` 객체의 속성이 아니라 `Number.POSITIVE_INFINITY`의 형식으로 사용해야 합니다.

예제
--

### `POSITIVE_INFINITY` 사용하기

다음 코드에서 `bigNumber`는 JavaScript의 최댓값보다 큰 값을 할당받습니다. `if` 문이 실행되면, `bigNumber`의 값이 `Infinity`이므로 `bigNumber`는 계산에 좀 더 적합한 유한값을 다시 할당합니다.

```js
var bigNumber = Number.MAX\_VALUE \* 2;

if (bigNumber === Number.POSITIVE\_INFINITY) {
  bigNumber = returnFinite();
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.positive\_infinity |

브라우저 호환성
--------

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

같이 보기
-----

* `Number.NEGATIVE_INFINITY`
* `Number.isFinite()`
* `Infinity`
* `isFinite()`


Number.isNaN() - JavaScript

Number.isNaN()
==============

**`Number.isNaN()`** 메서드는 주어진 값이 `NaN`인지 판별합니다. 기존부터 존재한 전역 `isNaN()` 함수의 더 엄격한 버전입니다.

시도해보기
-----

구문
--

```js
Number.isNaN(value);
```

### 매개변수

`value`

`NaN`인지 판별할 값.

### 반환 값

주어진 값의 유형이 `Number`이고 값이 `NaN`이면 `true`, 아니면 `false`.

설명
--

`NaN`이 `NaN`인지 계산할 때, 두 동일 연산자 `==`과 `===` 모두 `false`로 평가되므로 값의 `NaN` 여부를 알아내려면 `Number.isNaN()`이 필요합니다. 이 상황은 다른 모든 JavaScript와 다른 특별한 경우입니다.

전역 `isNaN()` 함수와 달리, `Number.isNaN()`은 강제로 매개변수를 숫자로 변환하는 문제를 겪지 않습니다. 이는 이제 보통`NaN`으로 변환됐을 값이 안전하게 전달되지만, 실제로는 `NaN`과 같은 값이 아님을 의미합니다. 이는 또한 오직 숫자형이고 또한 `NaN`인 값만이 `true`를 반환함을 뜻합니다.

예제
--

```js
Number.isNaN(NaN); // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0); // true

// 예를 들면 이들은 global isNaN()으로는 true가 됐을 것임
Number.isNaN("NaN"); // false
Number.isNaN(undefined); // false
Number.isNaN({}); // false
Number.isNaN("blabla"); // false

// 모두
Number.isNaN(true);
Number.isNaN(null);
Number.isNaN(37);
Number.isNaN("37");
Number.isNaN("37.37");
Number.isNaN("");
Number.isNaN(" ");
```

폴리필
---

```js
Number.isNaN =
  Number.isNaN ||
  function (value) {
    return value !== value;
  };
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isnan |

브라우저 호환성
--------

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

같이 보기
-----

* `Number`
* `isNaN()`


Number.EPSILON - JavaScript

Number.EPSILON
==============

**`Number.EPSILON`** 속성(property)은 `Number` 형으로 표현될 수 있는 1과 1보다 큰 값 중에서 가장 작은 값의, 차입니다.

당신은 이 정적 속성에 접근하기 위하여 `Number` 객체를 생성할 필요가 없습니다. `Number.EPSILON`을 쓰면 됩니다.

| Property attributes of `Number.EPSILON` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

이 `EPSILON` 속성은 대략 `2.2204460492503130808472633361816E-16` 또는 `2^-52`의 값을 갖습니다.

예제
--

### 동일성 확인하기

```js
const x = 0.2,
  y = 0.3,
  z = 0.1;
let equal = Math.abs(x - y + z) < Number.EPSILON;
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.epsilon |

브라우저 호환성
--------

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

관련된 문서
------

* 이 속성을 가지고 있는 `Number` 객체


Number.isInteger() - JavaScript

Number.isInteger()
==================

**`Number.isInteger()`** 메서드는 주어진 값이 정수인지 판별합니다.

시도해보기
-----

구문
--

```js
Number.isInteger(value);
```

### 매개변수

`value`

정수인지 확인하려는 값.

### 반환 값

주어진 값의 정수 여부를 나타내는 `Boolean`.

설명
--

매개변수의 값이 정수면 `true`를, 아니면 `false`를 반환합니다. 값이 `NaN`이거나 `Infinity`여도 `false`를 반환합니다.

예제
--

```js
Number.isInteger(0); // true
Number.isInteger(1); // true
Number.isInteger(-100000); // true
Number.isInteger(99999999999999999999999); // true

Number.isInteger(0.1); // false
Number.isInteger(Math.PI); // false

Number.isInteger(NaN); // false
Number.isInteger(Infinity); // false
Number.isInteger(-Infinity); // false
Number.isInteger("10"); // false
Number.isInteger(true); // false
Number.isInteger(false); // false
Number.isInteger([1]); // false
```

폴리필
---

```js
Number.isInteger =
  Number.isInteger ||
  function (value) {
    return (
      typeof value === "number" &&
      isFinite(value) &&
      Math.floor(value) === value
    );
  };
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isinteger |

브라우저 호환성
--------

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

같이 보기
-----

* 메서드가 속한 `Number` 객체.


Number.NaN - JavaScript

Number.NaN
==========

**`Number.NaN`** 속성은 Not-A-Number(숫자가 아님)를 나타냅니다. `NaN`과 같습니다.

시도해보기
-----

정적 속성이므로 접근하기 위해 `Number` 객체를 생성할 필요는 없습니다. (`Number.NaN` 사용)

| Property attributes of `Number.NaN` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

예제
--

### 값이 숫자형인지 확인하기

```js
function sanitise(x) {
  if (isNaN(x)) {
    return Number.NaN;
  }
  return x;
}
```

### NaN에 대한 테스트

`NaN` 페이지에서 NaN에 대한 테스트 를 참고하세요.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.nan |

브라우저 호환성
--------

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

같이보기
----

* 전역 `NaN` 객체.
* 본 속성이 속한 `Number` 객체.


Number.MAX_SAFE_INTEGER - JavaScript

Number.MAX\_SAFE\_INTEGER
=========================

**`Number.MAX_SAFE_INTEGER`** 상수는 JavaScript에서 안전한 최대 정수값을 나타냅니다. (`2^53 - 1`).

시도해보기
-----

| Property attributes of `Number.MAX_SAFE_INTEGER` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`MAX_SAFE_INTEGER` 상수는 `9007199254740991`(9,007,199,254,740,991 또는 약 9000조)의 값을 갖고 있습니다. 이 값의 이유는 JavaScript가 IEEE 754에 기술된 배정밀도 부동소숫점 형식 숫자체계를 사용하기 때문으로, 이로 인해 `-(2^53 - 1)`과 `2^53 - 1` 사이의 수만 안전하게 표현할 수 있습니다.

여기서의 안전함이란 정수를 정확하고 올바르게 비교할 수 있음을 의미합니다. 예를 들어 `Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2`는 참으로 평가되며 이는 수학적으로 올바르지 않습니다. 더 자세한 내용은 `Number.isSafeInteger()`를 참고하세요.

`MAX_SAFE_INTEGER`는 `Number`의 정적 속성이기 때문에, 직접 생성한 `Number` 객체의 속성이 아니라 `Number.MAX_SAFE_INTEGER` 형식으로 사용해야 합니다.

예제
--

```js
Number.MAX\_SAFE\_INTEGER; // 9007199254740991
Number.MAX\_SAFE\_INTEGER \* Number.EPSILON; // 2 because in floating points, the value is actually the decimal trailing "1"
// except for in subnormal precision cases such as zero
```

폴리필
---

```js
if (!Number.MAX\_SAFE\_INTEGER) {
  Number.MAX\_SAFE\_INTEGER = Math.pow(2, 53) - 1; // 9007199254740991
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.max\_safe\_integer |

브라우저 호환성
--------

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

같이 보기
-----

* `Number.MIN_SAFE_INTEGER`
* `Number.isSafeInteger()`
* `BigInt`


Number() 생성자 - JavaScript

Number() 생성자
============

**`Number()` 생성자**는 `Number` 객체를 생성합니다.

구문
--

```js
new Number(value);
```

### 매개변수

`value`

만들어질 객체의 숫자 값.

예제
--

### Number 객체 만들기

```js
const a = new Number("123"); // a === 123 은 거짓
const b = Number("123"); // b === 123 은 참
a instanceof Number; // 참
b instanceof Number; // 참
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number-constructor |

브라우저 호환성
--------

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

같이 보기
-----

* 최신 `Number` 동작(2진수와 8진수를 지원하는)의 폴리필은 `core-js`를 참고하세요
* `NaN`
* `Math` 전역 객체
* 임의 정밀도 정수: `BigInt`


Number.prototype.toFixed() - JavaScript

Number.prototype.toFixed()
==========================

**`toFixed()`** 메서드는 숫자를 고정 소수점 표기법(fixed-point notation)으로 표시합니다.

시도해보기
-----

구문
--

```js
numObj.toFixed([digits]);
```

### 매개변수

`digits` Optional

소수점 뒤에 나타날 자릿수. 0 이상 20 이하의 값을 사용할 수 있으며, 구현체에 따라 더 넓은 범위의 값을 지원할 수도 있습니다. 값을 지정하지 않으면 0을 사용합니다.

### 반환 값

고정 소수점 표기법을 사용하여 나타낸 수를 문자열로 바꾼 값.

### 예외

`RangeError`

`digits`가 너무 작거나 너무 클 때. 값이 0과 100사이의 값이라면 `RangeError`를 유발하지 않습니다. 구현체에 따라 더 크거나 작은 값을 지원할 수 있습니다.

`TypeError`

`Number`가 아닌 객체에서 호출한 경우.

설명
--

`toFixed()`는 `Number` 객체를 주어진 `digits` 만큼의 소수점 이하 자리수를 정확하게 갖는 문자열 표현으로 반환합니다. 소수점 이하가 길면 숫자를 반올림하고, 짧아서 부족할 경우 뒤를 0으로 채울 수 있습니다. 메서드를 호출한 숫자의 크기가 1e+21보다 크다면 `Number.prototype.toString()`을 호출하여 받은 지수 표기법 결과를 대신 반환합니다.

예제
--

### `toFixed()` 사용하기

```js
var numObj = 12345.6789;

numObj.toFixed(); // Returns '12346': 반올림하며, 소수 부분을 남기지 않습니다.
numObj.toFixed(1); // Returns '12345.7': 반올림합니다.
numObj.toFixed(6); // Returns '12345.678900': 빈 공간을 0으로 채웁니다.
(1.23e20).toFixed(2); // Returns '123000000000000000000.00'
(1.23e-10).toFixed(2); // Returns '0.00'
(2.34).toFixed(1); // Returns '2.3'
(2.35).toFixed(1); // Returns '2.4'. 이 경우에는 올림을 합니다.
-(2.34).toFixed(1); // Returns -2.3 (연산자의 적용이 우선이기 때문에, 음수의 경우 문자열로 반환하지 않습니다...)
(-2.34).toFixed(1); // Returns '-2.3' (...괄호를 사용할 경우 문자열을 반환합니다.)
```

명세
--

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

브라우저 호환성
--------

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

참조
--

* `Number.prototype.toExponential()`
* `Number.prototype.toPrecision()`
* `Number.prototype.toString()`


Number.prototype.valueOf() - JavaScript

Number.prototype.valueOf()
==========================

**`valueOf()`** 메서드는 `Number` 객체가 감싼(wrapped) 원시 값을 반환합니다.

시도해보기
-----

구문
--

```js
numObj.valueOf();
```

### 반환 값

`Number` 객체의 원시 값.

설명
--

`valueOf()` 메서드는 보통 JavaScript에 의해 내부적으로 호출되고, 웹 코드에서는 명시적으로 호출하지 않습니다.

예제
--

### `valueOf` 사용하기

```js
var numObj = new Number(10);
console.log(typeof numObj); // object

var num = numObj.valueOf();
console.log(num); // 10
console.log(typeof num); // number
```

명세
--

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

브라우저 호환성
--------

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

같이 보기
-----

* `Number.prototype.toSource()` (en-US)


Number.isSafeInteger() - JavaScript

Number.isSafeInteger()
======================

**`Number.isSafeInteger()`** 메서드는 전달된 값이 안전한 정숫값인지 확인합니다.

시도해보기
-----

안전한 정숫값이란 다음과 같습니다.

* IEEE-754 배정도수 형태로 정확히 표현될 수 있는 수이고
* IEEE-754 표현에 맞게 반올림하는 다른 정수의 결과가 아닌 IEEE-754 표현.

예를 들어, `2^53 - 1`은 안전한 정수입니다. 이 정수는 정확히 표현될 수 있으며, IEEE-754 반올림 모드에서 다른 정숫값이 이 값을 반올림하지 않습니다. 반면에, `2^53` 는 안전하지 않은 정수입니다. 이 정수는 정확히 IEEE-754로 표현될 수 있지만, 정수 `2^53 + 1`은 IEEE-754로 직접 표현될 수 없으며 가까운 수로 반올림하는 것과 0으로 반올림하는 것으로 `2^53`을 반올림합니다.

안전한 정숫값은 `-(2^53 - 1)` 부터 `2^53 - 1` 사이의 모든 정수값으로 구성됩니다.

구문
--

```js
Number.isSafeInteger(testValue);
```

### 매개변수

`testValue`

안전한 정수인지 확인할 값.

### 반환 값

주어진 값이 안전한 정숫값인지 나타내는 `Boolean`.

예시
--

```js
Number.isSafeInteger(3); // true
Number.isSafeInteger(Math.pow(2, 53)); // false
Number.isSafeInteger(Math.pow(2, 53) - 1); // true
Number.isSafeInteger(NaN); // false
Number.isSafeInteger(Infinity); // false
Number.isSafeInteger("3"); // false
Number.isSafeInteger(3.1); // false
Number.isSafeInteger(3.0); // true
```

폴리필
---

```js
Number.isSafeInteger =
  Number.isSafeInteger ||
  function (value) {
    return (
      Number.isInteger(value) && Math.abs(value) <= Number.MAX\_SAFE\_INTEGER
    );
  };
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.issafeinteger |

브라우저 호환성
--------

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

같이 보기
-----

* 메서드가 속한 `Number` 객체.
* `Number.MIN_SAFE_INTEGER`
* `Number.MAX_SAFE_INTEGER`


Number.MIN_VALUE - JavaScript

Number.MIN\_VALUE
=================

**`Number.MIN_VALUE`** 속성은 JavaScript가 표현할 수 있는 제일 작은 양의 숫자 값을 나타냅니다.

시도해보기
-----

| Property attributes of `Number.MIN_VALUE` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`MIN_VALUE` 속성은 JavaScript에서 표현할 수 있는, 0에 가장 가깝지만 음수는 아닌 수입니다.

`MIN_VALUE`의 값은 약 `5e-324`입니다. `MIN_VALUE`보다 작은 값("언더플로우 값")은 0으로 변환됩니다.

`MIN_VALUE`는 `Number`의 정적 속성이기 때문에, 직접 생성한 `Number` 객체의 속성이 아니라 `Number.MIN_VALUE` 형식으로 사용해야 합니다.

예제
--

### `MIN_VALUE` 사용하기

다음 코드는 숫자를 두 개의 수를 받아 나누기 연산을 합니다. 만약 결과가 `MIN_VALUE` 보다 크거나 같으면 `func1` 함수를 호출하고, 그렇지 않으면 `func2` 함수를 호출합니다.

```js
if (num1 / num2 >= Number.MIN\_VALUE) {
  func1();
} else {
  func2();
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.min\_value |

브라우저 호환성
--------

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

같이 보기
-----

* `Number.MAX_VALUE`


Number.isFinite() - JavaScript

Number.isFinite()
=================

**`Number.isFinite()`** 메서드는 주어진 값이 유한수인지 판별합니다.

시도해보기
-----

구문
--

```js
Number.isFinite(value);
```

### 매개변수

`value`

유한수인지 판별할 값.

### 반환 값

유한수 여부에 대한 `Boolean` 값.

설명
--

전역 함수 `isFinite()`와 비교했을 때, `Number.isFinite()` 메서드는 매개변수를 숫자로 변환하지 않습니다. 즉 값이 숫자이며 동시에 유한수일 때만 `true`를 반환합니다.

예제
--

```js
Number.isFinite(Infinity); // false
Number.isFinite(NaN); // false
Number.isFinite(-Infinity); // false

Number.isFinite(0); // true
Number.isFinite(2e64); // true

Number.isFinite("0"); // false
// 전역함수 isFinite('0')라면 true
Number.isFinite(null); // false
// 전역함수 isFinite(null)라면 true
```

폴리필
---

```js
if (Number.isFinite === undefined)
  Number.isFinite = function (value) {
    return typeof value === "number" && isFinite(value);
  };
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-number.isfinite |

브라우저 호환성
--------

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

같이 보기
-----

* 메서드가 속한 `Number` 객체.
* 전역 함수 `isFinite`.


Symbol.toPrimitive - JavaScript

Symbol.toPrimitive
==================

**`Symbol.toPrimitive`** 정적 데이터 속성은 잘 알려진 심볼 `@@toPrimitive`를 나타냅니다.
 모든 타입 강제 변환 알고리즘은 객체에서 이 심볼을 찾아서 선호하는 유형을 허용하고 객체의 원시 표현을 반환하는 메서드를 찾은 다음 객체의 `valueOf()` 및 `toString()` 메서드를 다시 사용합니다.

시도해보기
-----

값
-

잘 알려진 심볼 `@@toPrimitive`.

| Property attributes of `Symbol.toPrimitive` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

 함수 값으로 사용되는 `Symbol.toPrimitive` 속성의 도움으로 객체를 원시 값으로 변환할 수 있습니다.
 함수는 결과로 나온 원시 값의 선호 유형을 지정하는 문자열 인수 `hint`와 함께 호출됩니다. `hint` 인수는 `"number"` `"string"`, `"default"`중 하나일 수 있습니다.

`"number"` 힌트는 숫자 강제 알고리즘에서 사용됩니다. `"string"` 힌트는 문자열 강제 알고리즘에서 사용됩니다. `"default"` 힌트는 원시형 강제 알고리즘에서 사용됩니다. `hint`는 `Symbol.prototype[@@toPrimitive]()`와 같이 선호 사항정도로만 작용하며, 구현은 이를 무시할 수 있습니다. 언어에서는 `hint`와 결과 유형 간의 정렬을 강제하지 않지만, `[@@toPrimitive]()`는 원시형을 반환해야 하며, 그렇지 않으면 `TypeError`가 발생합니다.

`@@toPrimitive` 속성이 없는 객체는 `valueOf()` 및 `toString()` 메서드를 다른 순서로 호출하여 원시형으로 변환되며, 이에 대한 자세한 설명은 타입 강제 섹션에서 확인할 수 있습니다.
 `@@toPrimitive`를 사용하면 윈시형 변환 절차를 완전히 제어할 수 있습니다. 예를 들어, `Date.prototype[@@toPrimitive]`는 `"default"`를 `"string"`으로 취급하여 `valueOf()` 대신 `toString()`을 호출합니다.
 `Symbol.prototype[@@toPrimitive]`는 힌트를 무시하고 항상 심볼을 반환하므로 문자열 컨텍스트에서도 `Symbol.prototype.toString()`이 호출되지 않으며, `Symbol` 객체는 항상 `String()` (en-US)을 통해 명시적으로 문자열로 변환해야 합니다.

예제
--

### 객체에서 변환된 원시값 수정하기

다음 예제에서는 `Symbol.toPrimitive` 속성이 객체에서 변환된 원시값을 수정하는 방법을 설명합니다.

```js
// Symbol.toPrimitive 속성이 없는 객체.
const obj1 = {};
console.log(+obj1); // NaN
console.log(`${obj1}`); // "[object Object]"
console.log(obj1 + ""); // "[object Object]"

// Symbol.toPrimitive 속성이 있는 객체.
const obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint === "number") {
      return 10;
    }
    if (hint === "string") {
      return "hello";
    }
    return true;
  },
};
console.log(+obj2); // 10 — hint is "number"
console.log(`${obj2}`); // "hello" — hint is "string"
console.log(obj2 + ""); // "true" — hint is "default"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.toprimitive |

브라우저 호환성
--------

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

같이 보기
-----

* Polyfill of `Symbol.toPrimitive` in `core-js`
* `Date.prototype[@@toPrimitive]()`
* `Symbol.prototype[@@toPrimitive]()`
* `Object.prototype.toString()`
* `Object.prototype.valueOf()`


Symbol() 생성자 - JavaScript

Symbol() 생성자
============

**`Symbol()`** 함수는 타입 Symbol의 원시 값을 반환합니다.

시도해보기
-----

구문
--

```js
Symbol()
Symbol(description)
```

**참고:** `Symbol()`은 오직 `new`를 사용하지 않고 호출해야 합니다.
 `new`와 함께 생성하려하면 `TypeError`가 발생합니다.

### 매개변수

`description` Optional

문자열. 디버깅에는 사용할 수 있지만 심볼 자체에 접근하기 위해 사용할 수 없는, 심볼에 대한 설명입니다.

예제
--

### Symbol 생성하기

새로운 원시 심볼을 만들기 위해서는 아래와 같이 설명으로 사용할 선택적 문자열과 함께 `Symbol()`을 사용하면 됩니다.

```js
const sym1 = Symbol();
const sym2 = Symbol("foo");
const sym3 = Symbol("foo");
```

 위의 코드는 세 개의 새로운 심볼을 생성합니다. `Symbol("foo")`는 문자열 `"foo"`를 강제로 심볼로 만들지 않습니다.
 매번 새로운 심볼을 생성합니다.

```js
Symbol("foo") === Symbol("foo"); // false
```

### new Symbol()

`new` 연산자를 사용한 아래 구문은 `TypeError`를 발생시킵니다.

```js
const sym = new Symbol(); // TypeError
```

 이는 작성자가 새 심볼 값 대신 명시적인 `Symbol` 래퍼 개체를 만드는 것을 방지하며 원시 데이터 타입을 중심으로 명시적인 래퍼 개체를
 만드는 것이 일반적으로 가능하기 때문에 놀랄 수 있습니다(예: `new Boolean`, `new String` and `new Number`).

정말로 `Symbol` 래퍼 객체를 생성하려면 `Object()` 함수를 사용할 수 있습니다.

```js
const sym = Symbol("foo");
const symObj = Object(sym);
typeof sym; // "symbol"
typeof symObj; // "object"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol-constructor |

브라우저 호환성
--------

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

같이 보기
-----

* Polyfill of `Symbol` in `core-js`


Symbol.prototype.description - JavaScript

Symbol.prototype.description
============================

`Symbol` 값의 **`description`** 접근자 속성은 이 심볼에 대한 설명이 포함된 문자열을
 반환하거나 설명이 없는 경우 `undefined`를 반환합니다.

시도해보기
-----

설명
--

`Symbol` 객체는 디버깅에 사용할 수 있지만 심볼 자체에 접근하는 데는 사용할 수 없는 선택적인 설명과 함께 생성할 수 있습니다.
 `Symbol.prototype.description` 속성은 해당 설명을 읽는 데 사용할 수 있습니다. 이 속성은 둘러싸는
 `"Symbol()"` 문자열을 포함하지 않으므로 `Symbol.prototype.toString()`과 다릅니다. 예제를 참조하세요.

예제
--

### description 사용하기

```js
Symbol("desc").toString(); // "Symbol(desc)"
Symbol("desc").description; // "desc"
Symbol("").description; // ""
Symbol().description; // undefined

// well-known symbols
Symbol.iterator.toString(); // "Symbol(Symbol.iterator)"
Symbol.iterator.description; // "Symbol.iterator"

// global symbols
Symbol.for("foo").toString(); // "Symbol(foo)"
Symbol.for("foo").description; // "foo"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.description |

브라우저 호환성
--------

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

같이 보기
-----

* Polyfill of `Symbol.prototype.description` in `core-js`
* `Symbol.prototype.toString()`
* Polyfill: https://npmjs.com/symbol.prototype.description


Symbol.for() - JavaScript

Symbol.for()
============

**`Symbol.for(key)`** 메서드는 주어진 키를 사용해 런타임 범위의 심볼 레지스트리에서 존재하는 심볼을 찾고,
 존재할 경우 이를 반환합니다. 존재하지 않는 경우에는 해당 키를 사용해 전역 심볼 레지스트리에 새로운 심볼을 생성합니다.

시도해보기
-----

구문
--

```js
Symbol.for(key)
```

### 매개변수

`key`

문자열, 필수. 심볼에 대한 키(심볼을 설명하기 위해서도 사용됨).

### 반환 값

주어진 키를 갖는 존재하는 심볼. 존재하지 않을 경우 새로운 심볼이 생성되고 반환됨.

설명
--

`Symbol()`과 대조적으로, `Symbol.for()` 함수는 전역 심볼 레지스트리 목록에서 사용 가능한 심볼을 생성합니다.
 `Symbol.for()`는 호출할 때마다 새로운 심볼을 생성하지는 않으며 레지스트리에서 주어진 `key`를 갖는 심볼이
 이미 존재하는지를 먼저 확인합니다. 존재하는 경우 해당하는 심볼이 반환됩니다.
 주어진 키를 갖는 심볼이 존재하지 않는 경우, `Symbol.for()`는 새로운 전역 심볼을 생성합니다.

예제
--

### Symbol.for() 사용하기

```js
Symbol.for("foo"); // 새로운 전역 심볼을 생성
Symbol.for("foo"); // 이미 생성된 심볼을 반환

// 동일한 전역 심볼이지만 지역적으로는 그렇지 않음
Symbol.for("bar") === Symbol.for("bar"); // true
Symbol("bar") === Symbol("bar"); // false

// 키는 설명으로 사용되기도 함
var sym = Symbol.for("mario");
sym.toString(); // "Symbol(mario)"
```

전역 심볼 키와 다른 (라이브러리 코드) 전역 심볼의 이름 충돌을 피하려면, 심볼에 접두어를 붙이는 것이 좋습니다.

```js
Symbol.for("mdn.foo");
Symbol.for("mdn.bar");
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.for |

브라우저 호환성
--------

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

같이 보기
-----

* `Symbol.keyFor()`


Symbol.split - JavaScript

Symbol.split
============

**`Symbol.split`** 정적 데이터 속성은 잘 알려진 심볼 `@@split`을 나타냅니다. `String.prototype.split()` 메서드는 현재 객체와 일치하는 인덱스에서 문자열을 분할하는 메서드의 첫 번째 인수에서 이 심볼을 찾습니다.

보다 상세한 내용은 `RegExp.prototype[@@split]()` (en-US) 및 `String.prototype.split()`를 참조하시기 바랍니다.

시도해보기
-----

값
-

잘 알려진 심볼 `@@split`.

| Property attributes of `Symbol.split` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

예제
--

### 사용자 정의 역분할

```js
class ReverseSplit {
  [Symbol.split](string) {
    const array = string.split(" ");
    return array.reverse();
  }
}

console.log("Another one bites the dust".split(new ReverseSplit()));
// [ "dust", "the", "bites", "one", "Another" ]
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.split |

브라우저 호환성
--------

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

같이 보기
-----

* Polyfill of `Symbol.split` in `core-js`
* `Symbol.match` (en-US)
* `Symbol.matchAll` (en-US)
* `Symbol.replace` (en-US)
* `Symbol.search`
* `String.prototype.split()`
* `RegExp.prototype[@@split]()` (en-US)


Symbol.isConcatSpreadable - JavaScript

Symbol.isConcatSpreadable
=========================

**`Symbol.isConcatSpreadable`** 정적 데이터 속성은 잘 알려진 심볼 `@@isConcatSpreadable`을 나타냅니다.
 `Array.prototype.concat()` 메서드는 연결된 각 객체에서 이 심볼을 찾아 유사 배열과 객체로 취급하고
 해당 배열 요소로 평탄화해야 하는지 여부를 결정합니다.

시도해보기
-----

값
-

잘 알려진 심볼 `@@isConcatSpreadable`.

| Property attributes of `Symbol.isConcatSpreadable` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`@@isConcatSpreadable` 심볼(`Symbol.isConcatSpreadable`)은 자체 또는 상속된 속성으로
 정의할 수 있으며, 그 값은 불리언입니다. 아래와 같이 배열 및 배열 유사 객체에 대한 동작을 제어할 수 있습니다.

* 배열 객체의 경우 기본 동작은 요소를 펼치는(평평하게 하는) 것입니다.
 `Symbol.isConcatSpreadable`은 이러한 경우 평탄화를 피할 수 있습니다.
* 배열과 유사한 객체의 경우 기본 동작은 펼치거나 평평하게 하지 않는 것입니다.
 `Symbol.isConcatSpreadable`은 이러한 경우 평탄화를 강제할 수 있습니다.
예제
--

### 배열

기본적으로 `Array.prototype.concat()`는 여러 배열을 하나의 결과로 펼칩니다(평평하게 만듭니다).

```js
const alpha = ["a", "b", "c"];
const numeric = [1, 2, 3];

const alphaNumeric = alpha.concat(numeric);

console.log(alphaNumeric); // 결과: ['a', 'b', 'c', 1, 2, 3]
```

`Symbol.isConcatSpreadable`을 `false`로 설정하면 기본 동작을 비활성화할 수 있습니다.

```js
const alpha = ["a", "b", "c"];
const numeric = [1, 2, 3];

numeric[Symbol.isConcatSpreadable] = false;
const alphaNumeric = alpha.concat(numeric);

console.log(alphaNumeric); // Result: ['a', 'b', 'c', [1, 2, 3] ]
```

### 유사 배열 객체

 유사 배열 객체에서는 기본 동작이 평탄화시키지 않는 것입니다.
 배열을 평탄화시키고 싶다면 `Symbol.isConcatSpreadable`을 `true`로 설정할 필요가 있습니다.

```js
const x = [1, 2, 3];

const fakeArray = {
  [Symbol.isConcatSpreadable]: true,
  length: 2,
  0: "hello",
  1: "world",
};

x.concat(fakeArray); // [1, 2, 3, "hello", "world"]
```

**참고:** `length` 속성은 추가할 객체 속성의 수를 제어하는 데 사용됩니다.
 위의 예제에서 `length:2`는 2개의 속성이 추가되었다는 것을 가리킵니다.

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.isconcatspreadable |

브라우저 호환성
--------

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

같이 보기
-----

* Polyfill of `Symbol.isConcatSpreadable` in `core-js`
* `Array.prototype.concat()`


Symbol.iterator - JavaScript

Symbol.iterator
===============

잘 알려진 **`Symbol.iterator`** 심볼은 객체에 대응하는 기본 이터레이터를 지정합니다. `for...of`와 같이 사용됩니다.

시도해보기
-----

| Property attributes of `Symbol.iterator` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

(`for..of` 루프의 시작부분과 같이) 객체가 반환될 필요가 있을때는 언제든지`@@iterator` 메서드는 인수 없이도 호출 할 수 있습니다. 반환된 **iterator**는 반복할 값을 취득하기 위해 사용됩니다.

`Object`와 같이 반복동작을 내장하고 있는 형태도 있지만 그렇지 않은 경우도 있습니다. `@@iterator` 메서드를 가지고 있는 내장형 타입은 아래와 같습니다.

* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()`
* `String.prototype[@@iterator]()` (en-US)
* `Map.prototype[@@iterator]()`
* `Set.prototype[@@iterator]()`

상세한 내용은 반복처리 프로토콜도 확인 해 주시기 바랍니다.

예제
--

### 유저 정의 이터레이터

앞에서 기술한 바와 같이 독자적으로 이터레이터를 만드는 것이 가능합니다.

```js
var myIterable = {};
myIterable[Symbol.iterator] = function\* () {
  yield 1;
  yield 2;
  yield 3;
};
[...myIterable]; // [1, 2, 3]
```

### 비정형 이터레이터

iterable의 `@@iterator` 메서드가 이터레이터 객체를 반환하지 않는 경우 비정형 이터레이터입니다. 이와 같이 사용하는 경우 실행시 예외 혹은 예상치 못한 버그를 발생할 가능성이 있습니다.

```js
var nonWellFormedIterable = {}
nonWellFormedIterable[Symbol.iterator] = () => 1
[...nonWellFormedIterable] // TypeError: [] is not a function
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.iterator |

브라우저 호환성
--------

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

관련 정보
-----

* 반복처리 프로토콜
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype[@@iterator]()`
* `String.prototype[@@iterator]()` (en-US)
* `Map.prototype[@@iterator]()`
* `Set.prototype[@@iterator]()`


Symbol.keyFor() - JavaScript

Symbol.keyFor()
===============

**`Symbol.keyFor()`** 정적 메서드는 주어진 심볼에 해당하는 공유 심볼의 키를 전역 심볼 레지스트리에서 검색합니다.

시도해보기
-----

구문
--

```js
Symbol.keyFor(sym)
```

### 매개변수

`sym`

Symbol, 필수 값. 키를 찾기 위한 Symbol

### 반환 값

글로벌 레지스트리에 있는 경우
 지정된 심볼의 키를 나타내는 문자열이고, 그렇지 않으면 `undefined`입니다.

예제
--

### keyFor() 사용하기

```js
const globalSym = Symbol.for("foo"); // 새로운 전역 심볼 생성
Symbol.keyFor(globalSym); // "foo"

const localSym = Symbol();
Symbol.keyFor(localSym); // undefined

// 잘 알려진 심볼은 글로벌 심볼 레지스트리에 등록되지 않은 심볼입니다.
Symbol.keyFor(Symbol.iterator); // undefined
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.keyfor |

브라우저 호환성
--------

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

같이 보기
-----

* `Symbol.for()`


Symbol.prototype[@@toPrimitive] - JavaScript

Symbol.prototype[@@toPrimitive]
===============================

**`[@@toPrimitive]()`** 메서드는 Symbol 객체를 원시 값으로 변환합니다.

구문
--

```js
Symbol()[Symbol.toPrimitive](hint)
```

### 반환 값

명시된 `Symbol` 객체의 원시 값입니다.

설명
--

`Symbol`의 `[@@toPrimitive]()` 메서드는 Symbol 객체의 원시 값을
 Symbol 데이터 유형으로 반환합니다. `hint` 인자는 사용되지 않습니다.

 JavaScript는 객체를 원시 값으로 변환하기 위해 `[@@toPrimitive]()` 메서드를 호출합니다. 여러분은
 `[@@toPrimitive]()` 메서드를 직접 호출할 필요가 거의 없습니다. 원시 값이 예상되는 객체를 만나면 JavaScript가
 자동으로 호출합니다.

예제
--

### @@toPrimitive 사용하기

```js
const sym = Symbol("example");
sym === sym[Symbol.toPrimitive](); // true
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype-@@toprimitive |

브라우저 호환성
--------

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

같이 보기
-----

* `Symbol.toPrimitive`


Symbol.hasInstance - JavaScript

Symbol.hasInstance
==================

**`Symbol.hasInstance`** 정적 데이터 속성은 잘 알려진 심볼 `@@hasInstance`를 나타냅니다.
 `instanceof` 연산자는 생성자 객체가 객체를 인스턴스로 인식하는지 여부를 확인하기 위해
 사용하는 메서드의 오른쪽 피연산자에서 이 심볼을 찾습니다.

시도해보기
-----

값
-

잘 알려진 심볼 `@@hasInstance`.

| Property attributes of `Symbol.hasInstance` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`instanceof` 연산자는 다음 알고리즘을 사용하여 `object instanceof constructor`의 반환 값을 계산합니다.

1. `constructor`에 `@@hasInstance` 메서드가 있는 경우, 첫 번째 인수로 `object`를 사용하여 호출하고 불리언으로 강제 변환된 결과를 반환합니다.
 `constructor`가 객체가 아니거나 `constructor[@@hasInstance]`가 `null`, `undefined`, 함수 중 하나가 아닌 경우 `TypeError`가 발생합니다.
2. 그렇지 않으면, `constructor`에 `@@hasInstance` 메서드가 없는 경우(`constructor[@@hasInstance]`가 `null` 또는 `undefined`),
 `Function.prototype[@@hasInstance]` (en-US)와 동일한 알고리즘을 사용하여 결과를 결정합니다.
 `constructor`가 함수가 아닌 경우 `TypeError`가 발생합니다.

모든 함수는 기본적으로 `Function.prototype`을 상속하기 때문에, 대부분의 경우 `Function.prototype[@@hasInstance]` (en-US) 메서드는 오른쪽이 함수인 경우 `instanceof`의 동작을 지정합니다.

예제
--

### 사용자 지정 instanceof 동작

예를 들어 다음과 같이 사용자 정의 `instanceof` 동작을 구현할 수 있습니다.

```js
class MyArray {
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance);
  }
}
console.log([] instanceof MyArray); // true
```

```js
function MyArray() {}
Object.defineProperty(MyArray, Symbol.hasInstance, {
  value(instance) {
    return Array.isArray(instance);
  },
});
console.log([] instanceof MyArray); // true
```

### 객체의 인스턴스 검사하기

`instanceof` 키워드를 사용하여 객체가 클래스의 인스턴스 여부를 확인할 수 있는 것과 같은 방법으로
 `Symbol.hasInstance`를 사용하여 동일한 검사를 수행할 수 있습니다.

```js
class Animal {
  constructor() {}
}

const cat = new Animal();

console.log(Animal[Symbol.hasInstance](cat)); // true
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.hasinstance |

브라우저 호환성
--------

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

같이 보기
-----

* `instanceof`
* `Function.prototype[@@hasInstance]()` (en-US)


Symbol.search - JavaScript

Symbol.search
=============

 잘 알려진 심볼 **`Symbol.search`** 는 정규식과 일치하는 문자열 내의 인덱스를 반환하는 메서드를 명시합니다.
 이 함수는 `String.prototype.search()` (en-US) 메서드가 호출됩니다.

 자세한 내용은 `RegExp.prototype[@@search]()` (en-US) 및
 `String.prototype.search()` (en-US)을 참조하세요.

시도해보기
-----

값
-

잘 알려진 심볼 `@@search`.

| Property attributes of `Symbol.search` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

예제
--

### 고유의 문자열 검색

```js
class caseInsensitiveSearch {
  constructor(value) {
    this.value = value.toLowerCase();
  }
  [Symbol.search](string) {
    return string.toLowerCase().indexOf(this.value);
  }
}
console.log("foobar".search(new caseInsensitiveSearch("BaR"))); // 3
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.search |

브라우저 호환성
--------

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

같이 보기
-----

* Polyfill of `Symbol.search` in `core-js`
* `Symbol.match` (en-US)
* `Symbol.replace` (en-US)
* `Symbol.split`
* `RegExp.prototype[@@search]()` (en-US)


Symbol.prototype.toString() - JavaScript

Symbol.prototype.toString()
===========================

**`toString()`** 메서드는 지정된 심볼 값을 나타내는 문자열을 반환합니다.

시도해보기
-----

구문
--

```js
toString()
```

### 반환 값

지정된 심볼 값을 나타내는 문자열.

설명
--

`Symbol` 객체는 `Object`의 `toString` 메서드를 재정의하며,
 `Object.prototype.toString()`을 상속하지 않습니다.
 `Symbol` 값의 경우 `toString` 메서드는 `"Symbol(description)"` 형식의 설명 문자열을 반환하며,
 여기서 `description`은 심볼의 설명입니다.

`toString()` 메서드는 `this` 값이 `Symbol` 원시 값 또는 래퍼 객체여야 합니다. 이 외의 `this` 값에 대해서는 심볼 값으로 강제 변환하지 않고 `TypeError`를 던집니다.

`Symbol`에는 `[@@toPrimitive]()` 메서드가 있기 때문에 `Symbol` 객체를 문자열로 강제 변환할 때 이 메서드가 항상 `toString()`보다 우선합니다.
 그러나 `Symbol.prototype[@@toPrimitive]()`는 심볼 원시 값을 반환하고 심볼 원시 값은 문자열로 암시적으로 변환될 때 `TypeError`가 발생하기 때문에 언어에서 `toString()` 메서드는 절대 암시적으로 호출되지 않습니다.
 심볼을 문자열화하려면 해당 심볼의 `toString()` 메서드를 명시적으로 호출하거나 `String()` (en-US) 함수를 사용해야 합니다.

예제
--

### toString() 사용하기

```js
Symbol("desc").toString(); // "Symbol(desc)"

// 잘 알려진 심볼
Symbol.iterator.toString(); // "Symbol(Symbol.iterator)"

// 글로벌 심볼
Symbol.for("foo").toString(); // "Symbol(foo)"
```

### 암시적 toString() 호출

JavaScript가 심볼 래퍼 객체에서 `[@@toPrimitive]()` 대신 `toString()`을 암시적으로 호출하도록 하는 유일한 방법은 `@@toPrimitive` 메서드를 먼저 삭제 (en-US) 처리하는 방법 뿐 입니다.

>
> **주의:** 실제로 이 작업을 수행하지 마세요. 정확히 무엇을 하고 있는지 알지 못하면 기본 제공 객체를 변경하지 마세요.
>
>
>

```js
delete Symbol.prototype[Symbol.toPrimitive];
console.log(`${Object(Symbol("foo"))}`); // "Symbol(foo)"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-symbol.prototype.tostring |

브라우저 호환성
--------

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

같이 보기
-----

* `Object.prototype.toString()`


Int32Array() constructor - JavaScript

Int32Array() constructor
========================

**`Int32Array`** 형식화 배열(TypedArray) 생성자는 플랫폼의 바이트 순서를 따르는 2의 보수 32비트의 부호있는 정수
 배열을 생성합니다. 바이트 순서를 제어해야 하는 경우 대신 `DataView`를 사용합니다. 배열의 내용은 0으로
 초기화됩니다. 배열이 생성되면 객체의 메서드를 사용하거나 표준 배열 인덱스 구문(즉, 대괄호 표기법 사용)을 사용하여 배열의 요소를
 참조할 수있습니다.

구문
--

```js
new Int32Array()
new Int32Array(length)
new Int32Array(typedArray)
new Int32Array(object)

new Int32Array(buffer)
new Int32Array(buffer, byteOffset)
new Int32Array(buffer, byteOffset, length)
```

>
> **Note:** `Int32Array()`는 오직 `new`로만 생성할 수 있습니다. `new` 없이 호출을 시도하면 `TypeError` 예외가 발생합니다.
>
>
>

### 매개변수

`TypedArray`를 참고하세요.

### 예외

`TypedArray`를 참고하세요.

예제
--

### Int32Array을 생성하기 위한 각기 다른 여러 방법

```js
// 길이로부터 생성
const int32 = new Int32Array(2);
int32[0] = 42;
console.log(int32[0]); // 42
console.log(int32.length); // 2
console.log(int32.BYTES\_PER\_ELEMENT); // 4

// 배열로부터
const x = new Int32Array([21, 31]);
console.log(x[1]); // 31

// 다른 TypedArray로부터
const y = new Int32Array(x);
console.log(y[0]); // 21

// ArrayBuffer로부터
const buffer = new ArrayBuffer(32);
const z = new Int32Array(buffer, 4, 4);
console.log(z.byteOffset); // 4

// 순회로부터
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const int32FromIterable = new Int32Array(iterable);
console.log(int32FromIterable);
// Int32Array [1, 2, 3]
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray-constructors |

브라우저 호환성
--------

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

같이 보기
-----

* `core-js`에서 `Int32Array` 폴리필
* JavaScript 형식화 배열
* `ArrayBuffer`
* `DataView`


JSON.parse() - JavaScript

JSON.parse()
============

**`JSON.parse()`** 메서드는 JSON 문자열의 구문을 분석하고, 그 결과에서 JavaScript 값이나 객체를 생성합니다. 선택적으로, `reviver` 함수를 인수로 전달할 경우, 결과를 반환하기 전에 변형할 수 있습니다.

시도해보기
-----

구문
--

```js
    JSON.parse(text[, reviver])
```

### 매개변수

`text`

JSON으로 변환할 문자열. JSON 구문은 `JSON` 객체의 설명을 참고하세요.

`reviver` Optional

함수라면, 변환 결과를 반환하기 전에 이 인수에 전달해 변형함.

### 반환 값

주어진 JSON 문자열에 대응하는 `Object`.

### 예외

변환할 문자열이 유효한 JSON이 아닐 경우 `SyntaxError`.

예제
--

### `JSON.parse()` 사용하기

```js
JSON.parse("{}"); // {}
JSON.parse("true"); // true
JSON.parse('"foo"'); // "foo"
JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
JSON.parse("null"); // null
```

### `reviver` 매개변수 사용하기

`reviver`가 주어지면 분석한 값을 반환하기 전에 변환합니다. 구체적으로는, 분석한 값과 그 모든 속성(가장 깊게 중첩된 속성부터 시작해 제일 바깥의 원래 값까지)을 각각 `reviver`에 전달합니다. `reviver`의 `this` 문맥은 분석한 값으로 설정되고, 속성 명(문자열)과 값을 인자로 전달받습니다. `reviver`가 `undefined`를 반환하거나 반환하지 않는다면, 예컨대 함수가 중간에 실패한다면 그 속성은 최종 결과에서 제외됩니다. 그 외에는 반환 값으로 속성의 값을 재설정합니다.

만약 `reviver`가 일부 값만 변환하고 나머지는 건드리지 않는다면, 나머지 값을 그대로 반환하는걸 잊지 마세요. 그렇지 않으면 변환한 값 외에는 결과에서 모두 제외됩니다.

```js
JSON.parse(
  '{"p": 5}',
  (key, value) =>
    typeof value === "number"
      ? value \* 2 // 숫자라면 2배
      : value, // 나머진 그대로
);

// { p: 10 }

JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', (key, value) => {
  console.log(key); // 현재 속성명 출력, 마지막은 빈 문자열("")
  return value; // 변환하지 않고 그대로 반환
});

// 1
// 2
// 4
// 6
// 5
// 3
// ""
```

### 후행 쉼표 사용 불가

```js
// 둘 다 SyntaxError
JSON.parse("[1, 2, 3, 4, ]");
JSON.parse('{"foo" : 1, }');
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.parse |

브라우저 호환성
--------

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

같이 보기
-----

* `JSON.stringify()`


JSON.stringify() - JavaScript

JSON.stringify()
================

**`JSON.stringify()`** 메서드는 JavaScript 값이나 객체를 JSON 문자열로 변환합니다. 선택적으로, `replacer`를 함수로 전달할 경우 변환 전 값을 변형할 수 있고, 배열로 전달할 경우 지정한 속성만 결과에 포함합니다.

시도해보기
-----

구문
--

```js
    JSON.stringify(value[, replacer[, space]])
```

### 매개변수

`value`

JSON 문자열로 변환할 값.

`replacer` Optional

문자열화 동작 방식을 변경하는 함수, 혹은 JSON 문자열에 포함될 값 객체의 속성들을 선택하기 위한 화이트리스트(whitelist)로 쓰이는 `String` 과 `Number` 객체들의 배열. 이 값이 null 이거나 제공되지 않으면, 객체의 모든 속성들이 JSON 문자열 결과에 포함된다.

`space` Optional

가독성을 목적으로 JSON 문자열 출력에 공백을 삽입하는데 사용되는 `String` 또는 `Number` 객체. 이것이 `Number` 라면, 공백으로 사용되는 스페이스(space)의 수를 나타낸다; 이 수가 10 보다 크면 10 으로 제한된다. 1 보다 작은 값은 스페이스가 사용되지 않는 것을 나타낸다. 이것이 `String` 이라면, 그 문자열(만약 길이가 10 보다 길다면, 첫번째 10 개의 문자)이 공백으로 사용된다. 이 매개 변수가 제공되지 않는다면(또는 null 이면), 공백이 사용되지 않는다.

### 반환 값

주어진 값과 대응하는 JSON 문자열.

### 예외

순환 참조를 발견할 경우 `TypeError`(`cyclic object value`).

설명
--

`JSON.stringify()`는 값을 JSON 표기법으로 변환한다.

* 배열이 아닌 객체의 속성들은 어떤 특정한 순서에 따라 문자열화 될 것이라고 보장되지 않는다. 같은 객체의 문자열화에 있어서 속성의 순서에 의존하지 않는다.
* `Boolean`, `Number`, `String` 객체들은 문자열화 될 때 전통적인 변환 의미에 따라 연관된 기본형(primitive) 값으로 변환된다.
* `undefined`, 함수, 심볼(symbol)은 변환될 때 생략되거나(객체 안에 있을 경우) `null` 로 변환된다(배열 안에 있을 경우).
* 심볼을 키로 가지는 속성들은 `replacer` 함수를 사용하더라도 완전히 무시된다.
* 열거 불가능한 속성들은 무시된다.

```js
JSON.stringify({}); // '{}'
JSON.stringify(true); // 'true'
JSON.stringify("foo"); // '"foo"'
JSON.stringify([1, "false", false]); // '[1,"false",false]'
JSON.stringify({ x: 5 }); // '{"x":5}'

JSON.stringify(new Date(2006, 0, 2, 15, 4, 5));
// '"2006-01-02T15:04:05.000Z"'

JSON.stringify({ x: 5, y: 6 });
// '{"x":5,"y":6}' or '{"y":6,"x":5}'
JSON.stringify([new Number(1), new String("false"), new Boolean(false)]);
// '[1,"false",false]'

// Symbols:
JSON.stringify({ x: undefined, y: Object, z: Symbol("") });
// '{}'
JSON.stringify({ [Symbol("foo")]: "foo" });
// '{}'
JSON.stringify({ [Symbol.for("foo")]: "foo" }, [Symbol.for("foo")]);
// '{}'
JSON.stringify({ [Symbol.for("foo")]: "foo" }, function (k, v) {
  if (typeof k === "symbol") {
    return "a symbol";
  }
});
// '{}'

// Non-enumerable properties:
JSON.stringify(
  Object.create(null, {
    x: { value: "x", enumerable: false },
    y: { value: "y", enumerable: true },
  }),
);
// '{"y":"y"}'
```

### `replacer` 매개 변수

`replacer` 매개변수는 함수 또는 배열이 될 수 있다. 함수일 때는 문자열화 될 key 와 value, 2개의 매개변수를 받는다. key 가 발견된 객체는 리플레이서의 `this` 매개변수로 제공된다. 맨 처음에는 문자열화될 그 객체를 나타내는 비어 있는 key와 함께 호출되고, 그 다음에는 문자열화될 그 객체나 배열의 각 속성에 대해 호출된다. 이것은 JSON 문자열에 추가되어야 하는 값을 반환해야한다:

* `Number` 를 반환하면, JSON 문자열에 추가될 때 그 수를 나타내는 문자열이 그 속성의 값으로 사용된다.
* `String` 을 반환하면, 그것이 JSON 문자열에 추가될 때 속성의 값으로 사용된다.
* `Boolean` 을 반환하면, 그것이 JSON 문자열에 추가될 때 "true" 또는 "false" 이 속성의 값으로 사용된다.
* 다른 객체를 반환하면, 그 객체는 `replacer` 함수를 각각의 속성에 대해 호출하며 순환적으로 JSON 문자열로 문자열화된다. 그 객체가 함수인 경우에는 JSON 문자열에 아무것도 추가되지 않는다.
* `undefined` 를 반환하면, 그 속성은 JSON 문자열 결과에 포함되지 않는다.

**참고:** **유의:** `replacer` 함수를 배열로부터 값을 제거하기위해 사용할 수 없다. 만약 `undefined` 나 함수를 반환한다면 `null` 이 대신 사용될 것이다.

#### 함수에 대한 예제

```js
function replacer(key, value) {
  if (typeof value === "string") {
    return undefined;
  }
  return value;
}

var foo = {
  foundation: "Mozilla",
  model: "box",
  week: 45,
  transport: "car",
  month: 7,
};
var jsonString = JSON.stringify(foo, replacer);
```

JSON 문자열 결과는 `{"week":45,"month":7}` 이다.

#### 배열에 대한 예제

`replacer` 가 배열인 경우, 그 배열의 값은 JSON 문자열의 결과에 포함되는 속성의 이름을 나타낸다.

```js
JSON.stringify(foo, ["week", "month"]);
// '{"week":45,"month":7}', 단지 "week" 와 "month" 속성을 포함한다
```

### `space` 매개 변수

`space` 매개변수는 최종 문자열의 간격을 제어한다. 숫자일 경우 최대 10자 만큼의 공백 문자 크기로 들여쓰기되며, 문자열인 경우 해당 문자열 또는 처음 10자 만큼 들여쓰기 된다.

```js
JSON.stringify({ a: 2 }, null, " ");
// '{
// "a": 2
// }'
```

'\t'를 사용하면 일반적으로 들여쓰기 된 코드스타일과 유사함.

```js
JSON.stringify({ uno: 1, dos: 2 }, null, "\t");
// returns the string:
// '{
// "uno": 1,
// "dos": 2
// }'
```

### `toJSON()` 작동

If an object being stringified has a property named `toJSON` whose value is a function, then the `toJSON()` method customizes JSON stringification behavior: instead of the object being serialized, the value returned by the `toJSON()` method when called will be serialized. For example:

```js
var obj = {
  foo: "foo",
  toJSON: function () {
    return "bar";
  },
};
JSON.stringify(obj); // '"bar"'
JSON.stringify({ x: obj }); // '{"x":"bar"}'
```

### Example of using `JSON.stringify()` with `localStorage`

In a case where you want to store an object created by your user and allowing it to be restored even after the browser has been closed, the following example is a model for the applicability of `JSON.stringify()`:

**경고:** Functions are not a valid JSON data type so they will not work. However, they can be displayed if first converted to a string (e.g. in the replacer), via the function's toString method. Also, some objects like `Date` will be a string after `JSON.parse()`.

```js
// Creating an example of JSON
var session = {
  screens: [],
  state: true,
};
session.screens.push({ name: "screenA", width: 450, height: 250 });
session.screens.push({ name: "screenB", width: 650, height: 350 });
session.screens.push({ name: "screenC", width: 750, height: 120 });
session.screens.push({ name: "screenD", width: 250, height: 60 });
session.screens.push({ name: "screenE", width: 390, height: 120 });
session.screens.push({ name: "screenF", width: 1240, height: 650 });

// Converting the JSON string with JSON.stringify()
// then saving with localStorage in the name of session
localStorage.setItem("session", JSON.stringify(session));

// Example of how to transform the String generated through
// JSON.stringify() and saved in localStorage in JSON object again
var restoredSession = JSON.parse(localStorage.getItem("session"));

// Now restoredSession variable contains the object that was saved
// in localStorage
console.log(restoredSession);
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-json.stringify |

브라우저 호환성
--------

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

같이 보기
-----

* `JSON.parse()`


함수 선언 - JavaScript

함수 선언
=====

**함수 선언**(**function declaration**)은 지정된 매개변수(parameter)를 갖는 함수를 정의합니다.

`Function` 생성자나 `함수 표현식(function expression)`을 사용해서 정의할 수도 있습니다.

시도해보기
-----

구문
--

```js
    function name([param[, param,[..., param]]]) { [statements] }
```

`name`

함수 이름.

`param`

함수로 전달되는 인수(argument)의 이름. 인수의 최대 개수는 엔진마다 다름.

`statements`

함수의 몸통(body)을 구성하는 문(statement).

설명
--

함수 선언으로 생성된 함수는 `Function` 객체로, `Function` 객체의 모든 속성(property), 메서드 및 행위 특성(behavior)을 갖습니다. 함수에 관한 더 자세한 정보는 `Function` 참조하시기 바랍니다.

함수는 또한 표현식(`함수 표현식` 참조)을 사용하여 생성될 수 있습니다.

기본적으로 함수는 `undefined`를 반환합니다. 다른 값을 반환하기 위해서는, 함수는 반환값을 지정하는 `return` 문이 있어야 합니다.

### 조건부로 생성되는 함수

함수는 조건부로 선언될 수 있습니다. 즉, function 문은 `if` 문 안에 들어갈 수 있습니다. 하지만, 구현에 따라 결과에 일관성이 없으므로 이 패턴은 실제 코드에서는 사용해선 안됩니다. 조건부로 함수를 생성하고자 한다면, 함수 표현식(function expression)을 대신 사용하세요.

```js
var hoisted = "foo" in this;
console.log(
  `'foo' name ${
 hoisted ? "is" : "is not"
 } hoisted. typeof foo is ${typeof foo}`,
);
if (false) {
  function foo() {
    return 1;
  }
}

// In Chrome:
// 'foo' name is hoisted. typeof foo is undefined
//
// In Firefox:
// 'foo' name is hoisted. typeof foo is undefined
//
// In Edge:
// 'foo' name is not hoisted. typeof foo is undefined
//
// In Safari:
// 'foo' name is hoisted. typeof foo is function
```

결과는 참으로 평가되는 조건과 정확하게 일치합니다.

```js
var hoisted = "foo" in this;
console.log(
  `'foo' name ${
 hoisted ? "is" : "is not"
 } hoisted. typeof foo is ${typeof foo}`,
);
if (true) {
  function foo() {
    return 1;
  }
}

// In Chrome:
// 'foo' name is hoisted. typeof foo is undefined
//
// In Firefox:
// 'foo' name is hoisted. typeof foo is undefined
//
// In Edge:
// 'foo' name is not hoisted. typeof foo is undefined
//
// In Safari:
// 'foo' name is hoisted. typeof foo is function
```

### 함수 선언 끌어올리기

JavaScript에서 함수 선언은 그 선언을 둘러싼 함수의 최상부나 전역 범위(global scope)로 끌어올려집니다.

```js
hoisted(); // logs "foo"

function hoisted() {
  console.log("foo");
}
```

`함수 표현식`은 끌어올려지지 않으므로 주의하세요:

```js
notHoisted(); // TypeError: notHoisted is not a function

var notHoisted = function () {
  console.log("bar");
};
```

예제
--

### `function` 사용하기

다음 코드는 제품 `a`, `b` 및 `c`의 단위 판매량이 주어졌을 때, 총 판매량을 반환하는 함수를 선언합니다.

```js
function calc\_sales(units\_a, units\_b, units\_c) {
  return units_a \* 79 + units_b \* 129 + units_c \* 699;
}
```

명세서
---

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

브라우저 호환성
--------

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

같이 보기
-----

* `함수 및 함수 범위`
* `Function`
* `함수 표현식`
* `function* 문`
* `function* 식`
* `화살표 함수`
* `GeneratorFunction`


throw - JavaScript

throw
=====

**`throw`** 문은 사용자 정의 예외를 발생(throw)할 수 있습니다. 예외가 발생하면 현재 함수의 실행이 중지되고 (`throw` 이후의
 명령문은 실행되지 않습니다.), 제어 흐름은 콜스택의 첫 번째 `catch` (en-US)
 블록으로 전달됩니다. 호출자 함수 사이에 `catch` 블록이 없으면 프로그램이 종료됩니다.

시도해보기
-----

문법
--

```js
throw expression;
```

`expression`

예외를 발생시킬 표현식

설명
--

 예외를 발생하기 위해 `throw` 문을 사용하세요. 예외를 발생시키면 `expression`은 예외 값을 지정합니다.
 다음 각각은 예외를 발생시킵니다:

```js
throw "Error2"; // 문자열 값을 가지는 예외가 발생합니다.
throw 42; // 42 값을 가진 예외가 발생합니다.
throw true; // true 값을 가지는 예외가 발생합니다.
```

또한 `throw` 문은 자동 세미콜론 삽입 (en-US) (ASI)에 의해 영향을 받으며 `throw` 키워드와 표현식 사이에 줄 종결자는 허용되지 않으므로 주의해야합니다.

예제
--

### 예외 값으로 객체 사용하기

 예외를 발생시킬 때 객체를 명시할 수 있습니다. 그러면 `catch` 블록에서 객체의 속성을 참조 할 수 있습니다.
 다음 예제에서는 `UserException` 타입의 객체를 만들고 `throw` 구문에서 이 객체를 사용합니다.

```js
function UserException(message) {
  this.message = message;
  this.name = "UserException";
}
function getMonthName(mo) {
  mo = mo - 1; // 월 숫자를 배열의 인덱스 값과 맞추기 위해서 입니다.(1 = 1월, 12 = 12월)
  var months = [
    "Jan",
    "Feb",
    "Mar",
    "Apr",
    "May",
    "Jun",
    "Jul",
    "Aug",
    "Sep",
    "Oct",
    "Nov",
    "Dec",
  ];
  if (months[mo] !== undefined) {
    return months[mo];
  } else {
    throw new UserException("InvalidMonthNo");
  }
}

try {
  // try 문
  var myMonth = 15; // 15 는 범위를 벗어났기 때문에 예외를 발생시킵니다
  var monthName = getMonthName(myMonth);
} catch (e) {
  monthName = "unknown";
  console.error(e.message, e.name); // 오류 처리기에 예외 객체를 전달합니다
}
```

### 예외 값으로 객체 사용하는 다른 예제

 다음 예제는 입력 문자열에서 미국 우편 번호를 테스트합니다.
 우편 번호가 잘못된 형식을 사용하는 경우 throw 문은 `ZipCodeFormatException` 타입의 객체를 만들어 예외를 발생시킵니다.

```js
/\*
 \* ZipCode 객체를 만듭니다.
 \*
 \* 입력받을 수 있는 우편번호의 형태는 아래와 같습니다:
 \* 12345
 \* 12345-6789
 \* 123456789
 \* 12345 6789
 \*
 \* 만약 ZipCode 생성자로 전달된 매개변수가 이 패턴 중 하나도 맞지 않으면,
 \* 예외를 발생시킵니다.
 \*/

function ZipCode(zip) {
  zip = new String(zip);
  pattern = /[0-9]{5}([- ]?[0-9]{4})?/;
  if (pattern.test(zip)) {
    // 우편번호 값은 문자열의 첫 번째 매칭일 것입니다.
    this.value = zip.match(pattern)[0];
    this.valueOf = function () {
      return this.value;
    };
    this.toString = function () {
      return String(this.value);
    };
  } else {
    throw new ZipCodeFormatException(zip);
  }
}

function ZipCodeFormatException(value) {
  this.value = value;
  this.message = "does not conform to the expected format for a zip code";
  this.toString = function () {
    return this.value + this.message;
  };
}

/\*
 \* 이것은 미국 주소에 대한 주소 데이터를 검증하는 스크립트에서
 \* 발생할 수 있습니다.
 \*/

const ZIPCODE\_INVALID = -1;
const ZIPCODE\_UNKNOWN\_ERROR = -2;

function verifyZipCode(z) {
  try {
    z = new ZipCode(z);
  } catch (e) {
    if (e instanceof ZipCodeFormatException) {
      return ZIPCODE\_INVALID;
    } else {
      return ZIPCODE\_UNKNOWN\_ERROR;
    }
  }
  return z;
}

a = verifyZipCode(95060); // 95060 반환
b = verifyZipCode(9560); // -1 반환
c = verifyZipCode("a"); // -1 반환
d = verifyZipCode("95060"); // 95060 반환
e = verifyZipCode("95060 1234"); // 95060 1234 반환
```

### 예외 다시 발생시키기

`throw`를 사용하여 예외를 잡은(catch) 후에 예외를 다시 발생시킬 수 있습니다.
 다음 예제에서는 숫자 값으로 예외를 잡지만 값이 50 이상이면 예외를 다시 발생시킵니다.
 반환된 예외는 둘러싸는 함수 또는 최상위 수준으로 전파되어 사용자가 볼 수 있도록합니다

```js
try {
  throw n; // 숫자 값으로 예외를 발생시킵니다.
} catch (e) {
  if (e <= 50) {
    // 1-50 사이의 예외를 처리하는 구문
  } else {
    // 이 예외를 처리할 수 없어서, 다시 예외를 발생시킵니다
    throw e;
  }
}
```

명세
--

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

브라우저 호환성
--------

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

같이 보기
-----

* `try...catch` (en-US)
* `Error`


for...in - JavaScript

for...in
========

**`for...in` 문**은 상속된 열거 가능한 속성들을 포함하여 객체에서 문자열로 키가 지정된 모든 열거 가능한 속성에 대해 반복합니다. (Symbol로 키가 지정된 속성은 무시합니다.)

시도해보기
-----

문법
--

```js
for (const variable in object) {
  statement;
}
```

### 파라미터

`variable`

매번 반복마다 다른 속성이름(Value name)이 `변수(variable)`로 지정됩니다.

`object`

반복작업을 수행할 객체로 열거형 속성을 가지고 있는 객체.

설명
--

`for...in`문은 열거 가능한 non-Symbol 속성에 대해서만 반복합니다.

`Array`나 `Object` 등 내장 constructor를 통해 만들어진 객체는 `String`의 `indexOf()`, `Object`의 `toString()`와 같이 `Object.prototype`, `String.prototype` 로부터 열거가 가능하지 않은 속성들을 상속해왔습니다. `for...in`문은 객체 자체의 모든 열거 가능한 속성들과 프로토타입 체인으로부터 상속받은 속성들에 대해 반복할 것입니다. (더 가까운 프로토타입의 속성들이 프로토타입 체인 객체로부터 더 멀리 떨어진 프로토 타입의 속성보다 더 우선합니다.)

### 속성의 삭제, 추가, 수정

`for..in` 문은 임의의 순서로 객체의 속성들에 대해 반복합니다. (적어도 `cross-browser` 설정에서는 왜 표면적으로 보이는 반복의 순서를 따를 수 없는지에 대해서 `delete` (en-US) 를 참고하십시오.)

만약 한 반복으로 속성이 수정된 후에 방문하는 경우, 반복문에서의 그 값은 나중의 값으로 정해집니다. 방문하기 전에 삭제된 속성에 대해서는 이후에 방문하지 않습니다. 반복이 발생하는 객체에 추가된 속성은 방문하거나 반복에서 생략할 수 있습니다.

일반적으로 현재 방문 중인 속성 외에는 반복하는 동안 객체의 속성을 추가, 수정, 제거하지 않는 것이 가장 좋습니다. 추가된 속성을 방문할 것인지, 수정된 속성(현재의 속성 제외)을 수정 이전 혹은 이후에 방문할 것인지, 삭제된 속성을 삭제 이전에 방문할 것인지에 대해서는 보장할 수 없습니다.

### 배열의 반복과 for...in

>
> **Note:** `for...in`은 인덱스의 순서가 중요한 `Array`에서 반복을 위해 사용할 수 없습니다.
>
>
>

배열 인덱스는 정수로 된 열거 가능한 속성이며, 일반적인 객체의 속성들과 같습니다. `for...in`은 특정 순서에 따라 인덱스를 반환하는 것을 보장할 수 없습니다. `for...in`반복문은 정수가 아닌 이름을 가진 속성, 상속된 모든 열거 가능한 속성들을 반환합니다.

반복되는 순서는 구현에 따라 다르기 때문에, 배열의 반복이 일관된 순서로 요소를 방문하지 못할 수도 있습니다. 그러므로 방문의 순서가 중요한 배열의 반복시에는 숫자 인덱스를 사용할 수 있는 `for` 반복문을 사용하는 것이 좋습니다.(또는 `Array.prototype.forEach()`, `for...of`를 권장합니다.)

### 자체 속성만 반복

만약 당신이 객체의 프로토타입이 아닌 객체 자체에 연결된 속성만 고려한다면 `getOwnPropertyNames()`나 `hasOwnProperty()` (en-US)를 사용하십시오.(`propertyIsEnumerable()` 또한 가능합니다.) 또는 외부적인 코드 간섭이 없다면 체크 메서드로 내장 프로토타입을 확장할 수 있습니다.

왜 for...in을 사용합니까?
------------------

`for...in`이 객체의 반복을 위해 만들어졌지만, 배열의 반복을 위해서는 추천되지 않고, `Array.prototype.forEach()`, `for...of`가 이미 존재합니다. 그러면 for...in은 어떻게 사용하는 것이 좋을까요?

이것은 쉽게 객체의 속성을 확인(콘솔이나 다른 방법으로 출력)할 수 있기 때문에 실질적으로 디버깅을 위해 사용될 수 있습니다. 배열이 데이터의 저장에 있어서는 더 실용적이지만, 키-값 쌍이 선호되는 데이터의 경우(속성이 "key"의 역할을 함) 특정 값을 가진 키가 있는지 확인하려는 경우에 for...in을 사용할 수 있습니다.

예제
--

### for...in의 사용

아래의 예는 열거 가능한 non-Symbol속성들을 반복해서 속성의 이름과 그 값을 기록합니다.

```js
var obj = { a: 1, b: 2, c: 3 };

for (const prop in obj) {
  console.log(`obj.${prop} = ${obj[prop]}`);
}

// Output:
// "obj.a = 1"
// "obj.b = 2"
// "obj.c = 3"
```

### 자체 속성 반복

아래는 `hasOwnProperty()` (en-US) 를 사용하는 예를 보여주고 있습니다. 상속된 속성은 표시되지 않습니다.

```js
var triangle = { a: 1, b: 2, c: 3 };

function ColoredTriangle() {
  this.color = "red";
}

ColoredTriangle.prototype = triangle;

function show\_own\_props(obj, objName) {
  var result = "";

  for (var prop in obj) {
    if (obj.hasOwnProperty(prop)) {
      result += objName + "." + prop + " = " + obj[prop] + "\n";
    }
  }

  return result;
}

o = new ColoredTriangle();
alert(show\_own\_props(o, "o")); /\* alerts: o.color = red \*/
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-for-in-and-for-of-statements |

브라우저 호환성
--------

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

### Compatibility: Initializer expressions in strict mode

 Prior to Firefox 40, it was possible to use an initializer expression
 (`i=0`) in a `for...in` loop:

```js
const obj = { a: 1, b: 2, c: 3 };
for (var i = 0 in obj) {
  console.log(obj[i]);
}
// 1
// 2
// 3
```

This nonstandard behavior is now ignored in version 40 and later, and will present a `SyntaxError` ("for-in loop head declarations may not have initializers") error in strict mode (bug 748550 and bug 1164741).

 Other engines such as v8 (Chrome), Chakra (IE/Edge), and JSC (WebKit/Safari) are
 investigating whether to remove the nonstandard behavior as well.

See also
--------

* `for...of` – a similar statement that iterates
 over the property *values*
* `for`
* Iterators and Generator functions (usable with `for...of` syntax)
* Enumerability and ownership of properties (en-US)
* `Object.getOwnPropertyNames()`
* `Object.hasOwn()` (en-US)
* `Array.prototype.forEach()`