recursal/MDN huggingface dataset:
TypedArray.prototype.forEach()
==============================

**`forEach()`** 메서드는 주어진 함수을 형식화 배열에 있는 각 요소에 대해 한 번씩 실행합니다.
 이 메서드는 `Array.prototype.forEach()`와 동일한 알고리즘으로 동작합니다.
 형식화 배열은 형식화 배열 타입 중 하나입니다.

시도해보기
-----

구문
--


```js
// Arrow function
forEach((element) => { /\* ... \*/ } )
forEach((element, index) => { /\* ... \*/ } )
forEach((element, index, array) => { /\* ... \*/ } )

// Callback function
forEach(callbackFn)
forEach(callbackFn, thisArg)

// Inline callback function
forEach(function(element) { /\* ... \*/ })
forEach(function(element, index) { /\* ... \*/ })
forEach(function(element, index, array){ /\* ... \*/ })
forEach(function(element, index, array) { /\* ... \*/ }, thisArg)
```

### 매개변수

`callbackFn`

각 요소에 대해 실행할 함수.

다음 세 가지 매개변수를 받습니다.

`element`

현재 처리할 현재 요소.

`index`

처리할 현재 요소의 인덱스.

`array`

`forEach()` 를 호출한 배열.


`thisArg` Optional

`callbackFn`을 실행할 때 `this`로 사용할 값.

### 반환 값

`undefined`.

설명
--

`forEach()`는 주어진 `callbackFn`을 형식화 배열에 있는 각 요소에 대해 한 번씩 실행합니다.
 삭제했거나 초기화하지 않은 인덱스에 대해서는 실행하지 않습니다. 그러나 `undefined`값을 가진, 존재하는
 요소에 대해서는 실행합니다.

`callbackFn`은 다음 **세 인수**와 함께 호출됩니다.

* **요소 값**
* **요소 인덱스**
* **순회 중인 배열**

`thisArg` 매개변수를 `forEach()`에 제공한 경우 `callbackFn`을 호출할 때 전달해 `this`의 값으로 쓰입니다. 전달하지 않으면 `undefined`를 `this` 값으로 사용합니다. `callbackFn`이 최종적으로 관찰할 수 있는 `this` 값은 함수의 `this`를 결정하는 일반적인 규칙에 따라 결정됩니다.

`forEach()`로 처리할 요소의 범위는 최초 `callbackFn` 호출 전에 설정됩니다. `forEach()` 호출을 시작한 뒤
 배열에 추가한 요소는 `callbackFn`이 방문하지 않습니다. 형식화 배열의 기존 요소값이 바뀐 경우,
 `callbackFn`에 전달하는 값은 `forEach()`가 요소를 방문한 시점의 값을 사용합니다.
 방문하기 전에 삭제한 요소는 방문하지 않습니다.

`forEach()`는 각 형식화 배열 요소에 대해 한 번씩 `callbackFn` 함수를 실행합니다.
 `every()`과
 `some()`와는
 달리 `undefined`를 반환합니다.

예제
--

### 형식화 배열의 컨텐츠 기록하기

아래 코드는 형식화 배열의 각 요소당 한 줄의 로그를 남깁니다.


```js
function logArrayElements(element, index, array) {
  console.log(`a[${index}] = ${element}`);
}

new Uint8Array([0, 1, 2, 3]).forEach(logArrayElements);
// Logs:
// a[0] = 0
// a[1] = 1
// a[2] = 2
// a[3] = 3
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.foreach |

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

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

같이 보기
-----

* Polyfill of `TypedArray.prototype.forEach` in `core-js`
* `TypedArray.prototype.map()` (en-US)
* `TypedArray.prototype.every()`
* `TypedArray.prototype.some()`
* `Array.prototype.forEach()`
TypedArray.prototype.byteLength
===============================

**`byteLength`** 접근자 속성은 형식화 배열의 길이(바이트)를 나타냅니다.

시도해보기
-----

설명
--

`byteLength` 속성은 접근자 설정 함수가 `undefined`인 접근자 속성으로 이 속성은 읽을 수만 있습니다. 값은 *TypedArray*가 생성될 때 설정되며 변경할 수 없습니다. *TypedArray*가 `byteOffset` 또는 `length`를 지정하지 않으면 참조된 `ArrayBuffer`의 `length`가 반환됩니다. *TypedArray*는 TypedArray 객체 중 하나입니다.

예제
--

### byteLength 속성 사용하기


```js
const buffer = new ArrayBuffer(8);

