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

Baseline 2022
-------------

Newly availableSince March 2022, this feature works across the latest devices and browser versions. This feature might not work in older devices or browsers.

* Learn more
* See full compatibility
* Report feedback
`Array` 인스턴스의 **`at()`** 메서드는 정숫값을 받아 해당 인덱스에 있는 항목을 반환하며, 양수와 음수를 사용할 수 있습니다. 음의 정수는 배열의 마지막 항목부터 거슬러 셉니다.

시도해보기
-----

구문
--


```js
at(index)
```

### 매개변수

`index`

반환할 배열 요소의 0부터 시작하는 인덱스로, 정수로 변환됩니다. 음수 인덱스는 배열 끝부터 거슬러 셉니다. `index < 0`인 경우, `index + array.length`로 접근합니다.

### 반환 값

주어진 인덱스와 일치하는 배열의 요소입니다. `index < -array.length` 또는 `index >= array.length`인 경우, 해당 속성에 접근하지 않고 항상 `undefined`를 반환합니다.

설명
--

인덱스가 음수가 아니라면, `at()` 메서드는 대괄호 표기법과 동일합니다. 예를 들어, `array[0]`과 `array.at(0)`은 모두 배열의 첫 번째 항목을 반환합니다. 그러나 배열의 끝에서부터 요소를 계산할 땐 Python이나 R처럼 `array[-1]`을 사용할 수 없습니다. 대괄호 안의 모든 값은 문자 그대로 문자열 속성으로 처리되므로 `array["-1"]`을 읽게 됩니다. 이는 배열 인덱스가 아닌 일반 문자열 속성입니다.

일반적인 방법은 `length`에 접근하고, 그로부터 인덱스를 계산하는 것입니다(예: `array[array.length - 1]`). `at()` 메서드는 상대 인덱싱을 허용하므로 이를 `array.at(-1)`로 단축할 수 있습니다.

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

예제
--

### 배열의 끝 값 반환

아래 예제는 주어진 배열에서 맨 마지막에 위치한 값을 반환하는 함수를 정의합니다.


```js
// 몇 가지 요소가 있는 배열
const cart = ["사과", "바나나", "배"];

// 주어진 배열의 마지막 요소를 반환하는 함수
function returnLast(arr) {
  return arr.at(-1);
}

// 'cart' 배열에서 마지막 요소를 가져옴
const item1 = returnLast(cart);
console.log(item1); // '배'

// 'cart'배열에 요소를 추가
cart.push("오렌지");
const item2 = returnLast(cart);
console.log(item2); // '오렌지'
```

### 메서드 비교

아래 예제에서는 `Array`의 뒤에서 두 번째 요소를 가져오는 서로 다른 방법을 비교합니다. 모든 방법이 유효하긴 하지만 `at()` 메서드의 간결성과 가독성을 확인할 수 있습니다.


```js
// 몇 가지 요소가 있는 배열
const colors = ["빨강", "초록", "파랑"];

// length 속성 사용
const lengthWay = colors[colors.length - 2];
console.log(lengthWay); // '초록'

// slice() 메서드 사용. 배열을 반환하는 것에 유의
const sliceWay = colors.slice(-2, -1);
console.log(sliceWay[0]); // '초록'

// at() 메서드 사용
const atWay = colors.at(-2);
console.log(atWay); // '초록'
```

### 배열이 아닌 객체에서 at() 호출

`at()` 메서드는 `this`의 `length` 속성을 읽고 접근할 인덱스를 계산합니다.


```js
const arrayLike = {
  length: 2,
  0: "a",
  1: "b",
  2: "c", // length가 2이므로 at()은 이 값을 무시합니다.
};
console.log(Array.prototype.at.call(arrayLike, 0)); // "a"
console.log(Array.prototype.at.call(arrayLike, 2)); // undefined
```

명세서
---

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

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

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

같이 보기
-----

* `core-js`의 `Array.prototype.at` 폴리필
* 인텍스 된 컬렉션
* `Array`
* `Array.prototype.findIndex()`
* `Array.prototype.indexOf()`
* `TypedArray.prototype.at()` (en-US)
* `String.prototype.at()`
Array.prototype.flat()
======================

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

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

* Learn more
* See full compatibility
* Report feedback
`Array` 인스턴스의 **`flat()`** 메서드는 모든 하위 배열 요소가 지정된 깊이까지 재귀적으로 연결된 새 배열을 생성합니다.

