recursal/MDN huggingface dataset:
Array.prototype.toSpliced()
===========================

`Array`의 **`toSpliced()`** 메서드는 `splice()`에 대응되는 복사 메서드입니다. 이 메서드는 주어진 인덱스에서 일부 요소가 제거되거나 교체된 새로운 배열을 반환합니다.

구문
--


```js
toSpliced(start)
toSpliced(start, deleteCount)
toSpliced(start, deleteCount, item1)
toSpliced(start, deleteCount, item1, item2)
toSpliced(start, deleteCount, item1, item2, /\* …, \*/ itemN)
```

### 매개변수

`start`

배열은 0부터 시작하는 인덱스로 변경되며, 정수로 변환됩니다..

* 음수 인덱스는 배열의 끝에서부터 카운트됩니다. 만약 `start < 0` 인 경우, `start + array.length`가 적용됩니다.
* `start < -array.length`이거나 `start`가 생략된 경우, `0`이 적용됩니다.
* `start >= array.length`인 경우 요소는 삭제되지 않지만, 메서드는 요소를 추가하는 추가 함수처럼 작동합니다.

`deleteCount` Optional

`start`에서부터 제거할 배열의 요소의 개수를 나타내는 수입니다.

만약 `deleteCount`가 생략되거나, `deleteCount`가 `start` 인덱스 뒤의 요소의 개수보다 크거나 같으면 배열의 시작부터 끝까지 모든 요소가 삭제됩니다. 그러나 `itemN` 매개변수를 전달하려면 `Infinity`를 `deleteCount`로 전달하여 `start` 인덱스 뒤의 모든 요소를 삭제해야 합니다. 왜냐하면 `undefined`는 0으로 변환되기 때문입니다.

`deleteCount`가 `0`이거나 음수라면, 요소가 제거되지 않습니다. 이 경우 새 요소를 하나 이상 지정해야 합니다. (아래 참조).

`item1`, …, `itemN` Optional

`start` 부터 시작하여 배열에 추가할 요소입니다.

만약 명확한 요소를 지정하지 않으면, `toSpliced()`는 배열에서 요소만 제거합니다.

### 반환 값

`start` 전의 모든 요소, `item1`, `item2`, …, `itemN` 및 `start + deleteCount` 이후 모든 요소로 구성된 새로운 배열입니다.

설명
--

`splice()`와 비슷한 `toSpliced()`메서드는 여러 작업을 한 번에 수행합니다. 지정한 인덱스에서 시작하여 배열에서 지정한 수의 요소를 제거한 다음 동일한 인덱스에 지정된 요소를 삽입합니다. 그러나 원래 배열을 수정하는 대신 새로운 배열을 반환합니다. 따라서 삭제된 요소는 이 메서드에서 반환되지 않습니다.

`toSpliced()` 메서드는 절대 희소 배열을 생성하지 않습니다. 만약 배열이 비어있다면 빈 슬롯은 새로운 배열에서 `undefined`로 대체됩니다.

`toSpliced()`메서드는 제네릭입니다. `this`값에는 `length`속성과 정수 키 속성만 있을 것으로 예상합니다.

예시
--

### 요소의 삭제, 추가 및 교체하기

`toSpliced()`를 사용하면 배열의 요소를 삭제, 추가 및 교체할 수 있으며, `slice()` 나 `concat()`를 사용하는 것 보다 더 효율적으로 새 배열을 만들 수 있습니다.


```js
const months = ["Jan", "Mar", "Apr", "May"];

// 인덱스 1에 요소 추가
const months2 = months.toSpliced(1, 0, "Feb");
console.log(months2); // ["Jan", "Feb", "Mar", "Apr", "May"]

// 인덱스 2부터 2개의 요소 삭제
const months3 = months2.toSpliced(2, 2);
console.log(months3); // ["Jan", "Feb", "May"]

// 인덱스 1의 한 요소를 두 개의 새로운 요소로 교체
const months4 = months3.toSpliced(1, 1, "Feb", "Mar");
console.log(months4); // ["Jan", "Feb", "Mar", "May"]

// 원래 배열은 수정되지 않음
console.log(months); // ["Jan", "Mar", "Apr", "May"]
```

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