const uint8 = new Uint8Array(buffer);
uint8.byteLength; // 8 (buffer의 byteLength와 일치)

const uint8newLength = new Uint8Array(buffer, 1, 5);
uint8newLength.byteLength; // 5 (Uint8Array를 만들 때 지정된 대로)

const uint8offSet = new Uint8Array(buffer, 2);
uint8offSet.byteLength; // 6 (생성된 Uint8Array의 오프셋으로 인해)
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.bytelength |

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

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

같이 보기
-----

* JavaScript 형식화 배열
* `TypedArray`
TypedArray.prototype.indexOf()
==============================

**`indexOf()`** 메소드는 형식화 배열(typed array)에서 주어진 값과 일치하는 첫 번째 인덱스를 반환한다. 일치하는 값이 없으면 -1을 반환한다. 이 메소드는 `Array.prototype.indexOf()` 와 동일한 알고리즘을 가지고 있다\*.\* *TypedArray*는 TypedArray 객체 유형 중 하나이다.

시도해보기
-----

구문
--


```js
typedarray.indexOf(searchElement[, fromIndex = 0])
```

### 매개변수

`searchElement`

배열에서 검색할 요소.

`fromIndex`

문자열에서 찾기 시작하는 위치를 나타내는 인덱스 값. 만약 인덱스 번호가 배열의 길이와 동일하거나 더 크다면, 해당 요소를 찾을 수 없기 때문에 결과값으로 -1이 반환된다. 만약 인덱스 번호가 음수라면, 배열의 끝에서부터 하나씩 상쇄하며 계산한다. (예. fromIndex로 -1을 준 경우 가장 마지막 배열 요소의 값부터 검색을 시작. -2를 준 경우, 가장 마지막 배열 요소에서 하나 앞 요소부터 검색을 시작). 주의: 주어진 인덱스가 음수인 경우에도 배열은 여전히 앞에서부터 뒤로(왼쪽에서 오른쪽 순서로) 검색 된다. 만약 결과값으로 나온 인덱스가 0보다 작다면, 배열 전체가 찾아진 것이다. 디폴트 값 : 0 (전체 배열이 검색된다).

### 반환 결과

해당 배열에서 찾으려는 요소가 위치한 첫 번째 인덱스 값. 만약 찾으려는 요소가 없을 경우에는 -1을 반환.

설명
--

`indexOf` 메소드는 배열의 요소를 `searchElement` 와 비교할 때, strict equality (en-US)(===, *트리플 equals*) 를 사용하여 자료형의 일치 여부까지 비교한다.

예시
--


```js
var uint8 = new Uint8Array([2, 5, 9]);
uint8.indexOf(2); // 0
uint8.indexOf(7); // -1
uint8.indexOf(9, 2); // 2
uint8.indexOf(2, -1); // -1
uint8.indexOf(2, -3); // 0
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.indexof |

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

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

참고
--

* `TypedArray.prototype.lastIndexOf()` (en-US)
* `Array.prototype.indexOf()`
TypedArray.prototype.length
===========================

**`length`** 접근자(accessor) 속성(property)은 형식화 배열의 (요소) 길이를 나타냅니다.

설명
--

`length` 속성은 set 접근자 함수가 `undefined`인 접근자 속성입니다, 이 속성을 읽을 수만 있음을 뜻하는. 값은 *TypedArray*가 만들어질 때 수립되어 변경될 수 없습니다. *TypedArray*가 `byteOffset` 또는 `length`를 지정하지 않은 경우, 참조되는 `ArrayBuffer`의 길이가 반환됩니다. *TypedArray*는 TypedArray 객체 유형 중 하나입니다.

예제
--

### `length` 속성 사용


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

var uint8 = new Uint8Array(buffer);
uint8.length; // 8 (버퍼의 길이와 일치)

var uint8 = new Uint8Array(buffer, 1, 5);
uint8.length; // 5 (Uint8Array를 만들 때 지정된 대로)

var uint8 = new Uint8Array(buffer, 2);
uint8.length; // 6 (만든 Uint8Array의 오프셋으로 인해)
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.length |

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

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

같이 보기
-----

* JavaScript 형식화 배열
* `TypedArray`
TypedArray.prototype.keys()
===========================

**`keys()`** 메서드는 배열의 각 인덱스의 키를 포함하는 새로운 배열 반복자 객체를 반환합니다.

시도해보기
-----

구문
--


```js
keys()
```

### 반환 값

새로운 배열 반복자 객체.

예제
--

### for...of 루프를 사용한 반복


```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const arrKeys = arr.keys();
for (const n of arrKeys) {
  console.log(n);
}
```

### 다른 반복 방법


```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const arrKeys = arr.keys();
console.log(arrKeys.next().value); // 0
console.log(arrKeys.next().value); // 1
console.log(arrKeys.next().value); // 2
console.log(arrKeys.next().value); // 3
console.log(arrKeys.next().value); // 4
```

명새서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype.keys |

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

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

같이 보기
-----

* Polyfill of `TypedArray.prototype.keys` in `core-js`
* JavaScript typed arrays
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`
* for...of
* Iteration protocols
TypedArray.of()
===============