시도해보기
-----

구문
--


```js
flat()
flat(depth)
```

### 매개변수

`depth` Optional

 중첩된 배열 구조를 얼마나 깊이 평탄화 할지를 지정하는 깊이 수준입니다.
 기본값은 1입니다.


### 반환 값

하위 배열 요소가 연결된 새 배열입니다.

설명
--

`flat()` 메서드는 복사 메서드입니다. 이 메서드는 `this`를 변경하지 않는 대신 원래 배열의 요소와 동일한 요소를 포함하는 얕은 복사본을 반환합니다.

`flat()` 메서드는 평탄화할 배열이 희소 배열인 경우 빈 슬롯을 무시합니다. 예를 들어 `depth`가 1이면, 루트 배열과 중첩 배열의 첫 번째 수준에 있는 빈 슬롯은 모두 무시되지만 중첩된 배열의 빈 슬롯은 배열 자체와 함께 보존됩니다.

`flat()` 메서드는 범용입니다. `this`에는 length 속성과 정수 키 속성만 있을 것으로 예상합니다. 그러나 요소를 평탄화하려면 해당 요소는 배열이어야 합니다.

예제
--

### 중첩 배열 평탄화


```js
const arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]

const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]

const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

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

`flat()` 메서드는 배열의 빈 슬롯을 제거합니다.


```js
const arr5 = [1, 2, , 4, 5];
console.log(arr5.flat()); // [1, 2, 4, 5]

const array = [1, , 3, ["a", , "c"]];
console.log(array.flat()); // [ 1, 3, "a", "c" ]

const array2 = [1, , 3, ["a", , ["d", , "e"]]];
console.log(array2.flat()); // [ 1, 3, "a", ["d", empty, "e"] ]
console.log(array2.flat(2)); // [ 1, 3, "a", "d", "e"]
```

### 배열이 아닌 객체에서 flat() 호출

`flat()` 메서드는 `this`의 `length` 속성을 읽은 다음 키가 `length`보다 작은 음수가 아닌 정수인 속성에 각각 접근합니다. 요소가 배열이 아니면, 요소는 결괏값에 직접 추가됩니다. 요소가 배열인 경우 `depth` 매개변수에 따라 평탄화됩니다.


```js
const arrayLike = {
  length: 3,
  0: [1, 2],
  // 유사 배열은 평탄화되지 않습니다.
  1: { length: 2, 0: 3, 1: 4 },
  2: 5,
  3: 3, // length가 3이므로 flat()에서 무시됩니다.
};
console.log(Array.prototype.flat.call(arrayLike));
// [ 1, 2, { '0': 3, '1': 4, length: 2 }, 5 ]
```

명세서
---

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

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

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

같이 보기
-----

* `core-js`의 `Array.prototype.flat` 폴리필
* 인덱스 기반 컬렉션
* `Array`
* `Array.prototype.concat()`
* `Array.prototype.flatMap()`
* `Array.prototype.map()`
* `Array.prototype.reduce()`
Array.isArray()
===============

**`Array.isArray()`** 메서드는 인자가 `Array`인지 판별합니다.


```js
Array.isArray([1, 2, 3]); // true
Array.isArray({ foo: 123 }); // false
Array.isArray("foobar"); // false
Array.isArray(undefined); // false
```

구문
--


```js
Array.isArray(obj);
```

### 매개변수

`obj`

검사할 객체.

### 반환 값

객체가 `Array`라면 `true`, 아니라면 `false`.

설명
--

객체가 `Array`라면 `true`를 반환하고, 아니라면 `false`를 반환합니다.

자세한 정보는 "Determining with absolute accuracy whether or not a JavaScript object is an array"(JavaScript 객체가 배열인지 정확히 판별하는 방법) 문서를 참조하세요.

예제
--


```js
// 모두 true 반환
Array.isArray([]);
Array.isArray([1]);
Array.isArray(new Array());
Array.isArray(new Array("a", "b", "c", "d"));
Array.isArray(new Array(3));
// Array.prototype은 스스로도 배열입니다
Array.isArray(Array.prototype);