`toSpliced()`메서드는 항상 밀집 배열을 생성합니다.


```js
const arr = [1, , 3, 4, , 6];
console.log(arr.toSpliced(1, 2)); // [1, 4, undefined, 6]
```

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

`toSpliced()`메서드는 `this`속성의 `length`를 읽습니다. 그런 다음 필요한 정수 키 속성을 읽고 이를 새로운 배열에 작성합니다.


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  0: 5,
  2: 4,
};
console.log(Array.prototype.toSpliced.call(arrayLike, 0, 1, 2, 3));
// [2, 3, undefined, 4]
```

명세서
---

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

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

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

같이 보기
-----

* Polyfill of `Array.prototype.toSpliced` in `core-js`
* `Array.prototype.splice()`
* `Array.prototype.toReversed()`
* `Array.prototype.toSorted()`
* `Array.prototype.with()`
Array.prototype.unshift()
=========================

**`unshift()`** 메서드는 새로운 요소를 배열의 맨 앞쪽에 추가하고, 새로운 길이를 반환합니다.

시도해보기
-----

구문
--


```js
arr.unshift([...elementN]);
```

### 매개변수

`elementN`

배열 맨 앞에 추가할 요소.

### 반환 값

메서드를 호출한 배열의 새로운 `length` 속성.

설명
--

`unshift` 메서드는 배열 형태의 객체 시작점에 주어진 값을 삽입합니다.

`unshift`는 제네릭하도록 설계되었으며, 배열 형태를 가진 객체가 호출하거나 객체에 적용할 수 있습니다. `length` 속성을 가지지 않고, 대신 마지막 요소를 0부터 시작하는 순차적 인덱스로만 나타내는 객체에서는 의도한 것과 다르게 행동할 수 있습니다.

예제
--


```js
var arr = [1, 2];

arr.unshift(0); // result of call is 3, the new array length
// arr is [0, 1, 2]

arr.unshift(-2, -1); // = 5
// arr is [-2, -1, 0, 1, 2]

arr.unshift([-3]);
// arr is [[-3], -2, -1, 0, 1, 2]
```

명세
--

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

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

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

같이 보기
-----

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.concat()`
Array.prototype.indexOf()
=========================

`Array` 인스턴스의 **`indexOf()`** 메서드는 배열에서 주어진 요소를 찾을 수 있는 첫 번째 인덱스를 반환하고, 찾을 수 없는 경우 -1을 반환합니다.

시도해보기
-----

구문
--


```js
indexOf(searchElement)
indexOf(searchElement, fromIndex)
```

### 매개변수

`searchElement`

배열에서 위치를 찾을 요소입니다.

`fromIndex` Optional

검색을 시작할 0 기반 인덱스로, 정수로 변환됩니다.

* 음수 인덱스는 배열의 끝부터 거꾸로 셉니다. 즉, `fromIndex < 0`이면, `fromIndex + array.length`가 사용됩니다. 그러나, 이 경우에도 배열은 여전히 앞에서 뒤로 검색됩니다.
* `fromIndex < -array.length`이거나 `fromIndex`가 생략되면, `0`이 사용되어 전체 배열이 검색됩니다.
* `fromIndex >= array.length` 이면, 배열은 검색되지 않고 `-1`이 반환됩니다.

### 반환 값

배열에서 `searchElement`의 첫 번째 인덱스이고, 찾을 수 없으면 `-1`입니다.

설명
--

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

`indexOf()` 메서드는 희소 배열의 빈 슬롯을 건너뜁니다.

`indexOf()` 메서드는 범용입니다. `this` 값에는 `length` 속성과 정수 키 속성만 있을 것으로 예상합니다.

예제
--

### indexOf() 사용하기

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