`***TypedArray*.of()**`

는 가변적으로 인수를 전달 할수 있는 새로운 형식화 배열(typed array)를 만들어내는 메소드입니다.

이 메소드는 `Array.of()`와 거의 같습니다.

문법
--
```

TypedArray.of(element0[, element1[, ...[, elementN]]])
```


where TypedArray is one of:

* Int8Array
* Uint8Array
* Uint8ClampedArray
* Int16Array
* Uint16Array
* Int32Array
* Uint32Array
* Float32Array
* Float64Array
### 매개변수

`elementN`

형식화 된 배열을 만들 요소입니다.

### 반환 값

생성된 `TypedArray` 인스턴스

설명
--

`Array.of()`와 `TypedArray.of()` 사이의 약간의 차이점은 다음과 같습니다.

* `TypedArray.of`에 전달된 값이 생성자가 아닌 경우 `TypedArray.of`는 `TypeError`를 발생시킵니다. `Array.of`는 기본적으로 새로운 `Array`를 생성합니다.
* `TypedArray.of` uses `[[Put]]` where `Array.of` uses `[[DefineProperty]]`. Hence, when working with `Proxy` objects, it calls `handler.set` (en-US) to create new elements rather than `handler.defineProperty` (en-US).
* `TypedArray.of`는 `Array.of`가 `[[DefineProperty]]`를 사용하는 것처럼 `[[Put]]`을 사용합니다. 따라서 `Proxy` 객체로 작업 할 때 새로운 요소를 생성하기 위해 `handler.set` (en-US)대신 `handler.defineProperty` (en-US)를 호출합니다.
예제
--


```js
Uint8Array.of(1); // Uint8Array [ 1 ]
Int8Array.of("1", "2", "3"); // Int8Array [ 1, 2, 3 ]
Float32Array.of(1, 2, 3); // Float32Array [ 1, 2, 3 ]
Int16Array.of(undefined); // IntArray [ 0 ]
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.of |

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

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

See also
--------

* `TypedArray.from()` (en-US)
* `Array.of()`
Generator.prototype.return()
============================

제너레이터의 **`return()`** 메서드는 현재 중단된 위치에서 제너레이터 본체에 리턴 문이 삽입 된 것처럼 작동합니다. 이는 `try...finally` (en-US) 블록을 사용하여 제너레이터를 정리 할 수 있도록 합니다.

구문
--


```js
generatorObject.return(value);
```

매개변수
----

`value`

반환할 값입니다.

반환 값
----

두 개의 속성을 가진 `객체`이고, 이 속성은 다음과 같습니다.

`done`

불리언 값입니다.

* 제너레이터 함수의 제어 흐름이 끝에 도달한 경우 `true`입니다.
* 제너레이터 함수의 제어 흐름이 끝에 도달하지 않고 더 많은 값을 생성할 수 있는 경우 `false`입니다. 이는 `return`이 `try...finally` (en-US)에서 실행되었고 `finally` 블록에는 더 많은 `yield` 식이 있을때만 발생할 수 있습니다.

`value`

인수로 지정된 값이며, 만약 `yield` 식이 `try...finally` (en-US)로 감싸진 경우, 이 값은 `finally` 블록에서 yield 되거나 반환된 값입니다.

설명
--

`return()` 메서드는 현재 중단된 위치의 제너레이터 본체에 삽입된 `return value;`처럼 보일 수 있습니다. 여기서 `value`는 `return()` 메서드에 전달된 값입니다. 따라서 일반적인 흐름에서 `return(value)`를 호출하면 `{ done: true, value: value }`가 반환됩니다. 그러나 `yield` 식이 `try...finally` 블록으로 감싸진 경우, 제어 흐름은 함수를 종료 하지 않고 `finally` 블록이 실행되도록 합니다. 이 경우 반환되는 값은 다를 수 있으며 `finally` 블록 내에 더 많은 `yield`식이 있다면 `done`도 `false`일 수 있습니다.

예제
--

### return() 사용하기

다음 예제에서는 간단한 제너레이터와 `return` 메서드 사용을 보여줍니다.


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen();

g.next(); // { value: 1, done: false }
g.return("foo"); // { value: "foo", done: true }
g.next(); // { value: undefined, done: true }
```