// 모두 false 반환
Array.isArray();
Array.isArray({});
Array.isArray(null);
Array.isArray(undefined);
Array.isArray(17);
Array.isArray("Array");
Array.isArray(true);
Array.isArray(false);
Array.isArray({ \_\_proto\_\_: Array.prototype });
```

### `instanceof` vs `isArray`

`Array` 객체를 판별할 때, `Array.isArray`는 `iframe`을 통해서도 작동하기 때문에 `instanceof` 보다 적합합니다.


```js
var iframe = document.createElement("iframe");
document.body.appendChild(iframe);
xArray = window.frames[window.frames.length - 1].Array;
var arr = new xArray(1, 2, 3); // [1,2,3]

// 올바른 Array 판별
Array.isArray(arr); // true
// iframe을 통해서 작동하지 않기 때문에 올바르지 않은 방법
arr instanceof Array; // false
```

폴리필
---

아래 코드를 실행하면 지원하지 않는 환경에서도 `Array.isArray()`를 사용할 수 있습니다.


```js
if (!Array.isArray) {
  Array.isArray = function (arg) {
    return Object.prototype.toString.call(arg) === "[object Array]";
  };
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.isarray |

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

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

참고
--

* `Array`
Array.prototype.entries()
=========================

`Array` 인스턴스의 **`entries()`** 메서드는 배열의 각 인덱스에 대한 키/값 쌍을 포함하는 새 배열 반복자 (en-US) 객체를 반환합니다.

시도해보기
-----

구문
--


```js
entries()
```

### 매개변수

없음.

### 반환 값

새 순회 가능 반복자 객체 (en-US).

설명
--

희소 배열이 사용되는 경우, `entries()` 메서드는 빈 슬롯에 `undefined`값이 있는것 처럼 순회합니다.

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

예시
--

### 인덱스와 요소 순회하기


```js
const a = ["a", "b", "c"];

for (const [index, element] of a.entries()) {
  console.log(index, element);
}

// 0 'a'
// 1 'b'
// 2 'c'
```

### for...of 루프 사용하기


```js
const array = ["a", "b", "c"];
const arrayEntries = array.entries();

for (const element of arrayEntries) {
  console.log(element);
}

// [0, 'a']
// [1, 'b']
// [2, 'c']
```

### 희소 배열 순회하기

`entries()`는 빈 슬롯을 `undefined`인 것처럼 접근합니다.


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

### entries()를 배열이 아닌 객체에서 사용하기

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


```js
const arrayLike = {
  length: 3,
  0: "a",
  1: "b",
  2: "c",
  3: "d", // length가 3이므로 entries()에서 무시됩니다.
};
for (const entry of Array.prototype.entries.call(arrayLike)) {
  console.log(entry);
}
// [ 0, 'a' ]
// [ 1, 'b' ]
// [ 2, 'c' ]
```

명세서
---

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

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

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

같이 보기
-----

* `core-js`의 `Array.prototype.entries` 폴리필
* 인덱스된 컬렉션
* `Array`
* `Array.prototype.keys()`
* `Array.prototype.values()`
* `Array.prototype[@@iterator]()`
* `TypedArray.prototype.entries()`
* Iteration protocols
Array.prototype[@@unscopables]
==============================

`Array.prototype`의 **`@@unscopable`** 데이터 속성은 모든 `Array` 인스턴스에서 공유됩니다. 여기에는 ES2015 버전 이전에는 ECMAScript 표준에 포함되지 않았고, `with` (en-US) 문 바인딩을 위해 무시되는 속성 이름이 포함되어 있습니다.

값
-

아래에 있는 속성 이름과 해당 값이 `true`로 설정된 널 프로토타입 객체입니다.

| Property attributes of `Array.prototype[@@unscopables]` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 가능 |

설명
--

`with` 문 바인딩 목적으로 무시되는 기본 `Array` 속성은 다음과 같습니다.

* `at()`
* `copyWithin()`
* `entries()`
* `fill()`
* `find()`
* `findIndex()`
* `findLast()`
* `findLastIndex()`
* `flat()`
* `flatMap()`
* `includes()`
* `keys()`
* `toReversed()`
* `toSorted()`
* `toSpliced()`
* `values()`

`Array.prototype[@@unscopables]`는 위의 모든 속성 이름과 `true` 값만 포함하는 빈 객체입니다. 이 객체의 프로토타입은 `null`이므로 실수로 `toString`과 같은 `Object.prototype` 속성은 범위 지정이 불가능해지지 않으며, `with` 문 내의 `toString()`은 배열에서 계속 호출됩니다.

객체에 범위 지정 불가능 속성을 설정하는 방법은 `Symbol.unscopables` (en-US)를 참조하세요.

예제
--

아래의 `keys.push('something')` 호출이 ECMAScript 2015 이전에 작성된 코드에 있다고 가정해 보겠습니다.


```js
var keys = [];

with (Array.prototype) {
  keys.push("something");
}
```


ECMAScript 2015에 `Array.prototype.keys()` 메서드가 도입되었을 때, `@@unscopables` 데이터 속성이 함께 도입되지 않았다면, JavaScript 런타임이 `keys`를 예제 코드에 정의된 `keys` 배열이 아닌 `Array.prototype.keys()` 메서드로 해석하기 때문에 해당 `keys.push('something')` 호출이 중단될 수 있었습니다.

따라서 `Array.prototype`에 대한 `@@unscopables` 데이터 속성을 사용하면 ECMAScript 2015에 도입된 `Array` 속성이 `with` 문 바인딩 목적으로 무시되므로 ECMAScript 2015 이전에 작성된 코드가 중단되지 않고 예상대로 계속 작동할 수 있습니다.

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@unscopables |

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

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

같이 보기
-----

* `core-js`의 `Array.prototype[@@unscopables]` 폴리필
* 인덱스된 콜렉션
* `Array`
* `with` (en-US)
* `Symbol.unscopables` (en-US)
Array.prototype.fill()
======================

`Array` 인스턴스의 **`fill()`** 메서드는 배열의 인덱스 범위 내에 있는 모든 요소를 정적 값으로 변경합니다. 그리고 수정된 배열을 반환합니다.

시도해보기
-----

구문
--


```js
fill(value)
fill(value, start)
fill(value, start, end)
```

### 매개변수

`value`

배열을 채울 값입니다. 배열의 모든 요소는 정확히 이 값이 될 것입니다. `value`가 객체인 경우, 배열의 각 슬롯은 해당 객체를 참조합니다.

`start` Optional

채우기를 시작할 0 기반 인덱스로, 정수로 변환됩니다.

* 음수 인덱스는 배열의 끝부터 거꾸로 셉니다. `start < 0`인 경우, `start + array.length`가 사용됩니다.
* `start < -array.length` 또는 `start`가 생략된 경우, `0`이 사용됩니다.
* `start >= array.length`이면, 아무 인덱스도 채워지지 않습니다.

`end` Optional

채우기를 끝낼 0 기반 인덱스로, 정수로 변환됩니다. `fill()`은 `end`까지 채우며, `end`는 포함하지 않습니다.

* 음수 인덱스는 배열의 끝부터 거꾸로 셉니다. `end < 0`인 경우, `end + array.length`가 사용됩니다.
* `end < -array.length` 이면, `0`이 사용됩니다.
* `end >= array.length` 이거나 `end`가 생략된 경우, `array.length`가 사용되어 끝까지 모든 인덱스가 채워집니다.
* `end`가 정수로 변환된 후, `after`보다 앞에 위치하면, 아무 인덱스도 채워지지 않습니다.

### 반환 값

`value`로 채워진 변경된 배열입니다.

설명
--

`fill()` 메서드는 변경 메서드입니다. 이 메서드는 `this`의 length는 변경하지 않지만, `this`의 내용은 변경합니다.

`fill()` 메서드는 희소 배열의 빈 슬롯도 `value`로 채웁니다.

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

**참고:** 빈 배열(`length = 0`)에 `Array.prototype.fill()`을 사용하면 배열에 수정할 내용이 없으므로 배열이 수정되지 않습니다.
 배열을 선언할 때 `Array.prototype.fill()`을 사용하려면 배열의 길이가 0이 아닌지 확인하세요.
 예제를 참조하십시오.


예제
--

### fill() 사용하기


```js
console.log([1, 2, 3].fill(4)); // [4, 4, 4]
console.log([1, 2, 3].fill(4, 1)); // [1, 4, 4]
console.log([1, 2, 3].fill(4, 1, 2)); // [1, 4, 3]
console.log([1, 2, 3].fill(4, 1, 1)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, 3, 3)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, -3, -2)); // [4, 2, 3]
console.log([1, 2, 3].fill(4, NaN, NaN)); // [1, 2, 3]
console.log([1, 2, 3].fill(4, 3, 5)); // [1, 2, 3]
console.log(Array(3).fill(4)); // [4, 4, 4]

// 배열의 각 슬롯이 참조하는 단일 객체
const arr = Array(3).fill({}); // [{}, {}, {}]
arr[0].hi = "hi"; // [{ hi: "hi" }, { hi: "hi" }, { hi: "hi" }]
```

### fill()을 사용하여 전체 1 행렬로 만들기

이 예제는 Octave 또는 MATLAB의 `ones()` 함수와 같이 전체 1 행렬을 만드는 방법을 보여줍니다.


```js
const arr = new Array(3);
for (let i = 0; i < arr.length; i++) {
  arr[i] = new Array(4).fill(1); // 크기가 4이고, 1로 채워진 배열 생성
}
arr[0][0] = 10;
console.log(arr[0][0]); // 10
console.log(arr[1][0]); // 1
console.log(arr[2][0]); // 1
```

### fill()을 사용하여 빈 배열 채우기

이 예제는 모든 요소를 특정 값으로 설정하여 배열을 채우는 방법을 보여줍니다. `end` 매개변수는 지정할 필요가 없습니다.


```js
const tempGirls = Array(5).fill("girl", 0);
```


이 배열은 처음에 인덱스가 할당되지 않은 희소 배열이었습니다. 그래도 `fill()`은 여전히 이 배열을 채울 수 있습니다.

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

`fill()` 메서드는 `this`의 `length` 속성을 읽고 `start`부터 `end`까지 각 정수 키 속성 값을 설정합니다.


```js
const arrayLike = { length: 2 };
console.log(Array.prototype.fill.call(arrayLike, 1));
// { '0': 1, '1': 1, length: 2 }
```

명세서
---

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

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

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

같이 보기
-----

* `core-js`의 `Array.prototype.fill` 폴리필
* 인덱스된 컬렉션
* `Array`
* `TypedArray.prototype.fill()`
Array.prototype.join()
======================

`Array` 인스턴스의 **`Join()`** 메서드는 배열의 모든 요소를 쉼표나 지정된 구분 문자열로 구분하여 연결한 새 문자열을 만들어 반환합니다. 배열에 항목이 하나만 있는 경우, 해당 항목은 구분 기호를 사용하지 않고 반환됩니다.

시도해보기
-----

구문
--


```js
join()
join(separator)
```

### 매개변수

`separator` Optional

배열의 인접한 요소의 각 쌍을 구분하는 문자열입니다. 생략되면 배열 요소는 쉼표(",")로 구분됩니다.

### 반환 값

배열의 모든 요소들을 연결한 하나의 문자열을 반환합니다. 만약 `arr.length` 가 `0`이라면, 빈 문자열을 반환합니다.

설명
--

문자열로 변환된 모든 배열 요소가 하나의 문자열로 결합됩니다. 요소가 `undefined`, `null`인 경우, "null" 또는 "undefine" 문자열 대신 빈 문자열로 변환됩니다.

`Array.prototype.toString()`는 `join` 메서드를 내부적으로 인수 없이 호출합니다. 배열 인스턴스의 `join`을 재정의하면 해당 `toString` 동작도 재정의됩니다.

`Array.prototype.join`은 다른 배열을 포함하여 재귀적으로 각 요소를 문자열로 변환합니다. `Array.prototype.toString`(`join()` 호출과 같음)에서 반환된 문자열에는 구분 기호가 없기 때문에 중첩된 배열은 평탄화된 것처럼 보입니다. 첫 번째 수준의 구분 기호만 제어할 수 있으며, 더 깊은 수준에서는 항상 기본 쉼표를 사용합니다.


```js
const matrix = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9],
];

console.log(matrix.join()); // 1,2,3,4,5,6,7,8,9
console.log(matrix.join(";")); // 1,2,3;4,5,6;7,8,9
```


배열이 순환 배열(자체 요소를 포함)인 경우, 브라우저는 순환 참조를 무시하여 무한 재귀를 방지합니다.


```js
const arr = [];
arr.push(1, [3, arr, 4], 2);
console.log(arr.join(";")); // 1;3,,4;2
```


희소 배열에 사용되는 경우, `join()` 메서드는 빈 슬롯의 값이 `undefined`인 것처럼 반복합니다.

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

예제
--

### 네 가지 다른 방법으로 배열 연결하기

다음 예제에서는 세 개의 요소가 있는 배열 `a`를 만든 다음, 기본 구분 기호, 쉼표와 공백, 그리고 더하기와 빈 문자열을 사용하여 배열을 네 번 연결합니다.


```js
const a = ["바람", "물", "불"];
a.join(); // '바람,물,불'
a.join(", "); // '바람, 물, 불'
a.join(" + "); // '바람 + 물 + 불'
a.join(""); // '바람물불'
```

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

`join()`은 빈 슬롯을 `undefined`와 같이 처리하고 추가 구분 기호를 생성합니다.


```js
console.log([1, , 3].join()); // '1,,3'
console.log([1, undefined, 3].join()); // '1,,3'
```

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

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


```js
const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 4,
  3: 5, // length가 3 이므로 join()에서 무시됨.
};
console.log(Array.prototype.join.call(arrayLike));
// 2,3,4
console.log(Array.prototype.join.call(arrayLike, "."));
// 2.3.4
```

명세서
---

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

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

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

같이 보기
-----

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

`Array` 인스턴스의 **`length`** 속성은 배열의 길이를 반환합니다. 반환값은 부호 없는 32비트 정수형이며, 배열의 최대 인덱스보다 항상 큽니다. **`length`** 속성에 값을 설정할 경우 배열의 길이를 변경합니다.

시도해보기
-----

설명
--

`length` 속성의 값은 양의 정수이며 2^32 미만의 값을 가집니다.


```js
var namelistA = new Array(4294967296); // 2의 32제곱 = 4294967296
var namelistC = new Array(-100); // 음수

console.log(namelistA.length); // RangeError: Invalid array length
console.log(namelistC.length); // RangeError: Invalid array length

var namelistB = [];
namelistB.length = Math.pow(2, 32) - 1; // 길이를 2의 32제곱 미만으로 설정
console.log(namelistB.length);

// 4294967295
```


아무 때나 `length` 속성에 값을 설정해 배열을 절단할 수 있습니다. `length` 속성으로 배열의 길이를 늘리면 실제 원소의 수가 증가합니다. 예를 들어 길이가 2인 배열의 `length`를 3으로 설정한다면 마지막에 `undefined`가 추가돼 총 3개의 요소를 갖게 됩니다.


```js
var arr = [1, 2, 3];
printEntries(arr);

arr.length = 5; // set array length to 5 while currently 3.
printEntries(arr);

function printEntries(arr) {
  var length = arr.length;
  for (var i = 0; i < length; i++) {
    console.log(arr[i]);
  }
  console.log("=== printed ===");
}

// 1
// 2
// 3
// === printed ===
// 1
// 2
// 3
// undefined
// undefined
// === printed ===
```


그러나 `length` 속성의 값이 꼭 배열에 정의된 원소의 수를 나타내진 않습니다. `length`와 숫자형 속성의 관계를 참고하세요.

| Property attributes of `Array.length` |
| --- |
| Writable | 가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

예제
--

### 배열 순회

다음 예제는 `numbers` 배열을 length 속성의 크기만큼 순회합니다. 각 원소의 값은 두 배가 됩니다.


```js
var numbers = [1, 2, 3, 4, 5];
var length = numbers.length;
for (var i = 0; i < length; i++) {
  numbers[i] \*= 2;
}
// numbers is now [2, 4, 6, 8, 10]
```

### 배열 단축

다음 예제는 `numbers` 배열의 현재 길이가 3보다 클 경우 3으로 줄입니다.


```js
var numbers = [1, 2, 3, 4, 5];

if (numbers.length > 3) {
  numbers.length = 3;
}

console.log(numbers); // [1, 2, 3]
console.log(numbers.length); // 3
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-array-instances-length |

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

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

같이 보기
-----

* `Array`
Array.prototype.findLastIndex()
===============================

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

인덱스 대신 판별함수를 만족하는 마지막 값을 반환하는`findLast()`메서드도 참고하세요.

시도해보기
-----

구문
--


```js
findLastIndex(callbackFn)
findLastIndex(callbackFn, thisArg)
```

### 매개변수

`callbackFn`

배열의 각 요소에 대해 실행할 함수입니다. 이 함수는 매칭된 요소가 발견되었음을 나타내기 위해 참 값을 반환해야하며, 그렇지 않으면 거짓 값을 반환해야 합니다. 이 함수는 다음과 같은 인수와 함께 호출됩니다.

`element`

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

`index`

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

`array`

`findLastIndex()`가 호출된 배열입니다.


`thisArg` Optional

`callbackFn`을 실행할 때 this로 사용할 객체입니다. 자세한 내용은 반복적인 메소드(iterative methods)를 참조합니다.

### 반환 값

 테스트를 통과하는 배열에서 마지막 요소(가장 높은 인덱스)의 인덱스입니다.
 만약 매칭되는 요소가 없다면 -1을 반환합니다.

설명
--

`findLastIndex()` 메서드는 반복적인 메소드(iterative methods)입니다. 이 메서드는 배열의 각 요소마다 제공된 `callbackFn` 함수를 역순으로 한 번씩 호출하며, `callbackFn`이 참 값을 반환할 때까지 반복합니다. 참 값이 반환되면 `findLastIndex()`는 해당 요소의 인덱스를 반환하고 배열 반복을 중단합니다. 만약 `callbackFn`이 참 값을 반환하지 않으면, `findLastIndex()`는 `-1`을 반환합니다.

`callbackFn`는 배열의 *모든* 인덱스에 대해 호출됩니다. 할당된 값이 있는 인덱스뿐만 아니라 희소 배열(sparse arrays)의 비어있는 슬롯도 `undefined`와 동일하게 동작합니다.

`findLastIndex()` 메서드는 호출된 배열을 변경하지 않지만, 인자로 제공된 `callbackFn`은 변경할 수 있습니다. 그러나, 배열의 길이는 `callbackFn`의 첫 호출 *이전에* 저장됨에 유의합니다. 따라서 다음과 같이 동작합니다.

* `callbackFn`은 `findLastIndex()`가 호출된 이후 배열에 추가된 요소에 방문하지 않습니다.
* 이미 방문한 인덱스의 변경은 `callbackFn`을 다시 호출하지 않습니다.
* `callbackFn`에 의해 아직 방문되지 않은 배열의 기존 요소가 변경되면, `callbackFn`에 전달되는 값은 해당 요소가 방문되었을 때의 값이 됩니다. 삭제된 (en-US) 요소는 마치 `undefined`인 것처럼 방문됩니다.

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

`findLastIndex()` 메서드는 일반적인(generic) 메서드입니다. 이는 `this` 값이 `length` 속성과 정수 키 속성을 가지고 있는 것만을 요구합니다.

예제
--

### 배열에서 마지막 소수의 인덱스 찾기

다음 예제는 배열에서 마지막으로 나오는 소수(prime number)의 인덱스를 반환하며, 소수가 없는 경우 `-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, 12].findLastIndex(isPrime)); // -1, not found
console.log([4, 5, 7, 8, 9, 11, 12].findLastIndex(isPrime)); // 5
```

### 희소 배열에서 findLastIndex() 사용

희소 배열에서 `undefined`를 찾아 빈 슬롯의 인덱스를 알아낼 수 있습니다.


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

### 배열이 아닌 객체에서 findLastIndex() 사용

`findLastIndex()` 메서드는 `this`의 `length` 속성을 읽은 다음 각 정수 인덱스에 접근합니다.


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

명세
--

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

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

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

같이 보기
-----

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

**`pop()`** 메서드는 배열에서 **마지막** 요소를 제거하고 그 요소를 반환합니다.

시도해보기
-----

구문
--


```js
arr.pop();
```

### 반환 값

배열에서 제거한 요소. 빈 배열의 경우 `undefined` 를 반환합니다.

설명
--

`pop` 메서드는 배열에서 마지막 요소를 제거하여 그 값을 호출자(caller)에게 반환합니다.

`pop`은 일부러 일반(generic)입니다; 이 메서드는 배열을 닮은 객체에 호출 또는 적용될 수 있습니다. 0부터 시작하는 일련의 연속되는 숫자 속성 내 마지막을 반영하는 `length` 속성을 포함하지 않는 객체는 어떤 의미 있는 방식으로도 행동하지 않을 수 있습니다.

빈 배열에 `pop()`을 호출하면, `undefined`를 반환합니다.

예제
--

### 배열의 마지막 요소 제거

다음 코드는 요소 넷을 포함하는 `myFish` 배열을 생성하고 그 마지막 요소를 제거합니다.


```js
var myFish = ["angel", "clown", "mandarin", "sturgeon"];

var popped = myFish.pop();

console.log(myFish); // ['angel', 'clown', 'mandarin' ]

console.log(popped); // 'sturgeon'
```

명세
--

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

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

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

같이 보기
-----

* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.splice()`