```js
const array = [2, 9, 9];
array.indexOf(2); // 0
array.indexOf(7); // -1
array.indexOf(9, 2); // 2
array.indexOf(2, -1); // -1
array.indexOf(2, -3); // 0
```


`indexOf()`를 사용하여 `NaN`을 검색할 수 없습니다.


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

### 요소가 나타난 모든 위치 찾기


```js
const indices = [];
const array = ["a", "b", "a", "c", "a", "d"];
const element = "a";
let idx = array.indexOf(element);
while (idx !== -1) {
  indices.push(idx);
  idx = array.indexOf(element, idx + 1);
}
console.log(indices);
// [0, 2, 4]
```

### 배열에 요소가 있는지 확인하고 배열 업데이트하기


```js
function updateVegetablesCollection(veggies, veggie) {
  if (veggies.indexOf(veggie) === -1) {
    veggies.push(veggie);
    console.log(`새로운 veggies 컬력션은 ${veggies}`);
  } else {
    console.log(`${veggie}는 이미 veggies 컬렉션에 존재합니다.`);
  }
}

const veggies = ["potato", "tomato", "chillies", "green-pepper"];

updateVegetablesCollection(veggies, "spinach");
// 새로운 veggies 컬력션은 potato,tomato,chillies,green-pepper,spinach
updateVegetablesCollection(veggies, "spinach");
// spinach는 이미 veggies 컬렉션에 존재합니다.
```

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

`indexOf()`를 사용하여 희소 배열에서 빈 슬롯을 검색할 수 없습니다.


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

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

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


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

명세서
---

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

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

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

같이 보기
-----

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

**`toString()`** 메서드는 지정된 배열 및 그 요소를 나타내는 문자열을 반환합니다.

시도해보기
-----

구문
--


```js
arr.toString();
```

### 반환 값

배열을 표현하는 문자열을 반환합니다.

설명
--

`Array` 객체는 `Object`의 `toString` 메서드를 재정의(override)합니다. Array 객체에 대해, `toString` 메서드는 배열을 합쳐(join) 쉼표로 구분된 각 배열 요소를 포함하는 문자열 하나를 반환합니다. 예를 들어, 다음 코드는 배열을 생성하며 그 배열을 문자열로 변환하기 위해 `toString`을 사용합니다.


```js
var monthNames = ["Jan", "Feb", "Mar", "Apr"];
var myVar = monthNames.toString(); // 'Jan,Feb,Mar,Apr'을 myVar에 할당.
```


JavaScript는 배열이 텍스트 값으로 표현되거나 배열이 문자열 연결(concatenation)에 참조될 때 자동으로 `toString` 메서드를 호출합니다.

### ECMAScript 5 의미

JavaScript 1.8.5 (Firefox 4)부터, ECMAScript 제5판 의미(semantics)와 일치하는 `toString()` 메서드는 일반(generic) 메서드이므로 모든 객체에 사용될 수 있습니다. 객체가 `join()` 메서드가 있는 경우, 호출되어 그 값이 반환됩니다. 그렇지 않으면 `Object.prototype.toString()`가 호출되어 그 결과값이 반환됩니다.

명세
--

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

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

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

같이 보기
-----

* `Array.prototype.join()`
* `Object.prototype.toSource()` (en-US)
Array.prototype.splice()
========================

**`splice()`** 메서드는 배열의 기존 요소를 삭제 또는 교체하거나 새 요소를 추가하여 배열의 내용을 변경합니다.

시도해보기
-----

구문
--


```js
    array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
```

### 매개변수

`start`

 배열의 변경을 시작할 인덱스입니다. 배열의 길이보다 큰 값이라면 실제 시작 인덱스는 배열의 길이로 설정됩니다.
 음수인 경우 배열의 끝에서부터 요소를 세어나갑니다(원점 -1, 즉 -n이면 요소 끝의 n번째 요소를 가리키며 `array.length - n`번째 인덱스와 같음). 값의 절대값이 배열의 길이 보다 큰 경우 0으로 설정됩니다.