제너레이터가 이미 "완료" 상태 일때 `return(value)`가 호출되면 제너레이터는 "완료" 상태를 유지합니다.

인수를 지정하지 않으면 반환된 객체의 `value` 속성은 `undefined`가 됩니다. 인수가 제공되면 `yield` 식이 `try...finally`로 감싸지지 않는 한 반환된 객체의 `value` 속성은 해당 값이 됩니다.


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen();
g.next(); // { value: 1, done: false }
g.next(); // { value: 2, done: false }
g.next(); // { value: 3, done: false }
g.next(); // { value: undefined, done: true }
g.return(); // { value: undefined, done: true }
g.return(1); // { value: 1, done: true }
```

### try...finally와 함께 return() 사용하기

`yield` 식이 `try...finally` 블록으로 감싸진 경우에만 `return` 메소드가 호출되었다는 사실을 제너레이터에게 알릴 수 있습니다.

`try...finally` 문에서 `finally` 블록은 항상 실행되기 때문에 `try` 블록 안 일시 중단된 제너레이터에서 `return` 메서드가 호출되면 제너레이터의 실행이 `finally` 블록으로 진행됩니다.


```js
function\* gen() {
  yield 1;
  try {
    yield 2;
    yield 3;
  } finally {
    yield "cleanup";
  }
}

const g1 = gen();
g1.next(); // { value: 1, done: false }

// try...finally 전에 실행이 일시 중단됩니다.
g1.return("early return"); // { value: 'early return', done: true }

const g2 = gen();
g2.next(); // { value: 1, done: false }
g2.next(); // { value: 2, done: false }

// try...finally 내에서 실행이 일시 중단됩니다.
g2.return("early return"); // { value: 'cleanup', done: false }

// 완료 값은 유지됩니다.
g2.next(); // { value: 'early return', done: true }

// 제너레이터가 완료된 상태입니다.
g2.return("not so early return"); // { value: 'not so early return', done: true }
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.return |

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

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

같이 보기
-----

* `function*`
Generator.prototype.throw()
===========================

제너레이터의 **`throw()`** 메서드는 현재 중단 된 위치에서 제너레이터에 `throw` 문이 삽입되는 것처럼 작동하여 제너레이터의 오류 조건을 알려주고 오류를 처리하거나 정리 작업을 수행하며 제너레이터를 종료할 수 있도록 합니다.

구문
--


```js
generatorObject.throw(exception);
```

매개변수
----

`exception`

발생시킬 예외입니다. 디버깅을 위해 `Error` 인스턴스(`instanceof` `Error`)로 만드는 것이 유용합니다.

반환 값
----

예외가 `try...catch` (en-US)에서 발생하고 제너레이터가 재개하여 더 많은 값을 yield하면 다음 두 가지 속성을 가진 객체를 반환합니다.

`done`

불리언 값입니다.

* 제너레이터가 제어 흐름의 끝에 도달한 경우 `true`입니다.
* 제너레이터가 더 많은 값을 생성 할 수 있다면 `false`입니다.

`value`