`deleteCount` Optional

 배열에서 제거할 요소의 수입니다.
 `deleteCount`를 생략하거나 값이 `array.length - start`보다 크면 `start`부터의 모든 요소를 제거합니다.
 `deleteCount`가 0 이하라면 어떤 요소도 제거하지 않습니다. 이 때는 최소한 하나의 새로운 요소를 지정해야 합니다.


`item1, item2, <em>...</em>` Optional

배열에 추가할 요소입니다. 아무 요소도 지정하지 않으면 `splice()`는 요소를 제거하기만 합니다.

### 반환 값

제거한 요소를 담은 배열. 하나의 요소만 제거한 경우 길이가 1인 배열을 반환합니다. 아무 값도 제거하지 않았으면 빈 배열을 반환합니다.

설명
--

만약 제거할 요소의 수와 추가할 요소의 수가 다른 경우 배열의 길이는 달라집니다.

예제
--

### 하나도 제거하지 않고, 2번 인덱스에 "drum" 추가


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2, 0, "drum");

// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]
// removed is [], no elements removed
```

### 하나도 제거하지 않고, 2번 인덱스에 "drum"과 "guitar" 추가


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2, 0, "drum", "guitar");

// myFish is ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]
// removed is [], no elements removed
```

### 3번 인덱스에서 한 개 요소 제거


```js
var myFish = ["angel", "clown", "drum", "mandarin", "sturgeon"];
var removed = myFish.splice(3, 1);

// removed is ["mandarin"]
// myFish is ["angel", "clown", "drum", "sturgeon"]
```

### 2번 인덱스에서 한 개 요소 제거하고 "trumpet" 추가


```js
var myFish = ["angel", "clown", "drum", "sturgeon"];
var removed = myFish.splice(2, 1, "trumpet");

// myFish is ["angel", "clown", "trumpet", "sturgeon"]
// removed is ["drum"]
```

### 0번 인덱스에서 두 개 요소 제거하고 "parrot", "anemone", "blue" 추가


```js
var myFish = ["angel", "clown", "trumpet", "sturgeon"];
var removed = myFish.splice(0, 2, "parrot", "anemone", "blue");

// myFish is ["parrot", "anemone", "blue", "trumpet", "sturgeon"]
// removed is ["angel", "clown"]
```

### 2번 인덱스에서 두 개 요소 제거


```js
var myFish = ["parrot", "anemone", "blue", "trumpet", "sturgeon"];
var removed = myFish.splice(myFish.length - 3, 2);

// myFish is ["parrot", "anemone", "sturgeon"]
// removed is ["blue", "trumpet"]
```

### -2번 인덱스에서 한 개 요소 제거


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(-2, 1);

// myFish is ["angel", "clown", "sturgeon"]
// removed is ["mandarin"]
```

### 2번 인덱스를 포함해서 이후의 모든 요소 제거


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2);

// myFish is ["angel", "clown"]
// removed is ["mandarin", "sturgeon"]
```

명세
--

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

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

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

같이 보기
-----

* `push()` / `pop()` — 배열 끝에 요소를 추가하거나 제거
* `unshift()` / `shift()` — 배열 처음에 요소를 추가하거나 제거
* `concat()` — 배열과 배열 또는 값을 합친 새로운 배열 반환
Array.prototype.values()
========================

**`values()`** 메서드는 배열에서 각 인덱스에 대한 값을 순회하는 *array iterator* 객체를 반환합니다.

시도해보기
-----

구문
--


```js
values()
```

반환 값
----

순회 가능한 새로운 반복자

설명
--

`Array.prototype.values()`는 `Array.prototype[@@iterator]()`의 기본 구현체입니다.


```js
Array.prototype.values === Array.prototype[Symbol.iterator]; // true
```


`values()` 메소드는 희소 배열에서도 유별나게 동작하지 않습니다. 빈 슬롯은 값이 `undefined`인 것처럼 방문합니다.

예제
--

### for...of 루프를 통한 반복

`values()`는 순회 가능한 반복자를 반환하므로, `for...of` 루프를 사용하여 순회할 수 있습니다.


```js
const arr = ["a", "b", "c", "d", "e"];
const iterator = arr.values();

for (const letter of iterator) {
  console.log(letter);
} // "a" "b" "c" "d" "e"
```

### next()를 사용한 순회

반환 값도 반복자이므로 `next()` 메서드를 직접 호출할 수 있습니다.


```js
const arr = ["a", "b", "c", "d", "e"];
const iterator = arr.values();
iterator.next(); // { value: "a", done: false }
iterator.next(); // { value: "b", done: false }
iterator.next(); // { value: "c", done: false }
iterator.next(); // { value: "d", done: false }
iterator.next(); // { value: "e", done: false }
iterator.next(); // { value: undefined, done: true }
console.log(iterator.next().value); // undefined
```

### 반복자 재사용하기

> 
> **Warning:** 배열 반복자 객체는 일회용 객체입니다. 재사용하지 마세요.
> 
> 
> 

`values()`에서 반환되는 반복자는 재사용할 수 없습니다. `next().done = true` 또는 `currentIndex > length`, the `for...of` loop ends 그리고 추가적인 순회는 아무 효과가 없습니다.


```js
const arr = ["a", "b", "c", "d", "e"];
const values = arr.values();
for (const letter of values) {
  console.log(letter);
}
// "a" "b" "c" "d" "e"
for (const letter of values) {
  console.log(letter);
}
// undefined
```


`break`문을 사용하여 순회를 조기에 종료하면, 나중에 순회를 다시 이어나가고자 할 때 현재 위치에서 반복자를 다시 사용할 수 있습니다.


```js
const arr = ["a", "b", "c", "d", "e"];
const values = arr.values();
for (const letter of values) {
  console.log(letter);
  if (letter === "b") {
    break;
  }
}
// "a" "b"

for (const letter of values) {
  console.log(letter);
}
// "c" "d" "e"
```

### 순환 중 가변

`values()`에서 반환되는 배열 반복자 객체에는 저장되어 있는 값이 없습니다. 대신 생성에 사용된 배열의 주소를 저장하고 각 순회에서 현재 방문 중인 인덱스를 읽습니다. 따라서 순회 시 출력은 순회할 때의 인덱스에 담겨있는 값에 따라 달라집니다. 배열의 값이 변경되면 배열 반복자 객체의 값도 변경됩니다.


```js
const arr = ["a", "b", "c", "d", "e"];
const iterator = arr.values();
console.log(iterator); // Array Iterator { }
console.log(iterator.next().value); // "a"
arr[1] = "n";
console.log(iterator.next().value); // "n"
```

### 희소 배열 순회하기

`values()`은 빈 슬롯을 마치 `undefined`인 것처럼 방문합니다.


```js
for (const element of [, "a"].values()) {
  console.log(element);
}
// undefined
// 'a'
```

명세
--

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

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

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

같이 보기
-----

* Polyfill of `Array.prototype.values` in `core-js`
* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* A polyfill
Array.prototype.findIndex()
===========================

**`findIndex()`** 메서드는 주어진 판별 함수를 만족하는 배열의 첫 번째 요소에 대한 인덱스를 반환합니다. 만족하는 요소가 없으면 -1을 반환합니다.

판별 함수를 만족하는 첫번째 인덱스 대신 값을 반환하는 `find()` 메서드도 참고하세요.

시도해보기
-----

구문
--


```js
findIndex(callbackFn)
findIndex(callbackFn, thisArg)
```

### 매개변수

`callbackFn`

배열의 각 요소마다 실행할 함수입니다. 일치하는 요소가 발견되었음을 나타내는 참인 값을 반환하고 그렇지 않으면 거짓인 값을 반환해야합니다. 함수는 다음과 같은 인수와 함께 호출됩니다.

`element`

배열에서 처리중인 현재 요소입니다.

`index`

배열에서 처리중인 현재 요소의 인덱스입니다.