다음 yield 식에서 산출된 값입니다.

### 예외

예외가 `try...catch`에서 발생하지 않으면 `throw()`로 전달 된 `exception`은 제너레이터에서 취급하지 않습니다.

설명
--

`throw()` 메소드는 호출 될 때, 이는 현재 중단 된 위치의 제너레이터에 삽입된 `throw exception;` 문 처럼 보일 수 있습니다. `exception`은 `throw()` 메서드에 전달 된 예외입니다. 따라서 일반적인 흐름에서 `throw(exception)`을 호출하면 제너레이터가 throw됩니다. 그러나 yield 식이 `try...catch` 블록으로 감싸졌 다면, 오류를 포착할 수 있으며 제어 흐름은 오류 처리 후 재개하거나 정상적으로 종료 하도록 진행됩니다.

예제
--

### throw() 사용하기

다음 예제에서는 간단한 제너레이터와 `throw` 메서드를 사용하여 오류를 발생시키는 것을 보여 줍니다. 오류는 보통 `try...catch` (en-US) 블록으로 처리합니다.


```js
function\* gen() {
  while (true) {
    try {
      yield 42;
    } catch (e) {
      console.log("Error caught!");
    }
  }
}

const g = gen();
g.next();
// { value: 42, done: false }
g.throw(new Error("Something went wrong"));
// "Error caught!"
// { value: 42, done: false }
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.throw |

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

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

같이 보기
-----

* `function*`
Generator.prototype.next()
==========================

**`next()`** 메서드는 `done`과 `value` 속성을 가지는 객체를 반환 합니다. `next` 메서드에 매개변수를 제공하여 값을 제너레이터로 보낼 수도 있습니다.

구문
--


```js
generatorObject.next(value);
```

### 매개변수

`value`

제너레이터로 보낼 값입니다.

값은 `yield` 식의 결과로 할당됩니다. 예를 들어 `variable = yield 식`에서 `.next()` 함수에 전달된 값은 `variable`에 할당됩니다.

### 반환 값

두 개의 속성을 가진 `객체`이고, 이 속성은 다음과 같습니다.

`done` (boolean)

반복자가 반복 시퀀스의 끝을 지난 경우 `true`입니다. 이 경우 `value`는 선택적으로 반복자의 *반환 값*을 지정합니다.

반복자가 시퀀스에서 다음 값을 생성할 수 있는 경우 `false`입니다. 이는 `done` 속성을 완전히 지정하지 않는 것과 같습니다.

`value`

제너레이터가 생성하거나 반환한 모든 JavaScript 값입니다.

예제
--

### next() 사용하기

다음 예제에서는 간단한 제너레이터와 `next` 메서드가 반환하는 객체를 보여 줍니다.


```js
function\* gen() {
  yield 1;
  yield 2;
  yield 3;
}

const g = gen(); // "Generator { }"
g.next(); // "Object { value: 1, done: false }"
g.next(); // "Object { value: 2, done: false }"
g.next(); // "Object { value: 3, done: false }"
g.next(); // "Object { value: undefined, done: true }"
```

### 리스트와 함께 next() 사용하기

이 예제에서 `getPage`는 리스트를 받아 `pageSize` 크기의 청크로 "페이지 나누기"를 수행합니다. `next`를 호출할 때마다 그러한 청크가 하나 생성됩니다.


```js
function\* getPage(pageSize = 1, list) {
  let output = [];
  let index = 0;

  while (index < list.length) {
    output = [];
    for (let i = index; i < index + pageSize; i++) {
      if (list[i]) {
        output.push(list[i]);
      }
    }

    yield output;
    index += pageSize;
  }
}

list = [1, 2, 3, 4, 5, 6, 7, 8];
let page = getPage(3, list); // Generator { }

page.next(); // Object {value: (3) [1, 2, 3], done: false}
page.next(); // Object {value: (3) [4, 5, 6], done: false}
page.next(); // Object {value: (2) [7, 8], done: false}
page.next(); // Object {value: undefined, done: true}
```

### 제너레이터에 값 보내기

이 예제에서는 값과 함께 `next`를 호출합니다.

**참고:** 제너레이터가 처음에는 아무것도 생성하지 않았기 때문에 첫 번째 호출에서 기록되는 것은 없습니다.


```js
function\* gen() {
  while (true) {
    let value = yield null;
    console.log(value);
  }
}

const g = gen();
g.next(1);
// "{ value: null, done: false }"
g.next(2);
// 2
// "{ value: null, done: false }"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generator.prototype.next |

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

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

같이 보기
-----

* `function*`
* 반복자와 제너레이터
ReferenceError() 생성자
====================

**`ReferenceError`** 객체는 존재하지 않는 변수를 참조할 때의 에러를 의미합니다.

구문
--


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


> 
> **Note:** `ReferenceError()` 는 `new`와 같이 호출될 때도 있고 아닐 때도 있습니다. 두 방법 모두 새로운 `ReferenceError` 인스턴스를 생성합니다.
> 
> 
> 

### 매개변수

`message` Optional

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

`options` Optional

아래 속성을 가진 객체

`cause` Optional

오류의 특정 원인을 나타내는 속성을 가리킵니다. 보다 구체적이거나 유용한 오류 메시지와 함께 오류를 처리했다가 다시 발생했을 때 이 속성을 사용하여 원래 오류를 전달할 수 있습니다.


`fileName` Optional 
비표준

이 예외의 원인이 된 코드가 있는 파일 이름

`lineNumber` Optional 
비표준

이 예외의 원인이 코드의 줄 수

예제
--

### ReferenceError 처리하기


```js
try {
  let a = undefinedVariable;
} catch (e) {
  console.log(e instanceof ReferenceError); // true
  console.log(e.message); // "undefinedVariable is not defined"
  console.log(e.name); // "ReferenceError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 6
  console.log(e.stack); // "@Scratchpad/2:2:7\n"
}
```

### ReferenceError 생성하기


```js
try {
  throw new ReferenceError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof ReferenceError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "ReferenceError"
  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`
Array.prototype.lastIndexOf()
=============================

`Array` 인스턴스의 `lastIndexOf()` 메서드는 배열에서 특정 요소를 찾을 수 있는 마지막 인덱스를 반환하거나, 해당 요소가 없으면 `-1`을 반환합니다. 배열은 `fromIndex`에서 시작하여 역방향으로 검색됩니다.

시도해보기
-----

구문
--


```js
lastIndexOf(searchElement)
lastIndexOf(searchElement, fromIndex)
```

### 매개변수

`searchElement`

배열에서 찾을 요소.

`fromIndex` Optional

역방향 검색을 시작하는 0부터 시작하는 인덱스로, 정수로 변환됩니다.

* 음수 인덱스는 배열 끝에서부터 다시 계산됩니다. 만약 `fromIndex < 0` 이라면, `fromIndex + array.length`가 사용됩니다.
* `fromIndex < -array.length`인 경우, 배열을 검색하지 않고 `-1`을 반환합니다. 개념적으로 배열이 시작되기 전 존재하지 않는 위치에서 시작해 그곳에서부터 거꾸로 가는 것이라고 생각하면 됩니다. 도중에 배열 요소가 없으므로 `searchElement`를 찾을 수 없습니다.
* `fromIndex >= array.length` 또는 `fromIndex`를 생략하면, `array.length - 1`이 사용되어 전체 배열을 검색하게 됩니다. 개념적으로 배열 끝 너머 존재하지 않는 위치에서 시작하고 그곳에서부터 거꾸로 가는 것이라고 생각하면 됩니다. 결국 배열의 실제 끝 위치에 도달하고, 이 지점에서 실제 배열 요소를 통해 역순 검색을 시작합니다.

### 반환 값

배열에 있는 `searchElement`의 마지막 인덱스입니다. 찾을 수 없으면 `-1`입니다.

설명
--

`lastIndexOf()` 메서드는 엄격한 동등성 (en-US)(`===` 연산자에서 사용하는 것과 동일한 알고리즘)을 사용하여 `searchElement`를 배열 요소와 비교합니다. 두 개의 `NaN` 값은 동일한 것으로 비교되지 않으므로 `searchElement`가 `NaN`인 경우, `lastIndexOf()`는 항상 `-1`을 반환합니다.

예제
--

### lastIndexOf() 사용하기

다음 예제에서는 `lastIndexOf()`를 사용하여 배열에서 값을 찾습니다.