`array`

`findIndex()` 함수가 호출된 배열입니다.


`thisArg` Optional

`callbackFn`을 실행할 때 `this`로 사용할 값입니다. 반복 메서드를 참조하세요.

### 반환 값

 테스트를 통과하는 첫 번째 요소의 인덱스입니다.
 일치하는 요소가 없으면 -1을 반환합니다.

설명
--

`findIndex()`는 반복 메서드입니다. `callbackFn` 함수를 배열의 각 요소에 대해 오름차순 인덱스 순서로 한 번씩 호출하고, `callbackFn`이 참인 값을 반환할 때까지 반복합니다. 그런 다음 `findIndex()`는 해당 요소의 인덱스를 반환하고 배열 반복을 중단합니다. `callbackFn`이 참인 값을 반환하지 않으면 `findIndex()`는 `-1`을 반환합니다.

`callbackFn`은 배열의 *모든* 인덱스에 대해 호출되며, 할당된 값만이 아닙니다. 희소 배열의 빈 슬롯은 `undefined`와 동일하게 동작합니다.

`findIndex()`는 호출된 배열을 변경하지 않지만, `callbackFn`으로 제공된 함수는 변경할 수 있습니다. 그러나 배열의 길이는 `callbackFn`의 첫 번째 호출 "전에" 저장됩니다. 따라서 다음과 같습니다.

* `callbackFn`은 `findIndex()` 호출이 시작된 배열의 초기 길이를 초과하여 추가된 요소를 방문하지 않습니다.
* 이미 방문한 인덱스에 대한 변경은 `callbackFn`이 다시 호출되지 않도록 합니다.
* `callbackFn`에 의해 배열의 아직 방문하지 않은 요소가 변경되었다면, `callbackFn`에 전달된 값은 해당 요소가 방문되는 시점의 값이 됩니다. 삭제된 (en-US) 요소는 `undefined`인 것처럼 방문됩니다.

**경고:** 위에서 설명한 종류의 동시 수정은 종종 이해하기 어려운 코드로 이어지며, 일반적으로 피해야 합니다(특별한 경우를 제외하고).

`findIndex()` 메서드는 일반적입니다. `length` 속성과 정수 키 속성을 가진 `this` 값을 기대합니다.

예제
--

### 배열에서 소수의 색인 찾기

다음 예제에서는 배열에서 소수인 첫번째 요소의 인덱스를 찾습니다. 소수가 없으면 -1을 반환합니다.


```js
function isPrime(element) {
  if (element % 2 === 0 || element < 2) {
    return false;
  }
  for (let factor = 3; factor <= Math.sqrt(element); factor += 2) {
    if (element % factor === 0) {
      return false;
    }
  }
  return true;
}

console.log([4, 6, 8, 9, 12].findIndex(isPrime)); // -1, not found
console.log([4, 6, 7, 9, 12].findIndex(isPrime)); // 2 (array[2] is 7)
```

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

희소 배열에서 `undefined`를 검색하고 빈 슬롯의 인덱스를 얻을 수 있습니다.


```js
console.log([1, , 3].findIndex((x) => x === undefined)); // 1
```

### findIndex()를 배열이 아닌 객체에 호출하기