```js
const numbers = [2, 5, 9, 2];
numbers.lastIndexOf(2); // 3
numbers.lastIndexOf(7); // -1
numbers.lastIndexOf(2, 3); // 3
numbers.lastIndexOf(2, 2); // 0
numbers.lastIndexOf(2, -2); // 0
numbers.lastIndexOf(2, -1); // 3
```


`NaN`을 찾기위해 `lastIndexOf()`을 사용할 수 없습니다.


```js
const array = [NaN];
array.lastIndexOf(NaN); // -1
```

### 요소의 모든 위치 찾기

다음 예제에서는 `lastIndexOf`를 사용하여 주어진 배열에 있는 요소의 모든 인덱스를 찾고, 발견된 요소를 다른 배열에 추가하기 위해 `push()`를 사용합니다.


```js
const indices = [];
const array = ["a", "b", "a", "c", "a", "d"];
const element = "a";
let idx = array.lastIndexOf(element);
while (idx !== -1) {
  indices.push(idx);
  idx = idx > 0 ? array.lastIndexOf(element, idx - 1) : -1;
}

console.log(indices);
// [4, 2, 0]
```


여기서는 `idx === 0`인 경우를 별도로 처리해야 합니다. 요소가 배열의 첫 번째 요소인 경우 `fromIndex` 매개변수에 관계없이 항상 검색되기 때문입니다. 이는 `indexOf()` 메서드와 다릅니다.

### 희소 배열에 lastIndexOf() 사용하기

배열의 빈 슬롯을 검색하기 위해 `lastIndexOf()`를 사용할 수 없습니다.


```js
console.log([1, , 3].lastIndexOf(undefined)); // -1
```

### 배열이 아닌 객체에 lastIndexOf() 사용하기

`lastIndexOf()` 메서드는 `this`의 `length` 속성을 읽은 다음 키가 `length`보다 작은 음이 아닌 정수인 각 속성에 접근합니다.


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 2,
  3: 5, // length가 3 이므로 lastIndexOf()에서 무시됩니다.
};
console.log(Array.prototype.lastIndexOf.call(arrayLike, 2));
// 2
console.log(Array.prototype.lastIndexOf.call(arrayLike, 5));
// -1
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.lastindexof |

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

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

같이 보기
-----

* `core-js`의 `Array.prototype.lastIndexOf` 폴리필
* 인덱스 기반 컬렉션 안내서
* `Array`
* `Array.prototype.findIndex()`
* `Array.prototype.findLastIndex()`
* `Array.prototype.indexOf()`
* `TypedArray.prototype.lastIndexOf()` (en-US)
* `String.prototype.lastIndexOf()`
Array() 생성자
===========

**`Array()`** 생성자는 새로운 `Array` 객체를 생성할 때 사용합니다.

구문
--


```js
new Array()
new Array(element0)
new Array(element0, element1)
new Array(element0, element1, /\* …, \*/ elementN)
new Array(arrayLength)

Array()
Array(element0)
Array(element0, element1)
Array(element0, element1, /\* …, \*/ elementN)
Array(arrayLength)
```


**참고:** `Array()`는 `new`를 붙이거나 붙이지 않고 호출할 수 있습니다. 둘 다 새 `Array` 인스턴스를 생성합니다.

### 매개변수

`elementN`

JavaScript 배열은 주어진 요소로 초기화되지만, 단일 인수가 `Array` 생성자에 전달되고, 그 인수가 숫자인 경우는 예외입니다(아래 `arrayLength` 매개변수 참조). 이 특수한 경우는 대괄호 구문으로 만들어진 배열 리터럴이 아닌 `Array` 생성자로 만들어진 JavaScript 배열에만 적용된다는 점에 유의하세요.

`arrayLength`

`Array` 생성자에 전달된 유일한 인수가 0에서 232 - 1(포함) 사이의 정수인 경우, `length` 속성이 해당 숫자로 설정된 새 JavaScript 배열을 반환합니다(**참고:** 이는 실제 `undefined` 값을 가진 슬롯이 아닌 `arrayLength` 길이의 빈 슬롯 배열을 의미합니다. 희소 배열참조).

### 예외

`RangeError`

숫자인 인자(`arrayLength`)가 하나뿐이지만, 그 값이 정수가 아니거나 0에서 232 - 1 (포함) 사이가 아닌 경우 발생합니다.

예제
--

### 배열 리터럴 표기법

배열은 리터럴 표기법 (en-US)으로 생성할 수도 있습니다.


```js
const fruits = ["사과", "바나나"];

console.log(fruits.length); // 2
console.log(fruits[0]); // "사과"
```

### 단일 매개변수 배열 생성자

 단일 숫자 매개변수가 있는 생성자를 사용하여 배열을 만들 수 있습니다.
 배열은 `length` 속성이 해당 숫자로 설정되어 생성되며, 배열 요소는 빈 슬롯입니다.


```js
const arrayEmpty = new Array(2);

console.log(arrayEmpty.length); // 2
console.log(arrayEmpty[0]); // undefined이지만, 사실 빈 슬롯입니다.
console.log(0 in arrayEmpty); // false
console.log(1 in arrayEmpty); // false
```



```js
const arrayOfOne = new Array("2"); // 숫자 2가 아니라 문자열 "2"

console.log(arrayOfOne.length); // 1
console.log(arrayOfOne[0]); // "2"
```

### 복수 매개변수 배열 생성자

생성자에 두 개 이상의 매개변수를 제공한 경우, 매개변수를 원소로 하는 새로운 `Array`를 생성합니다.


```js
const fruits = new Array("사과", "바나나");

console.log(fruits.length); // 2
console.log(fruits[0]); // "사과"
```

명세서
---

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

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

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

같이 보기
-----

* 인덱스된 컬렉션
* `Array`
Array.prototype.toReversed()
============================

`Array` 인스턴스의 **`toReversed()`** 메서드는 `reverse()`에 대응되는 복사 메서드입니다. 이 메서드는 요소들을 반대로 뒤집은 새로운 배열을 반환합니다.

구문
--


```js
toReversed()
```

### 반환 값

역순으로 정렬된 새로운 배열을 반환합니다.

설명
--

`toReversed()` 메서드는 호출한 배열 객체의 요소를 반대로 변경하고 새로운 배열을 반환합니다.

희소 배열에서 사용할 때, `toReversed()` 메서드는 빈 슬롯을 `undefined` 값으로 간주하고 반복합니다.

`toReversed()` 메서드는 일반화되어 있습니다. `this` 값이 `length` 속성과 정수로 키가 지정된 속성을 가지고 있다고 기대합니다.

예제
--

### 배열의 요소를 반대로 뒤집기

다음 예제는 세 개의 요소를 가진 `items` 배열을 생성하고, 이를 반대로 뒤집은 새로운 배열을 생성합니다. `items` 배열은 변경되지 않습니다.


```js
const items = [1, 2, 3];
console.log(items); // [1, 2, 3]

const reversedItems = items.toReversed();
console.log(reversedItems); // [3, 2, 1]
console.log(items); // [1, 2, 3]
```

### 희소 배열에서 toReversed() 사용하기

`toReversed()`의 반환 값은 절대 희소 배열이 아닙니다. 빈 슬롯은 반환된 배열에서 `undefined`가 됩니다.


```js
console.log([1, , 3].toReversed()); // [3, undefined, 1]
console.log([1, , 3, 4].toReversed()); // [4, 3, undefined, 1]
```

### 배열이 아닌 객체에서 toReversed() 호출하기

`toReversed()` 메서드는 `this`의 `length` 속성을 읽습니다. 그런 다음 `length - 1`과 `0` 사이의 각 인덱스를 내림차순으로 방문하고, 원래 배열의 해당 인덱스의 값을 새 배열의 해당 인덱스에 추가합니다.


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  2: 4,
};
console.log(Array.prototype.toReversed.call(arrayLike));
// [4, undefined, undefined]
// '0'번과 '1'번 인덱스가 없기 때문에 undefined가 됩니다.
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.toreversed |

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

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

같이 보기
-----

* Polyfill of `Array.prototype.toReversed` in `core-js`
* `Array.prototype.reverse()`
* `Array.prototype.toSorted()`
* `Array.prototype.toSpliced()`
* `Array.prototype.with()`
* `TypedArray.prototype.toReversed()` (en-US)