`findIndex()`는 `this`의 `length` 속성을 읽은 다음 각 정수 인덱스에 액세스합니다.


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 7.3,
  2: 4,
};
console.log(
  Array.prototype.findIndex.call(arrayLike, (x) => !Number.isInteger(x)),
); // 1
```

명세서
---

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

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

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

같이 보기
-----

* Polyfill of `Array.prototype.findIndex` in `core-js`
* Indexed collections
* `Array`
* `Array.prototype.find()`
* `Array.prototype.findLast()`
* `Array.prototype.findLastIndex()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`
* `TypedArray.prototype.findIndex()` (en-US)
Array.prototype.copyWithin()
============================

`Array` 인스턴스의 **`copyWithin()`** 메서드는 배열의 일부를 같은 배열의 다른 위치로 얕게 복사하며, 배열의 길이를 수정하지 않고 해당 배열을 반환합니다.

시도해보기
-----

구문
--


```js
copyWithin(target, start)
copyWithin(target, start, end)
```

### 매개변수

`target`

시퀀스를 복사할 0 기반 인덱스로, 정수로 변환됩니다.

* 음수 인덱스는 배열의 끝부터 셉니다. `target < 0`이라면, `target + array.length`이 사용됩니다.
* `target < -array.length`이면, `0`이 사용됩니다.
* `target >= array.length`이면, 아무것도 복사되지 않습니다.
* 정수 변환 후 `target`이 `start` 보디 뒤에 위치하면, `array.length`의 끝부분까지만 복사가 수행됩니다(즉, `copyWithin()`은 배열을 확장하지 않습니다).

`start`

요소 복사를 시작할 0 기반 인덱스로, 정수로 변환됩니다.

* 음수 인덱스는 배열의 끝부터 셉니다. `target < 0`이라면, `target + array.length`이 사용됩니다.
* `target < -array.length`이면, `0`이 사용됩니다.
* `target >= array.length`이면, 아무것도 복사되지 않습니다.

`end` Optional

요소 복사를 끝낼 0 기반 인덱스로, 정수로 변환됩니다. `copyWithin()`은 `end`를 포함하지 않고 `end`전 까지 복사합니다.

* 음수 인덱스는 배열의 끝부터 셉니다. `target < 0`이라면, `target + array.length`이 사용됩니다.
* `target < -array.length`이면, `0`이 사용됩니다.
* `end >= array.length` 이거나 `end`가 생략되면, `array.length`가 사용됩니다. 이는 끝까지 모든 요소를 복사하는 것이 됩니다.
* 정수 변환 후 `end`가 `start`뒤에 위치하면, 아무것도 복사되지 않습니다.

### 반환 값

변경된 배열입니다.

설명
--

`copyWithin()` 메서드는 C와 C++의 `memmove`처럼 작동하며, `Array`의 데이터를 이동하는 고성능 메서드입니다. 이는 특히 같은 이름의 메서드를 가진 `TypedArray` (en-US)에서도 적용됩니다. 시퀀스는 하나의 작업으로 복사와 붙여넣기가 이루어집니다. 복사 붙여넣기 영역이 겹치더라도 붙여넣은 시퀀스는 복사된 값을 갖습니다.

`undefined`를 정수로 변환하면 `0`이 되므로, `start` 매개변수를 생략하면 `0`을 전달하여 전체 배열을 target 위치로 복사하는 것과 동일한 효과가 있습니다. 이는 오른쪽 경계가 잘리고 왼쪽 경계가 복제되는 오른쪽 시프트와 같습니다. 이 동작은 코드를 읽는 사람에게 혼란을 줄 수 있으므로 명시적으로 `0`을 `start`로 전달하는것이 좋습니다.


```js
console.log([1, 2, 3, 4, 5].copyWithin(2));
// [1, 2, 1, 2, 3]; 모든 요소를 오른쪽으로 2칸 이동합니다.
```


`copyWithin()` 메서드는 변경 메서드입니다. `this`의 길이를 변경하진 않지만, 필요한 경우 `this`의 내용을 변경하고, 새 속성을 만들거나 기존 속성을 삭제합니다.

`copyWithin()` 메서드는 빈 슬롯을 보존합니다. 복사할 영역이 희소인 경우, 빈 슬롯의 해당 새 인덱스에 있는 항목은 삭제 (en-US)되고 빈 슬롯이 됩니다.

`copyWithin()` 메서드는 범용입니다. 이 메서드는 `this` 값에 `length` 속성과 정수 키 속성만 있을 것으로 예상합니다. 문자열도 유사 배열이지만, 문자열은 불변이므로 이 메서드를 적용하기에는 적합하지 않습니다.

예제
--

### copyWithin() 사용하기


```js
console.log([1, 2, 3, 4, 5].copyWithin(0, 3));
// [4, 5, 3, 4, 5]

console.log([1, 2, 3, 4, 5].copyWithin(0, 3, 4));
// [4, 2, 3, 4, 5]

console.log([1, 2, 3, 4, 5].copyWithin(-2, -3, -1));
// [1, 2, 3, 3, 4]
```

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

`copyWithin()`은 빈 슬롯을 전파합니다.


```js
console.log([1, , 3].copyWithin(2, 1, 2)); // [1, empty, empty]
```

### copyWithin()을 배열이 아닌 객체에 적용하기

`copyWithin()` 메서드는 `this`의 `length` 속성을 읽은 다음 관련된 정수 인덱스를 변경합니다.


```js
const arrayLike = {
  length: 5,
  3: 1,
};
console.log(Array.prototype.copyWithin.call(arrayLike, 0, 3));
// { '0': 1, '3': 1, length: 5 }
console.log(Array.prototype.copyWithin.call(arrayLike, 3, 1));
// { '0': 1, length: 5 }
// 복사된 소스가 빈 슬롯이므로 '3' 속성이 삭제됩니다.
```

명세서
---

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

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

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

같이 보기
-----

* `core-js`의 `Array.prototype.copyWithin` 폴리필
* 인덱스된 컬렉션
* `Array`
* `TypedArray.prototype.copyWithin()` (en-US)
Array.prototype.toSorted()
==========================

`Array`의 **`toSorted()`** 메서드는 `sort()`에 대응되는 복사 메서드입니다. 이 메서드는 요소들을 오름차순으로 정렬한 새로운 배열을 반환합니다.

구문
--


```js
// 함수 없이 사용
toSorted()

// 화살표 함수
toSorted((a, b) => { /\* … \*/ })

// 비교 함수
toSorted(compareFn)

// 인라인 비교 함수
toSorted(function compareFn(a, b) { /\* … \*/ })
```

### 매개변수

`compareFn` Optional

정렬 순서를 정의하는 함수를 지정합니다. 생략하면 배열 요소는 문자열로 변환되고 각 문자의 유니코드 포인트 값에 따라 정렬됩니다.

`a`

비교할 첫 번째 요소입니다.

`b`

비교할 두 번째 요소입니다.


### 반환 값

요소들을 오름차순으로 정렬한 새로운 배열입니다.

설명
--

`compareFn` 매개변수에 대해 더 알아보려면 `sort()`를 참조하세요.

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

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

예제
--

### 배열 정렬하기


```js
const months = ["Mar", "Jan", "Feb", "Dec"];
const sortedMonths = months.toSorted();
console.log(sortedMonths); // ['Dec', 'Feb', 'Jan', 'Mar']
console.log(months); // ['Mar', 'Jan', 'Feb', 'Dec']

const values = [1, 10, 21, 2];
const sortedValues = values.toSorted((a, b) => a - b);
console.log(sortedValues); // [1, 2, 10, 21]
console.log(values); // [1, 10, 21, 2]
```


더 많은 사용 예제는 `sort()`를 참조하세요.

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

빈 슬롯은 `undefined` 값으로 간주되어 정렬됩니다. 빈 슬롯은 항상 배열의 끝으로 정렬되며 `compareFn`은 호출되지 않습니다.


```js
console.log(["a", "c", , "b"].toSorted()); // ['a', 'b', 'c', undefined]
console.log([, undefined, "a", "b"].toSorted()); // ["a", "b", undefined, undefined]
```

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

`toSorted()` 메서드는 `this`의 `length` 속성을 읽습니다. 그런 다음 `0`부터 `length - 1`까지의 범위에 있는 모든 정수 키 속성을 수집하여 정렬하고 새 배열에 씁니다.


```js
const arrayLike = {
  length: 3,
  unrelated: "foo",
  0: 5,
  2: 4,
};
console.log(Array.prototype.toSorted.call(arrayLike));
// [4, 5, undefined]
```

명세서
---

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

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

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

같이 보기
-----

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