String.prototype.toLocaleUpperCase() - JavaScript

String.prototype.toLocaleUpperCase()
====================================

**`toLocaleUpperCase()`** 메서드는 어떤 지역 특정 대/소문자 매핑에 따른 대문자로 변환된 문자열 값을 반환합니다.

시도해보기
-----

구문
--

```js
toLocaleUpperCase()
toLocaleUpperCase(locales)
```

### 매개변수

`locales` Optional

BCP 47 언어 태그가 있는 문자열 또는 이런 문자열을 가진 배열. 어떤 지역 특정 대/소문자 매핑에 따른 대문자로 변환하는데 사용된 지역을 나타냅니다. 일반 양식과 `locales` 인수의 설명에 대해서 Locale identification and negotiation (en-US)를 참조하세요.

### 반환 값

어떤 지역 특정 대/소문자 매핑에 따른 대문자로 변환된 문자열을 나타낸 새 문자열.

### 예외

* `locale` 인수가 올바른 언어 태그가 아닌 경우 `RangeError` ("잘못된 언어 태그: xx\_yy")가 발생합니다.
* 배열 요소가 문자열 유형이 아닌 경우 `TypeError` ("지역 인수에 있는 잘못된 요소")가 발생합니다.
설명
--

`theLocaleUpperCase()` 메서드는 지역 특정 대/소문자 맴핑에 따른 대문자로 변환된 문자열 값을 반환합니다. `toLocaleUpperCase()`는 문자열 자체 값에 영향을 미치지 않습니다. 대부분의 경우, `toUpperCase()`와 같은 결과를 제공하지만 터키와 같은 일부 지역에서는 대/소문자 매핑이 유니코드의 기존 대/소문자 매핑을 따르지 않아 다른 결과가 있을 수 있습니다.

또한 대문자로 변환될 때 어떤 문자는 두 개 (혹은 그 이상) 문자를 생성할 수 있으므로 변환이 반드시 1:1 문자 맴핑일 필요는 없다는 것을 알아야 합니다. 그러므로 문자열 결과 길이는 입력 길이와 다를 수 있습니다. 이것은 또한 변환이 안정적이지 않음을 의미합니다. 즉, 구문 `x.toLocaleLowerCase() === x.toLocaleUpperCase().toLocaleLowerCase()`는 `false`를 반환할 수 있습니다.

예제
--

### toLocaleUpperCase() 사용

```js
"alphabet".toLocaleUpperCase(); // 'ALPHABET'

"Gesäß".toLocaleUpperCase(); // 'GESÄSS'

"i\u0307".toLocaleUpperCase("lt-LT"); // 'I'

const locales = ["lt", "LT", "lt-LT", "lt-u-co-phonebk", "lt-x-lietuva"];
"i\u0307".toLocaleUpperCase(locales); // 'I'
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocaleuppercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocaleuppercase |

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

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

같이 보기
-----

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`


String.prototype.normalize() - JavaScript

String.prototype.normalize()
============================

**`normalize()`** 메서드는 주어진 문자열을 유니코드 정규화 방식(Unicode Normalization Form)에 따라 정규화된 형태로 반환합니다. 만약 주어진 값이 문자열이 아닐 경우에는 우선 문자열로 변환 후 정규화합니다.

시도해보기
-----

구문
--

```js
str.normalize([form]);
```

### 매개변수

`form`

유니코드 정규화 방식을 지정합니다. `"NFC"`, `"NFD"`, `"NFKC"`, `"NFKD"` 중 하나이며, 생략되거나 `undefined` 일 경우 `"NFC"`가 사용됩니다.\* `NFC` — 정규형 정준 결합(Normalization Form Canonical Composition).

* `NFD` — 정규형 정준 분해(Normalization Form Canonical Decomposition).
* `NFKC` — 정규형 호환성 결합(Normalization Form Compatibility Composition).
* `NFKD` — 정규형 호환성 분해(Normalization Form Compatibility Decomposition).

### 반환 값

주어진 문자열을 유니코드 정규화 방식에 따라 정규화된 문자열로 반환합니다.

### 예외

`RangeError`

`form`이 위에서 명시된 값 중 하나가 아닐 경우 `RangeError` 에러가 발생합니다.

설명
--

`normalize()` 메서드는 문자열을 유니코드 정규화 방식에 따라 정규화된 형태로 반환합니다. 문자열의 값 자체에는 영향을 주지 않습니다.

예제
--

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

```js
// 원본 문자열

// U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE
// U+0323: COMBINING DOT BELOW
var str = "\u1E9B\u0323";

// 정규형 정준 결합 (NFC)

// U+1E9B: LATIN SMALL LETTER LONG S WITH DOT ABOVE
// U+0323: COMBINING DOT BELOW
str.normalize("NFC"); // '\u1E9B\u0323'
str.normalize(); // 위와 같은 결과

// 정규형 정준 분해 (NFD)

// U+017F: LATIN SMALL LETTER LONG S
// U+0323: COMBINING DOT BELOW
// U+0307: COMBINING DOT ABOVE
str.normalize("NFD"); // '\u017F\u0323\u0307'

// 정규형 호환성 결합 (NFKC)

// U+1E69: LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE
str.normalize("NFKC"); // '\u1E69'

// 정규형 호환성 분해 (NFKD)

// U+0073: LATIN SMALL LETTER S
// U+0323: COMBINING DOT BELOW
// U+0307: COMBINING DOT ABOVE
str.normalize("NFKD"); // '\u0073\u0323\u0307'
```

### 한글에 `normalize()` 사용하기

```js
// 결합된 한글 문자열

// U+D55C: 한(HANGUL SYLLABLE HAN)
// U+AE00: 글(HANGUL SYLLABLE GEUL)
var first = "\uD55C\uAE00";

// 정규형 정준 분해 (NFD)
// 정준 분해 결과 초성, 중성, 종성의 자소분리가 일어납니다.
// 일부 브라우저에서는 결과값 '한글'이 자소분리된 상태로 보여질 수 있습니다.

// U+1112: ᄒ(HANGUL CHOSEONG HIEUH)
// U+1161: ᅡ(HANGUL JUNGSEONG A)
// U+11AB: ᆫ(HANGUL JONGSEONG NIEUN)
// U+1100: ᄀ(HANGUL CHOSEONG KIYEOK)
// U+1173: ᅳ(HANGUL JUNGSEONG EU)
// U+11AF: ᆯ(HANGUL JONGSEONG RIEUL)
var second = first.normalize("NFD"); // '\u1112\u1161\u11AB\u1100\u1173\u11AF'

// 정규형 정준 결합 (NFC)
// 정준 결합 결과 자소분리 되었던 한글이 결합됩니다.

// U+D55C: 한(HANGUL SYLLABLE HAN)
// U+AE00: 글(HANGUL SYLLABLE GEUL)
var third = second.normalize("NFC"); // '\uD55C\uAE00'

console.log(second === third); // 같은 글자처럼 보이지만 false를 출력합니다.
```

명세
--

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

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

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

같이 보기
-----

* Unicode Standard Annex #15, Unicode Normalization Forms
* Unicode equivalence
* 유니코드 정규화


String.prototype.replaceAll() - JavaScript

String.prototype.replaceAll()
=============================

**`replaceAll()`** 메서드는 `pattern`의 모든 일치 항목이 `replacement`로 대체된 새 문자열을 반환합니다. `pattern`은 문자열 또는 `RegExp`일 수 있으며 `replacement`는 각 일치 항목에 대해 호출되는 문자열 또는 함수일 수 있습니다. 원래 문자열은 변경되지 않습니다.

시도해보기
-----

구문
--

```js
replaceAll(pattern, replacement)
```

매개변수
----

`pattern`

문자열이거나 `Symbol.replace` (en-US) 메서드가 있는 객체일 수 있습니다. 일반적인 예로 정규식이 있습니다. `Symbol.replace` 메서드가 없는 모든 값은 문자열로 강제 변환됩니다.

`pattern`이 정규식이면 전역(`g`) 플래그가 설정되어 있어야 합니다. 그렇지 않으면 `TypeError`가 발생합니다.

`replacement`

문자열이거나 함수일 수 있습니다. 교체는 `String.prototype.replace()` (en-US)와 동일한 의미 체계를 갖습니다.

### 반환 값

패턴의 모든 일치 항목이 교체자로 대체된 새 문자열입니다.

### 예외

`TypeError`

`pattern`이 정규식 이지만, 전역(`g`) 플래그가 설정되지 않은 경우 발생합니다(`flags` 속성에 "g"가 포함되지 않음).

설명
--

이 메서드는 호출된 문자열 값을 변경하지 않고 새 문자열을 반환합니다.

`replace()` (en-US)와 달리 이 메서드는 첫 번째 문자열뿐만 아니라 문자열의 모든 항목을 바꿉니다. 특수 문자를 이스케이프하지 않고 `RegExp()` 생성자를 호출하면 의도하지 않게 의미 체계가 변경될 수 있으므로 문자열이 정적이라고 확신하지 못할 때 특히 유용합니다.

```js
function unsafeRedactName(text, name) {
  return text.replace(new RegExp(name, "g"), "[REDACTED]");
}
function safeRedactName(text, name) {
  return text.replaceAll(name, "[REDACTED]");
}

const report =
  "A hacker called ha.\*er used special characters in their name to breach the system.";

console.log(unsafeRedactName(report, "ha.\*er")); // "A [REDACTED]s in their name to breach the system."
console.log(safeRedactName(report, "ha.\*er")); // "A hacker called [REDACTED] used special characters in their name to breach the system."
```

`pattern`이 `Symbol.replace` (en-US) 메서드(`RegExp` 객체 포함)가 있는 객체인 경우 대상 문자열과 `replacement`를 인수로 하여 해당 메서드를 호출합니다. 반환 값은 `replaceAll()`의 반환 값이고, 이 경우 `replaceAll()`의 동작은 `@@replace` 메서드에 의해 완전히 인코딩되므로 `replace()`와 동일한 결과를 갖게 됩니다(정규식이 전역이라는 추가 입력 유효성 검사는 제외).

`pattern`이 빈 문자열인 경우엔 `split()` 동작과 유사하게 모든 UTF-16 코드 단위 사이에 교체자가 삽입됩니다.

```js
"xxx".replaceAll("", "\_"); // "\_x\_x\_x\_"
```

regex 속성(특히 sticky (en-US) 플래그)이 `replaceAll()`과 상호 작용하는 방식에 대한 자세한 내용은 `RegExp.prototype[@@replace]()` (en-US)를 참조하세요.

예제
--

### replaceAll() 사용

```js
"aabbcc".replaceAll("b", ".");
// 'aa..cc'
```

### 비전역 정규식 오류

```js
"aabbcc".replaceAll(/b/, ".");
// TypeError: replaceAll must be called with a global RegExp
```

아래는 잘 작동합니다.

```js
"aabbcc".replaceAll(/b/g, ".");
("aa..cc");
```

명세서
---

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

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

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

같이 보기
-----

* `core-js`의 `String.prototype.replaceAll` 폴리필
* `String.prototype.replace()` (en-US)
* `String.prototype.match()`
* `RegExp.prototype.exec()` (en-US)
* `RegExp.prototype.test()`


String.prototype.substring() - JavaScript

String.prototype.substring()
============================

**`substring()`** 메소드는 string 객체의 시작 인덱스로 부터 종료 인덱스 전 까지 문자열의 부분 문자열을 반환합니다.

시도해보기
-----

사용방법
----

```js
str.substring(indexStart[, indexEnd])
```

### 인자값

`indexStart`

반환문자열의 시작 인덱스

`indexEnd`

옵션. 반환문자열의 마지막 인덱스 (포함하지 않음.)

### 반환값

기존문자열의 부분 문자열을 반환합니다.

Description
-----------

`substring()` 메서드는 `indexStart` 부터 문자를 추출하지만 `indexEnd` 가 포함되지 않아도 괜찮습니다. 특징은 아래와 같습니다.

* 만약 `indexEnd` 가 생략된 경우, `substring()` 문자열의 끝까지 모든 문자를 추출합니다.
* 만약 `indexStart` 가 `indexEnd`와 같을 경우, `substring()` 빈 문자열을 반환합니다.
* 만약 `indexStart` 가 `indexEnd`보다 큰 경우, `substring()` 메서드는 마치 두 개의 인자를 바꾼 듯 작동하게 됩니다. 아래 예제를 보세요.

0보다 작은 인자 값을 가지는 경우에는 0으로, `stringName.length` 보다 큰 인자 값을 가지는 경우, `stringName.length` 로 처리됩니다. `NaN` 값은 0으로 처리됩니다.

Examples
--------

### Using `substring()`

The following example uses `substring()` to display characters from the string `'Mozilla'`:

```js
var anyString = "Mozilla";

// Displays 'M'
console.log(anyString.substring(0, 1));
console.log(anyString.substring(1, 0));

// Displays 'Mozill'
console.log(anyString.substring(0, 6));

// Displays 'lla'
console.log(anyString.substring(4));
console.log(anyString.substring(4, 7));
console.log(anyString.substring(7, 4));

// Displays 'Mozilla'
console.log(anyString.substring(0, 7));
console.log(anyString.substring(0, 10));
```

### Using `substring()` with `length` property

The following example uses the `substring()` method and `length` property to extract the last characters of a particular string. This method may be easier to remember, given that you don't need to know the starting and ending indices as you would in the above examples.

```js
// Displays 'illa' the last 4 characters
var anyString = "Mozilla";
var anyString4 = anyString.substring(anyString.length - 4);
console.log(anyString4);

// Displays 'zilla' the last 5 characters
var anyString = "Mozilla";
var anyString5 = anyString.substring(anyString.length - 5);
console.log(anyString5);
```

### The difference between `substring()` and `substr()`

There's a subtle difference between the `substring()` and `substr()` methods, so you should be careful not to get them confused.

The arguments of `substring()` represent the starting and ending indexes, while the arguments of `substr()` represent the starting index and the number of characters to include in the returned string.

```js
var text = "Mozilla";
console.log(text.substring(2, 5)); // => "zil"
console.log(text.substr(2, 3)); // => "zil"
```

### Differences between `substring()` and `slice()`

The `substring()` and `slice()` methods are almost identical, but there are a couple of subtle differences between the two, especially in the way negative arguments are dealt with.

The `substring()` method swaps its two arguments if `indexStart` is greater than `indexEnd`, meaning that a string is still returned. The `slice()` method returns an empty string if this is the case.

```js
var text = "Mozilla";
console.log(text.substring(5, 2)); // => "zil"
console.log(text.slice(5, 2)); // => ""
```

If either or both of the arguments are negative or `NaN`, the `substring()` method treats them as if they were `0`.

```js
console.log(text.substring(-5, 2)); // => "Mo"
console.log(text.substring(-5, -2)); // => ""
```

`slice()` also treats `NaN` arguments as `0`, but when it is given negative values it counts backwards from the end of the string to find the indexes.

```js
console.log(text.slice(-5, 2)); // => ""
console.log(text.slice(-5, -2)); // => "zil"
```

See the `slice()` page for more examples with negative numbers.

### Replacing a substring within a string

The following example replaces a substring within a string. It will replace both individual characters and substrings. The function call at the end of the example changes the string `Brave New World` to `Brave New Web`.

```js
// Replaces oldS with newS in the string fullS
function replaceString(oldS, newS, fullS) {
  for (var i = 0; i < fullS.length; ++i) {
    if (fullS.substring(i, i + oldS.length) == oldS) {
      fullS =
        fullS.substring(0, i) +
        newS +
        fullS.substring(i + oldS.length, fullS.length);
    }
  }
  return fullS;
}

replaceString("World", "Web", "Brave New World");
```

Note that this can result in an infinite loop if `oldS` is itself a substring of `newS` — for example, if you attempted to replace 'World' with 'OtherWorld' here. A better method for replacing strings is as follows:

```js
function replaceString(oldS, newS, fullS) {
  return fullS.split(oldS).join(newS);
}
```

The code above serves as an example for substring operations. If you need to replace substrings, most of the time you will want to use `String.prototype.replace()` (en-US).

명세서
---

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

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

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

See also
--------

* `String.prototype.substr()`
지원이 중단되었습니다
* `String.prototype.slice()`


String.prototype.split() - JavaScript

String.prototype.split()
========================

**`split()`** 메서드는 `String` 객체를 지정한 구분자를 이용하여 여러 개의 문자열로 나눕니다.

시도해보기
-----

구문
--

```js
split();
split(separator);
split(separator, limit);
```

**경고:** **주의:** 구분자로 빈 문자열(`""`)을 제공하면, 사용자가 인식하는 문자 하나(grapheme cluster) 또는 유니코드 문자(코드포인트) 하나씩으로 나누는 것이 아니라, UTF-16 코드유닛으로 나누게 되며 써로게이트 페어가 망가질 수 있습니다. 스택 오버플로우의 How do you get a string to a character array in JavaScript? 질문도 참고해 보세요.

### 매개변수

`separator` Optional

원본 문자열을 끊어야 할 부분을 나타내는 문자열을 나타냅니다. 실제 문자열이나 정규표현식을 받을 수 있습니다. 문자열 유형의 `separator`가 두 글자 이상일 경우 그 부분 문자열 전체가 일치해야 끊어집니다. `separator`가 생략되거나 `str`에 등장하지 않을 경우, 반환되는 배열은 원본 문자열을 유일한 원소로 가집니다. `separator`가 빈 문자열일 경우 `str`의 각각의 문자가 배열의 원소 하나씩으로 변환됩니다.

`limit` Optional

끊어진 문자열의 최대 개수를 나타내는 정수입니다. 이 매개변수를 전달하면 split() 메서드는 주어진 `separator`가 등장할 때마다 문자열을 끊지만 배열의 원소가 `limit`개가 되면 멈춥니다. 지정된 한계에 도달하기 전에 문자열의 끝까지 탐색했을 경우 `limit`개 미만의 원소가 있을 수도 있습니다. 남은 문자열은 새로운 배열에 포함되지 않습니다.

### 반환값

주어진 문자열을 `separator`마다 끊은 부분 문자열을 담은 `Array`.

설명
--

문자열에서 `separator`가 등장하면 해당 부분은 삭제되고 남은 문자열이 배열로 반환됩니다. `separator`가 등장하지 않거나 생략되었을 경우 배열은 원본 문자열을 유일한 원소로 가집니다. `separator`가 빈 문자열일 경우, `str`은 문자열의 모든 문자를 원소로 가지는 배열로 변환됩니다. `separator`가 원본 문자열의 처음이나 끝에 등장할 경우 반환되는 배열도 빈 문자열로 시작하거나 끝납니다. 그러므로 원본 문자열에 `separator` 하나만이 포함되어 있을 경우 빈 문자열 두 개를 원소로 가지는 배열이 반환됩니다.

`separator`가 포획 괄호를 포함하는 정규표현식일 경우, `separator`가 일치할 때마다 포획 괄호의 (정의되지 않은 경우도 포함한) 결과가 배열의 해당 위치에 포함됩니다.

>
> **Note:** `separator`가 배열일 경우 분할에 사용하기 전에 우선 문자열로 변환됩니다.
>
>
>

예제
--

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

>
> **Note:** 빈 문자열이 주어졌을 경우 `split()`은 빈 배열이 아니라 빈 문자열을 포함한 배열을 반환합니다. 문자열과 `separator`가 모두 빈 문자열일 때는 빈 배열을 반환합니다.
>
>
>

```js
const myString = "";
const splits = myString.split();

console.log(splits);

// ↪ [""]
```

다음 예제에서는 문자열을 주어진 구분자로 끊는 함수를 정의합니다. 문자열을 끊은 다음에는 (끊기 이전의) 원본 문자열과 사용한 구분자, 배열의 길이와 각 원소를 로그로 출력합니다.

```js
function splitString(stringToSplit, separator) {
  var arrayOfStrings = stringToSplit.split(separator);

  console.log('The original string is: "' + stringToSplit + '"');
  console.log('The separator is: "' + separator + '"');
  console.log(
    "The array has " +
      arrayOfStrings.length +
      " elements: " +
      arrayOfStrings.join(" / "),
  );
}

var tempestString = "Oh brave new world that has such people in it.";
var monthString = "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec";

var space = " ";
var comma = ",";

splitString(tempestString, space);
splitString(tempestString);
splitString(monthString, comma);
```

위 예제의 출력은 다음과 같습니다.
```

    The original string is: "Oh brave new world that has such people in it."
    The separator is: " "
    The array has 10 elements: Oh / brave / new / world / that / has / such / people / in / it.

    The original string is: "Oh brave new world that has such people in it."
    The separator is: "undefined"
    The array has 1 elements: Oh brave new world that has such people in it.

    The original string is: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"
    The separator is: ","
    The array has 12 elements: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec
```

### 문자열에서 공백 제거하기

다음 예제에서 `split()`은 세미콜론 앞뒤에 각각 0개 이상의 공백이 있는 부분 문자열을 찾고, 있을 경우 문자열에서 세미콜론과 공백을 제거합니다. `split()`의 결과로 반환된 배열은 `nameList`에 저장됩니다.

```js
var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ";

console.log(names);

var re = /\s\*(?:;|$)\s\*/;
var nameList = names.split(re);

console.log(nameList);
```

위 예제는 원본 문자열과 반환된 배열을 각각 한 줄씩 로그로 출력합니다.
```

    Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand
    [ "Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand", "" ]
```

### 끊는 횟수 제한하기

다음 예제에서 `split()`은 문자열을 공백으로 끊고 처음 3개의 문자열을 반환합니다.

```js
var myString = "Hello World. How are you doing?";
var splits = myString.split(" ", 3);

console.log(splits);
```

위 예제의 로그 출력은 다음과 같습니다.
```

    ["Hello", "World.", "How"]
```

### `RegExp`를 사용해 구분자도 결과에 포함하기

`separator`가 포획 괄호 `()`를 포함하는 정규표현식일 경우, 포획된 결과도 배열에 포함됩니다.

```js
var myString = "Hello 1 word. Sentence number 2.";
var splits = myString.split(/(\d)/);

console.log(splits);
```

위 예제의 로그 출력은 다음과 같습니다.
```

    [ "Hello ", "1", " word. Sentence number ", "2", "." ]
```

### 배열을 구분자로 사용하기

```js
var myString = "this|is|a|Test";
var splits = myString.split(["|"]);

console.log(splits); //["this", "is", "a", "Test"]

var myString = "ca,bc,a,bca,bca,bc";

var splits = myString.split(["a", "b"]);
// myString.split(['a','b'])은 myString.split(String(['a','b']))와 같다

console.log(splits); //["c", "c,", "c", "c", "c"]
```

### `split()`으로 문자열 뒤집기

**경고:**
 이 방법은 문자열 뒤집기에 효과적인 방법이 아닙니다.

```js
var str = "asdfghjkl";
var strReverse = str.split("").reverse().join("");
// 'lkjhgfdsa'
// split()에서 반환한 배열에는 reverse()와 join()을 사용할 수 있다 문자열에 grapheme clusters가 있을 경우, 유니코드 플래그를 설정해도 오류를 일으킵니다([esrever](https://github.com/mathiasbynens/esrever) 등의 라이브러리를 대신 사용하세요).
```

```js
var str = "résumé";
var strReverse = str.split(/(?:)/u).reverse().join("");
// => "́emuśer"
```

**추가:** `===` (en-US) 연산자를 사용하면 원본 문자열이 팰린드롬인지 확인할 수 있습니다.

명세
--

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

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

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

같이 보기
-----

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `Array.prototype.join()`


String.prototype.at() - JavaScript

String.prototype.at()
=====================

**`at()`** 메서드는 정수 값을 받아서 지정된 오프셋에 있는 단일 UTF-16 코드 단위로 구성된 새 `String`을 반환합니다. 이 방법은 양의 정수와 음의 정수를 허용합니다. 음의 정수는 문자열의 마지막부터 셉니다.

시도해보기
-----

구문
--

```js
at(index)
```

### 매개변수

`index`

문자열에서 반환할 문자의 인덱스(위치)입니다. 인덱스로 음수를 전달할 때 문자열의 끝에서 상대적인 색인을 지원합니다. 즉, 음수가 사용되면 반환할 문자는 문자열의 끝에서 역으로 계산하여 찾습니다.

### 반환 값

지정된 위치에 있는 단일 UTF-16 코드 단위로 구성된 새 `String`. 만약 주어진 인덱스를 찾을 수 없는 경우 `undefined`을 반환합니다.

예제
--

### 문자열의 마지막 문자 반환

다음 예제는 주어진 문자열에서 마지막 문자를 반환하는 함수를 제공합니다.

```js
// 주어진 문자열에서 마지막 문자를 반환하는 함수
function returnLast(arr) {
  return arr.at(-1);
}
let invoiceRef = "myinvoice01";

console.log(returnLast(invoiceRef)); // '1'

invoiceRef = "myinvoice02";

console.log(returnLast(invoiceRef)); // '2'
```

### 메서드 비교하기

여기서 `String`의 끝에서 두 번째 문자를 선택하는 다양한 방법을 비교하겠습니다. 아래의 모든 방법이 유효하며, 싱대적으로 `at()`의 간결함과 가독성이 돋보입니다.

```js
const myString = "Every green bus drives fast.";

// length 속성과 charAt() 메서드 사용하기
const lengthWay = myString.charAt(myString.length - 2);
console.log(lengthWay); // 't'

// slice() 메서드 사용하기
const sliceWay = myString.slice(-2, -1);
console.log(sliceWay); // 't'

// at() 메서드 사용하기
const atWay = myString.at(-2);
console.log(atWay); // 't'
```

명세
--

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

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

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

같이 보기
-----

* Polyfill of `String.prototype.at` in `core-js`
* A polyfill for the at() method.
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.charCodeAt()` (en-US)
* `String.prototype.codePointAt()` (en-US)
* `String.prototype.split()`


String.prototype.trimEnd() - JavaScript

String.prototype.trimEnd()
==========================

**`trimEnd()`** 메서드는 문자열 끝부분의 공백을 제거합니다.
 또 해당 메서드는 `trimRight()` 라는 별칭으로 호출이 가능합니다.

시도해보기
-----

구문
--

```js
trimEnd();

trimRight();
```

### 반환값

`str` 에서 (오른쪽)끝 공백이 제거된 새 문자열을 반환합니다.
 `str` 에 공백이 없을시에도 에러가 발생하지 않고 여전히 새 문자열(본질적으로 `str` 의 복사본)이 반환됩니다.

### 별칭

`String.prototype.padEnd` 표준 메서드 이름과 같은 함수의 일관성을 위해서 `trimEnd` 가 되었습니다. 그러나,
 웹 호환성을 위해서 `trimEnd` 는 `trimRight` 이라는 별칭을 가집니다. 일부 엔진에서 이것은 다음 예시를 의미합니다.

```js
String.prototype.trimRight.name === "trimEnd";
```

예제
--

### trimEnd() 사용

다음 예제는 `' foo'` 문자열을 표시합니다.

```js
var str = " foo ";

console.log(str.length); // 8

str = str.trimEnd();
console.log(str.length); // 6
console.log(str); // ' foo'
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.trimEnd` 의 폴리필은 여기를 `core-js` 참고하세요.
* `String.prototype.trim()`
* `String.prototype.trimStart()`


String.prototype.slice() - JavaScript

String.prototype.slice()
========================

**`slice()`** 메소드는 문자열의 일부를 추출하면서 새로운 문자열을 반환합니다.

시도해보기
-----

문법
--

```js
str.slice(beginIndex[, endIndex])
```

### 매개변수

`beginIndex`
추출 시작점인 0부터 시작하는 인덱스입니다. 만약 음수라면, beginIndex는 `strLength(문자열 길이) + beginIndex`로 취급됩니다. (예를 들어 `beginIndex`가 -3이면 시작점은 `strLength - 3`).
만약 `beginIndex`가 `strLength` 보다 크거나 같은 경우, `slice()`는 빈 문자열을 반환합니다.
`endIndex`Optional
0부터 시작하는 추출 종료점 인덱스로 그 직전까지 추출됩니다. 인덱스 위치의 문자는 추출에 포함되지 않습니다.
만약 `endIndex`가 생략된다면, `slice()`는 문자열 마지막까지 추출합니다. 만약 음수라면, endIndex는 `strLength(문자열 길이) + endIndex` 로 취급됩니다(예를 들어 `endIndex`가 -3이면 종료점은 `strLength - 3`).
### 반환 값

문자열의 추출된 부분을 담는 새로운 문자열이 반환됩니다.

설명
--

`slice()`는 문자열로부터 텍스트를 추출하고 새 문자열을 반환합니다. 문자열의 변경은 다른 문자열에 영향을 미치지 않습니다.

`slice()`는 `endIndex`를 포함하지 않고 추출합니다. `str.slice(1, 4)`는 두 번째 문자부터 네 번째 문자까지 추출합니다 (1, 2, 3 인덱스 문자).

`str.slice(2, -1)`는 세 번째 문자부터 문자열의 마지막에서 두 번째 문자까지 추출합니다.

예시
--

### `slice()`를 사용하여 새 문자열 생성하기

아래 예시는 새 문자열을 생성하기 위해 `slice()`를 사용합니다.

```js
var str1 = "The morning is upon us.", // the length of str1 is 23.
  str2 = str1.slice(1, 8),
  str3 = str1.slice(4, -2),
  str4 = str1.slice(12),
  str5 = str1.slice(30);
console.log(str2); // OUTPUT: he morn
console.log(str3); // OUTPUT: morning is upon u
console.log(str4); // OUTPUT: is upon us.
console.log(str5); // OUTPUT: ""
```

### 음수 인덱스로 `slice()` 사용하기

아래 예시는 `slice()`에 음수 인덱스를 사용합니다.

```js
var str = "The morning is upon us.";
str.slice(-3); // returns 'us.'
str.slice(-3, -1); // returns 'us'
str.slice(0, -1); // returns 'The morning is upon us'
```

아래의 예시는 시작 인덱스를 찾기 위해 문자열의 끝에서부터 역방향으로 `11`개를 세고 끝 인덱스를 찾기 위해 문자열의 시작에서부터 정방향으로 `16`개를 셉니다.

```js
console.log(str.slice(-11, 16)); // => "is u";
```

아래에서는 시작 인덱스를 찾기 위해 문자열의 처음부터 정방향으로 `11`개를 세고 끝 인덱스를 찾기 위해 끝에서부터 `7`개를 셉니다.

```js
console.log(str.slice(11, -7)); // => "is u";
```

이 인수는 끝에서부터 5로 역순으로 계산하여 시작 인덱스를 찾은 다음 끝에서부터 1을 거쳐 끝 인덱스를 찾습니다.

```js
console.log(str.slice(-5, -1)); // => "n us";
```

명세서
---

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

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

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

See also
--------

* `String.prototype.substr()`
* `String.prototype.substring()`
* `Array.prototype.slice()`


String.prototype.concat() - JavaScript

String.prototype.concat()
=========================

**`concat()`** 메서드는 매개변수로 전달된 모든 문자열을 호출 문자열에 붙인 새로운 문자열을 반환합니다.

시도해보기
-----

구문
--

```js
str.concat(string2, string3[, ..., stringN])
```

### 매개변수

`string2...stringN`

합칠 문자열.

### 반환값

주어진 문자열을 모두 붙인 새로운 문자열.

설명
--

`concat()` 함수는 호출 문자열에 문자열 인수를 이어 붙인 결과를 반환합니다. 원본 문자열과 결과 문자열의 변형은 서로에게 영향을 미치지 않습니다. 인수가 문자열이 아니면 계산 전에 문자열로 변환합니다.

예제
--

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

아래 예제에서는 문자열을 결합하여 새로운 문자열을 만듭니다.

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

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

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

성능
--

`concat()` 메서드보다 할당 연산자 (en-US) (`+`, `+=`)를 사용하는게 더 좋습니다. 성능 테스트 결과에 따르면 할당 연산자의 속도가 몇 배 빠릅니다.

명세
--

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

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

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

관련문서
----

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


String.prototype.toLocaleLowerCase() - JavaScript

String.prototype.toLocaleLowerCase()
====================================

**`toLocaleLowerCase()`** 메서드는 어떤 지역 특정 대/소문자 매핑에 따른 소문자로 변환된 문자열 값을 반환합니다.

시도해보기
-----

구문
--

```js
toLocaleLowerCase()
toLocaleLowerCase(locales)
```

### 매개변수

`locales` Optional

BCP 47 언어 태그가 있는 문자열 또는 이런 문자열을 가진 배열. 어떤 지역 특정 대/소문자 매핑에 따른 소문자로 변환하는데 사용된 지역을 나타냅니다. 일반 양식과 `locales` 인수의 설명에 대해서 Locale identification and negotiation (en-US)를 참조하세요.

### 반환 값

어떤 지역 특정 대/소문자 매핑에 따른 소문자로 변환된 문자열을 나타낸 새 문자열.

### 예외

* `locale` 인수가 올바른 언어 태그가 아닌 경우 `RangeError` ("잘못된 언어 태그: xx\_yy")가 발생합니다.
* 배열 요소가 문자열 유형이 아닌 경우 `TypeError` ("지역 인수에 있는 잘못된 요소")가 발생합니다.
설명
--

`theLocaleLowerCase()` 메서드는 지역 특정 대/소문자 매핑에 따른 소문자로 변환된 문자열 값을 반환합니다. `toLocaleUpperCase()`는 문자열 자체 값에 영향을 미치지 않습니다. 대부분의 경우, `toLowerCase()`와 같은 결과를 제공하지만 터키와 같은 일부 지역에서는 대/소문자 매핑이 유니코드의 기존 대/소문자 매핑을 따르지 않아 다른 결과가 있을 수 있습니다.

예제
--

### toLocaleLowerCase() 사용

```js
"ALPHABET".toLocaleLowerCase(); // 'alphabet'

"\u0130".toLocaleLowerCase("tr") === "i"; // true
"\u0130".toLocaleLowerCase("en-US") === "i"; // false

const locales = ["tr", "TR", "tr-TR", "tr-u-co-search", "tr-x-turkish"];
"\u0130".toLocaleLowerCase(locales) === "i"; // true
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.tolocalelowercase |
| ECMAScript Internationalization API Specification # sup-string.prototype.tolocalelowercase |

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

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

같이 보기
-----

* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`
* `String.prototype.toUpperCase()`


String.prototype.trim() - JavaScript

String.prototype.trim()
=======================

**`trim()`** 메서드는 문자열 양 끝의 공백을 제거하고 원본 문자열을 수정하지 않고 새로운 문자열을 반환합니다. 여기서 말하는 공백이란 모든 공백문자(space, tab, NBSP 등)와 모든 개행문자(LF, CR 등)를 의미합니다.

한쪽 끝의 공백만 제거한 새로운 문자열을 반환하려면 `trimStart()` 또는 `trimEnd()`를 사용하세요.

시도해보기
-----

구문
--

```js
trim()
```

### 반환 값

시작과 끝에서 공백이 제거된 `str`을 나타내는 새로운 문자열입니다. 공백은 white space (en-US) 문자와 line terminators (en-US)로 정의됩니다.

한쪽 끝의 공백만 제거한 문자열을 반환하시려면 `trimStart()` 또는 `trimEnd()` 메서드를 사용하세요.

예제
--

### `trim()` 사용

아래 예제는 `str` 양 끝의 공백을 제거합니다.

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

명세
--

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

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

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

같이 보기
-----

* `String.prototype.trimStart()`
* `String.prototype.trimEnd()`


String.prototype.substr() - JavaScript

String.prototype.substr()
=========================

**경고:** 경고: 엄밀히 말해서 `String.prototype.substr()` 메서드가 더 이상 사용되지 않는, 즉 "웹 표준에서 제거된" 건 아닙니다. 그러나 `substr()`이 포함된 ECMA-262 표준의 부록 B는 다음과 같이 명시하고 있습니다.> … 본 부록이 포함한 모든 언어 기능과 행동은 하나 이상의 바람직하지 않은 특징을 갖고 있으며 사용처가 없어질 경우 명세에서 제거될 것입니다. …

>
> … 프로그래머는 새로운 ECMAScript 코드를 작성할 때 본 부록이 포함한 기능을 사용하거나 존재함을 가정해선 안됩니다. …
>
>
>

**`substr()`** 메서드는 문자열에서 특정 위치에서 시작하여 특정 문자 수 만큼의 문자들을 반환합니다.

시도해보기
-----

구문
--

```js
str.substr(start[, length])
```

### 매개변수

`start`

추출하고자 하는 문자들의 시작위치입니다. 만약 음수가 주어진다면, `문자열총길이 + start`의 값으로 취급합니다. 예를 들면, `start`에 -3을 설정하면, 자동적으로 `문자열총길이 - 3`으로 설정하게 됩니다.

`length`

옵션값. 추출할 문자들의 총 숫자.

설명
--

`start` 는 문자 인덱스입니다. 문자열에서 첫 번째 문자의 인덱스는 0이며, 마지막 문자의 인덱스는 문자열 전체 길이에서 1을 뺀 값입니다. `substr()` 는 `start` 에서 문자들을 추출을 시작하여 `length` 만큼 문자들을 수집합니다.

만약 `start` 값이 양수이고 문자열 전체 길이보다 크거가 같을 경우, `substr()`은 빈 문자열을 반환합니다.

만약 `start`가 음수이면, `substr()`은 문자열 끝에서 `start` 숫자만큼 뺀 곳에서 시작하게 됩니다. 만약 `start`가 음수이고 절대값이 문자열 전체보다 크다면, `substr()`은 문자열의 0 인덱스부터 시작하게 됩니다. (주의: `start`의 음수값은 Microsoft JScript에서는 위의 설명과 같이 동작하지 않습니다.)

만약 `length`가 0 혹은 음수이면, `substr()`은 빈 문자열을 반환합니다. 만약 `length`가 생략되면, `substr()`은 문자열의 끝까지 추출하여 반환합니다.

예제
--

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

```js
var str = "abcdefghij";

console.log("(1, 2): " + str.substr(1, 2)); // '(1, 2): bc'
console.log("(-3, 2): " + str.substr(-3, 2)); // '(-3, 2): hi'
console.log("(-3): " + str.substr(-3)); // '(-3): hij'
console.log("(1): " + str.substr(1)); // '(1): bcdefghij'
console.log("(-20, 2): " + str.substr(-20, 2)); // '(-20, 2): ab'
console.log("(20, 2): " + str.substr(20, 2)); // '(20, 2): '
```

폴리필
---

Microsoft의 JScript는 시작 인덱스에서 음수값을 지원하지 않습니다. 만약 여러분이 이렇게 동작하길 원한다면, 아래 코드를 사용하여 해결할 수 있습니다:

```js
// only run when the substr() function is broken
if ("ab".substr(-1) != "b") {
  /\*\*
 \* Get the substring of a string
 \* @param {integer} start where to start the substring
 \* @param {integer} length how many characters to return
 \* @return {string}
 \*/
  String.prototype.substr = (function (substr) {
    return function (start, length) {
      // call the original method
      return substr.call(
        this,
        // did we get a negative start, calculate how much it is from the beginning of the string
        // adjust the start parameter for negative value
        start < 0 ? this.length + start : start,
        length,
      );
    };
  })(String.prototype.substr);
}
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.slice()`
* `String.prototype.substring()`


String.raw() - JavaScript

String.raw()
============

`String.raw()`메서드는 템플릿 리터럴의 태그 함수입니다.
 이는 Pyhon의 `r` 접두사 또는 C#의 문자열 리터럴의 `@` 접두사와 유사합니다.(그러나 동일 하지는 않습니다. 이 문제에 관해서는 여기 이슈를 참조하십시오.)
 이 메서드는 템플릿 리터럴의 윈시 문자열을 가져오는데 사용됩니다. 즉, 대체(예: `${foo}`)는 처리되지만 이스케이프(예: `\n`)는 처리되지 않습니다.

시도해보기
-----

구문
--

```js
String.raw(callSite, ...substitutions);

String.raw`templateString`;
```

### 매개변수

`callSite`

정해진 형식의 템플릿 호출 개체 예: `{ raw: ['foo', 'bar', 'baz'] }`.

`...substitutions`

대체값을 포함합니다.

`templateString`

템플릿 리터럴, 선택사항으로 대체를 포함 예:(`${...}`).

### 반환값

주어진 템플릿 리터럴의 원시 문자열 형식.

### 예외

`TypeError`

첫번째 인자의 객체의 포맷이 올바르지 않은 경우 `TypeError`예외가 발생(throw)한다.

설명
--

`String.raw()`의 경우 보통 템플릿 리터럴과 많이 사용하고, 첫번째 구문의 경우 잘 사용되지 않습니다.
 왜냐하면 JavaScript 엔진이 당신을 위해서 자동으로 적절한 인수로 호출해주기 때문입니다. ( 다른 태그 메서드 들과 마찬가지로).

`String.raw()`은 템플릿 리터럴의 유일한 내장 함수입니다. 기본 템플릿 기능과 동일하게 작동하며 연결을 수행합니다. JavaScript 코드를 사용하여 다시 구현할 수도 있습니다.

예시
--

### String.raw() 사용

```js
String.raw`Hi\n${2 + 3}!`;
// 'Hi\\n5!', the character after 'Hi'
// is not a newline character,
// '\' and 'n' are two characters.

String.raw`Hi\u000A!`;
// 'Hi\\u000A!', same here, this time we will get the
// \, u, 0, 0, 0, A, 6 characters.
// All kinds of escape characters will be ineffective
// and backslashes will be present in the output string.
// You can confirm this by checking the .length property
// of the string.

let name = "Bob";
String.raw`Hi\n${name}!`;
// 'Hi\\nBob!', substitutions are processed.

// Normally you would not call String.raw() as a function,
// but to simulate `foo${2 + 3}bar${'Java' + 'Script'}baz` you can do:
String.raw(
  {
    raw: ["foo", "bar", "baz"],
  },
  2 + 3,
  "Java" + "Script",
); // 'foo5barJavaScriptbaz'
// Notice the first argument is an object with a 'raw' property,
// whose value is an iterable representing the separated strings
// in the template literal.
// The rest of the arguments are the substitutions.

// The first argument’s 'raw' value can be any iterable, even a string!
// For example, 'test' is treated as ['t', 'e', 's', 't'].
// The following is equivalent to
// `t${0}e${1}s${2}t`:
String.raw({ raw: "test" }, 0, 1, 2); // 't0e1s2t'
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.raw |

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

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

같이 보기
-----

* `String.raw`의 폴리필은 여기를 참고`core-js`
* Template literals
* `String`
* Lexical grammar (en-US)


String.prototype.indexOf() - JavaScript

String.prototype.indexOf()
==========================

**`indexOf()`** 메서드는 호출한 `String` 객체에서 주어진 값과 일치하는 첫 번째 인덱스를 반환합니다. 일치하는 값이 없으면 -1을 반환합니다.

시도해보기
-----

**참고:** `Array`에서는 `Array.prototype.indexOf()` 메서드가 같은 역할을 합니다.

구문
--

```js
str.indexOf(searchValue[, fromIndex])
```

### 매개변수

`searchValue`

찾으려는 문자열. 아무 값도 주어지지 않으면 문자열 `"undefined"`를 찾으려는 문자열로 사용합니다.

`fromIndex` Optional

문자열에서 찾기 시작하는 위치를 나타내는 인덱스 값입니다. 어떤 정수값이라도 가능합니다. 기본값은 0이며, 문자열 전체를 대상으로 찾게 됩니다. 만약 `fromIndex` 값이 음의 정수이면 전체 문자열을 찾게 됩니다. 만약 `fromIndex >= str.length` 이면, 검색하지 않고 바로 -1을 반환합니다. `searchValue`가 공백 문자열이 아니라면, `str.length`를 반환합니다.

### 반환 값

`searchValue`의 첫 번째 등장 인덱스. 찾을 수 없으면 -1.

설명
--

문자열 내에 있는 문자들은 왼쪽에서 오른쪽 방향으로 순번이 매겨집니다. 제일 처음 문자는 0번째 순번(index)이며, `stringName` 문자열의 마지막 문자의 순번 `stringName.length -1` 입니다.

```js
"Blue Whale".indexOf("Blue"); // returns 0
"Blue Whale".indexOf("Blute"); // returns -1
"Blue Whale".indexOf("Whale", 0); // returns 5
"Blue Whale".indexOf("Whale", 5); // returns 5
"Blue Whale".indexOf("Whale", 7); // returns -1
"Blue Whale".indexOf(""); // returns 0
"Blue Whale".indexOf("", 9); // returns 9
"Blue Whale".indexOf("", 10); // returns 10
"Blue Whale".indexOf("", 11); // returns 10
```

`indexOf()` 메서드는 대소문자를 구분합니다. 예를 들면, 아래 예제는 일치하는 문자열이 없으므로 `-1`을 반환합니다.

```js
"Blue Whale".indexOf("blue"); // returns -1
```

### 존재 여부 확인

'0'을 평가했을 때 `true`가 아니고, -1을 평가했을 때 `false`가 아닌 것에 주의해야 합니다. 따라서, 임의의 문자열에 특정 문자열이 있는지를 확인하는 올바른 방법은 다음과 같습니다.

```js
"Blue Whale".indexOf("Blue") !== -1; // true
"Blue Whale".indexOf("Bloe") !== -1; // false
```

예제
--

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

아래 예제는 `"Brave new world"` 문자열의 위치를 확인하기 위해 `indexOf()`와 `lastIndexOf()` 를 사용하고 있습니다.

```js
var anyString = "Brave new world";

console.log(
  "The index of the first w from the beginning is " + anyString.indexOf("w"),
);
// 첫번째 w 문자 위치는 8
console.log(
  "The index of the first w from the end is " + anyString.lastIndexOf("w"),
);
// 마지막 w 문자 위치는 10

console.log(
  'The index of "new" from the beginning is ' + anyString.indexOf("new"),
);
// 첫번째 new 문자열 위치는 6
console.log(
  'The index of "new" from the end is ' + anyString.lastIndexOf("new"),
);
// 마지막 new 문자열 위치는 6
```

### `indexOf()`와 대소문자 구분

아래 예제에서는 2개의 문자열 변수를 정의하고 있습니다. 이 변수들 내에 있는 문자열들은 모두 같지만 두 번째 변수에 포함되어 있는 문자열은 대문자를 포함하고 있습니다. 첫 번째 `console.log()` 메서드의 결과값은 19입니다. 하지만, 두 번째 `console.log()` 메서드의 결과값은 `-1`입니다. 왜냐하면, indexOf() 메서드는 대소문자를 구분하기 때문에 `myCapString`에서 "`cheddar`" 문자열을 찾을 수 없기 때문입니다.

```js
var myString = "brie, pepper jack, cheddar";
var myCapString = "Brie, Pepper Jack, Cheddar";

console.log('myString.indexOf("cheddar") is ' + myString.indexOf("cheddar"));
// 로그에 19를 출력합니다.
console.log(
  'myCapString.indexOf("cheddar") is ' + myCapString.indexOf("cheddar"),
);
// 로그에 -1을 출력합니다.
```

### `indexOf()`를 사용하여 문자열 내의 특정 문자 숫자 세기

아래 예제는 `str` 문자열에서 `e` 문자의 총 숫자를 확인하는 프로그램입니다:

```js
var str = "To be, or not to be, that is the question.";
var count = 0;
var pos = str.indexOf("e"); //pos는 4의 값을 가집니다.

while (pos !== -1) {
  count++;
  pos = str.indexOf("e", pos + 1); // 첫 번째 e 이후의 인덱스부터 e를 찾습니다.
}

console.log(count); // 로그에 4를 출력합니다.
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.charAt()`
* `String.prototype.lastIndexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`


String.prototype.padStart() - JavaScript

String.prototype.padStart()
===========================

**`padStart()`** 메서드는 현재 문자열의 시작을 다른 문자열로 채워, 주어진 길이를 만족하는 새로운 문자열을 반환합니다. 채워넣기는 대상 문자열의 시작(좌측)부터 적용됩니다.

시도해보기
-----

구문
--

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

### 매개변수

`targetLength`

목표 문자열 길이. 현재 문자열의 길이보다 작다면 채워넣지 않고 그대로 반환.

`padString` Optional

현재 문자열에 채워넣을 다른 문자열. 문자열이 너무 길어 목표 문자열 길이를 초과한다면 좌측 일부를 잘라서 넣음. 기본값은 " ". (U+0020)

### 반환값

시작점부터 주어진 문자열로 채워 목표 길이를 만족하는 `String`.

예시
--

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

폴리필
---

다른 모든 코드 이전에 아래 코드를 포함하면 지원하지 않는 플랫폼에서도 `String.prototype.padStart()` 메서드를 사용할 수 있습니다.

```js
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
// https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global\_Objects/String/padStart
if (!String.prototype.padStart) {
  String.prototype.padStart = function padStart(targetLength, padString) {
    targetLength = targetLength >> 0; //truncate if number or convert non-number to 0;
    padString = String(typeof padString !== "undefined" ? padString : " ");
    if (this.length > targetLength) {
      return String(this);
    } else {
      targetLength = targetLength - this.length;
      if (targetLength > padString.length) {
        padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
      }
      return padString.slice(0, targetLength) + String(this);
    }
  };
}
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.padEnd()`


String.fromCharCode() - JavaScript

String.fromCharCode()
=====================

**`String.fromCharCode()`** 메서드는 UTF-16 코드 유닛의 시퀀스로부터 문자열을 생성해 반환합니다.

시도해보기
-----

구문
--

```js
String.fromCharCode(num1[, ...[, numN]])
```

### 매개변수

`num1, ..., numN`

UTF-16 코드 유닛인 숫자 뭉치. 가능한 값의 범위는 0부터 65535(0xFFFF)까지입니다. 0xFFFF를 초과하는 값은 잘립니다. 유효성 검사는 하지 않습니다.

### 반환 값

주어진 UTF-16 코드 유닛 N개로 이루어진 문자열.

설명
--

이 메서드는 `String` 객체가 아닌 문자열을 반환합니다.

`fromCharCode()`는 `String`의 정적 메서드이기 때문에 `String.fromCharCode()`로 사용해야 합니다.

예제
--

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

다음 예제는 문자열 `"ABC"`를 반환합니다..

```js
String.fromCharCode(65, 66, 67); // "ABC"
String.fromCharCode(0x2014); // "—"
String.fromCharCode(0x12014); // 숫자 '1'은 무시해서 "—"
```

더 큰 값과 사용하기
-----------

초기 JavaScript 표준화 과정에서 예상했던 것처럼, 대부분의 흔한 유니코드 값을 16비트 숫자로 표현할 수 있고, `fromCharCode()`가 많은 흔한 값에서 하나의 문자를 반환할 수 있지만, **모든** 유효한 유니코드 값(최대 21비트)을 처리하려면 `fromCharCode()`만으로는 부족합니다. 높은 코드 포인트의 문자는 써로게이트 값 두 개를 합쳐 하나의 문자를 표현하므로,`String.fromCodePoint()` (en-US)(ES2015 표준) 메서드는 그러한 쌍을 높은 값의 문자로 변환할 수 있습니다.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.fromcharcode |

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

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

같이 보기
-----

* `String.fromCodePoint()` (en-US)
* `String.prototype.charAt()`
* `String.prototype.charCodeAt()` (en-US)
* `String.prototype.codePointAt()` (en-US)


String.prototype.endsWith() - JavaScript

String.prototype.endsWith()
===========================

The **`endsWith()`** 메서드를 사용하여 어떤 문자열에서 특정 문자열로 끝나는지를 확인할 수 있으며, 그 결과를 `true` 혹은 `false`로 반환한다.

문법
--

```js
str.endsWith(searchString[, length])
```

### 파라미터들

`searchString`

이 문자열의 끝이 특정 문자열로 끝나는지를 찾기 원하는 문자열입니다.

`length`

옵션입니다. 찾고자 하는 문자열의 길이값이며, 기본값은 문자열 전체 길이입니다. 문자열의 길이값은 문자열 전체 길이 안에서만 존재하여야 합니다.

### 반환 값

문자열의 끝이 주어진 문자열로 끝나면 **`true`**, 그렇지 않다면 **`false`**

설명
--

여러분은 이 메서드를 사용하여 어떤 문자열이 특정 문자열로 끝나는지를 확인할 수 있습니다.

예제
--

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

```js
var str = "To be, or not to be, that is the question.";

console.log(str.endsWith("question.")); // true
console.log(str.endsWith("to be")); // false
console.log(str.endsWith("to be", 19)); // true
```

Polyfill
--------

이 메서드는 ECMAScript 6 규격에 포함되었습니다만 아직까지는 모든 JavaScrpt가 이 기능을 지원하고 있지는 않습니다. 하지만 여러분은 `String.prototype.endsWith()` 메서드를 다음과 같이 쉽게 polyfill 할 수 있습니다:

```js
if (!String.prototype.endsWith) {
  String.prototype.endsWith = function (searchString, position) {
    var subjectString = this.toString();
    if (
      typeof position !== "number" ||
      !isFinite(position) ||
      Math.floor(position) !== position ||
      position > subjectString.length
    ) {
      position = subjectString.length;
    }
    position -= searchString.length;
    var lastIndex = subjectString.indexOf(searchString, position);
    return lastIndex !== -1 && lastIndex === position;
  };
}
```

명세
--

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

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

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

관련문서
----

* `String.prototype.startsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`


String.prototype.toLowerCase() - JavaScript

String.prototype.toLowerCase()
==============================

**`toLowerCase()`** 메서드는 문자열을 소문자로 변환해 반환합니다.시도해보기
-----

구문
--

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

### 반환값

호출 문자열을 소문자로 변환한 새로운 문자열

설명
--

`toLowerCase()` 메서드는 호출 문자열을 소문자로 변환해 반환합니다. `toLowerCase()` 는 원래의 `str`에 영향을 주지 않습니다.

예제
--

### `toLowerCase()`

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

명세
--

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

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

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

참조
--

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toUpperCase()`


String.prototype.lastIndexOf() - JavaScript

String.prototype.lastIndexOf()
==============================

**`lastIndexOf()`** 메서드는 주어진 값과 일치하는 부분을 `fromIndex`로부터 역순으로 탐색하여, 최초로 마주치는 인덱스를 반환합니다. 일치하는 부분을 찾을 수 없으면 `-1`을 반환합니다.

시도해보기
-----

구문
--

```js
str.lastIndexOf(searchValue[, fromIndex])
```

### 매개변수

`searchValue`

탐색할 문자열. 빈 값을 제공할 경우 `fromIndex`를 반환합니다.

`fromIndex` Optional

탐색의 시작점으로 사용할 인덱스. 기본값은 `+Infinity`입니다. `fromIndex >= str.length`인 경우 모든 문자열을 탐색합니다. `fromIndex < 0`인 경우엔 `0`을 지정한 것과 동일합니다.

### 반환 값

문자열 내에서 searchValue가 마지막으로 등장하는 인덱스. 등장하지 않으면 `-1`.

설명
--

문자열의 문자는 왼쪽에서 오른쪽으로 인덱스를 매깁니다. 첫 번째 문자의 인덱스는 `0`이며, 마지막 문자의 인덱스는 `str.length -1`입니다.

```js
"canal".lastIndexOf("a"); // 3 반환
"canal".lastIndexOf("a", 2); // 1 반환
"canal".lastIndexOf("a", 0); // -1 반환
"canal".lastIndexOf("x"); // -1 반환
"canal".lastIndexOf("c", -5); // 0 반환
"canal".lastIndexOf("c", 0); // 0 반환
"canal".lastIndexOf(""); // 5 반환
"canal".lastIndexOf("", 2); // 2 반환
```

**참고:** `'abab'.lastIndexOf('ab', 2)`는 0이 아니고 2를 반환합니다. `fromIndex`는 탐색의 시작점만 제한하기 때문입니다.

### 대소문자 구분

`lastIndexOf()` 메서드는 대소문자를 구분합니다. 예를 들어, 아래 예제는 `-1`을 반환합니다.

```js
"Blue Whale, Killer Whale".lastIndexOf("blue"); // -1 반환
```

예제
--

### `indexOf()`와 `lastIndexOf()` 사용하기

아래 예제는 문자열 `"Brave new world"` 내에서 특정 값의 위치를 확인하기 위해 `indexOf()`와 `lastIndexOf()`를 사용합니다.

```js
let anyString = "Brave new world";

console.log("시작점으로부터 처음 만나는 w의 위치는 " + anyString.indexOf("w"));
// logs 8
console.log(
  "끝점으로부터 처음 만나는 w의 위치는 " + anyString.lastIndexOf("w"),
);
// logs 10
console.log(
  '시작점으로부터 처음 만나는 "new"의 위치는 ' + anyString.indexOf("new"),
);
// logs 6
console.log(
  '끝점으로부터 처음 만나는 "new"의 위치는 ' + anyString.lastIndexOf("new"),
);
// logs 6
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.charAt()`
* `String.prototype.indexOf()`
* `String.prototype.split()`
* `Array.prototype.indexOf()`
* `Array.prototype.lastIndexOf()`


String.prototype.includes() - JavaScript

String.prototype.includes()
===========================

**`includes()`** 메서드는 하나의 문자열이 다른 문자열에 포함되어 있는지를 판별하고, 결과를 `true` 또는 `false` 로 반환합니다. 검색 시 대소문자를 구분합니다.

시도해보기
-----

구문
--

```js
includes(searchString)
includes(searchString, position)
```

### 매개변수

`searchString`

이 문자열에서 찾을 다른 문자열. 정규표현식이 올 수 없습니다.

`position` Optional

`searchString`을 찾기 시작할 위치. (기본값 `0`).

### 반환값

문자열을 찾아내면 **`true`** . 실패하면 **`false`** .

### 예외

`TypeError`

`searchString`이 정규식일 경우.

설명
--

이 메서드를 사용해 문자열 내에 찾고자 하는 다른 문자열이 있는지 확인할 수 있습니다.

### 대소문자 구분

`includes()` 메서드는 대소문자를 구별합니다. 예를 들어 아래 코드는 `false`를 반환합니다.

```js
"Blue Whale".includes("blue"); // returns false
```

아래와 같이 원본 문자열과 검색 문자열을 모두 소문자로 변환하여 이 제약 조건을 해결할 수 있습니다.

```js
"Blue Whale".toLowerCase().includes("blue"); // returns true
```

예제
--

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

```js
const str = "To be, or not to be, that is the question.";

console.log(str.includes("To be")); // true
console.log(str.includes("question")); // true
console.log(str.includes("nonexistent")); // false
console.log(str.includes("To be", 1)); // false
console.log(str.includes("TO BE")); // false
console.log(str.includes("")); // true
```

명세
--

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

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

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

같이 보기
-----

* `core-js`에서 `String.prototype.includes`의 폴리필
* `Array.prototype.includes()`
* `TypedArray.prototype.includes()` (en-US)
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`
* `String.prototype.startsWith()`
* `String.prototype.endsWith()`


String.length - JavaScript

String.length
=============

**`length`** 속성은 UTF-16 코드 유닛을 기준으로 문자열의 길이를 나타냅니다.

시도해보기
-----

설명
--

`length` 속성은 문자열 안의 코드 유닛 수를 반환합니다. JavaScript가 사용하는 문자열 형식인 UTF-16은 대부분의 일반적인 문자를 표현하기 위해 하나의 16비트 코드 유닛을 사용합니다. 반면, 덜 쓰이는 문자를 표현하기 위해 2개의 코드 유닛을 사용해야 할 때도 있으므로 문자열 내에 있는 문자들의 실제 총 숫자가 `length` 속성이 반환하는 숫자와 일치하지 않을 수 있습니다.

ECMAScript 2016 7판은 최대 길이를 `2^53 - 1`로 설정했습니다. 이전엔 명시된 최대 길이가 없었습니다.

빈 문자열은 `length`가 0입니다.

정적 속성 `String.length`는 1을 반환합니다.

예제
--

### 일반적인 사용법

```js
var x = "Mozilla";
var empty = "";

console.log("Mozilla는 코드 유닛 " + x.length + "개의 길이입니다.");
/\* "Mozilla는 코드 유닛 7개의 길이입니다." \*/

console.log("빈 문자열은 " + empty.length + "의 길이를 가집니다.");
/\* "빈 문자열은 0의 길이를 가집니다." \*/
```

명세
--

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

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

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

같이 보기
-----

* JavaScript `String.length` and Internationalizing Web Applications


String.prototype.startsWith() - JavaScript

String.prototype.startsWith()
=============================

**`startsWith()`** 메서드는 어떤 문자열이 특정 문자로 시작하는지 확인하여 결과를 `true` 혹은 `false`로 반환합니다.

시도해보기
-----

구문
--

```js
startsWith(searchString)
startsWith(searchString, position)
```

### 매개변수

`searchString`

문자열의 시작 지점에서 탐색할 문자열. 정규표현식이 올 수 없습니다.

`position` Optional

`searchString`을 탐색할 위치. 기본값은 `0`.

### 반환 값

대상 문자열이 주어진 문자로 시작하면 `true`, 아니면 `false`.

### 예외

`TypeError`

`searchString`이 정규식일 경우.

설명
--

`startsWith` 메소드로 어떤 문자열이 다른 문자열로 시작하는지 확인 할 수 있습니다. 대소문자를 구분합니다.

예제
--

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

```js
const str = "To be, or not to be, that is the question.";

console.log(str.startsWith("To be")); // true
console.log(str.startsWith("not to be")); // false
console.log(str.startsWith("not to be", 10)); // true
```

명세
--

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

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

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

같이 보기
-----

* `core-js`에서 `String.prototype.startsWith`의 폴리필
* `String.prototype.endsWith()`
* `String.prototype.includes()`
* `String.prototype.indexOf()`
* `String.prototype.lastIndexOf()`


String.prototype.padEnd() - JavaScript

String.prototype.padEnd()
=========================

**`padEnd()`** 메서드는 현재 문자열에 다른 문자열을 채워, 주어진 길이를 만족하는 새로운 문자열을 반환합니다. 채워넣기는 대상 문자열의 끝(우측)부터 적용됩니다.

시도해보기
-----

구문
--

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

### 매개변수

`targetLength`

목표 문자열 길이. 현재 문자열의 길이보다 작다면 채워넣지 않고 그대로 반환.

`padString` Optional

현재 문자열에 채워넣을 다른 문자열. 문자열이 너무 길어 목표 문자열 길이를 초과한다면 좌측 일부를 잘라서 넣음. 기본값은 " ". (U+0020)

### 반환값

끝부터 주어진 문자열로 채워 목표 길이를 만족하는 `String`

예시
--

```js
"abc".padEnd(10); // "abc "
"abc".padEnd(10, "foo"); // "abcfoofoof"
"abc".padEnd(6, "123456"); // "abc123"
"abc".padEnd(1); // "abc"
```

폴리필
---

다른 모든 코드 이전에 아래 코드를 포함하면 지원하지 않는 플랫폼에서도 `String.prototype.padStart()` 메서드를 사용할 수 있습니다.

```js
// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
// https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global\_Objects/String/padEnd
if (!String.prototype.padEnd) {
  String.prototype.padEnd = function padEnd(targetLength, padString) {
    targetLength = targetLength >> 0; //floor if number or convert non-number to 0;
    padString = String(typeof padString !== "undefined" ? padString : " ");
    if (this.length > targetLength) {
      return String(this);
    } else {
      targetLength = targetLength - this.length;
      if (targetLength > padString.length) {
        padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
      }
      return String(this) + padString.slice(0, targetLength);
    }
  };
}
```

명세
--

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

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

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

See also
--------

* `String.prototype.padStart()`


String.prototype.localeCompare() - JavaScript

String.prototype.localeCompare()
================================

**`localeCompare()`** 메서드는 참조 문자열이 정렬 순으로 지정된 문자열 앞 혹은 뒤에 오는지 또는 동일한 문자열인지 나타내는 수치를 반환합니다.

시도해보기
-----

 새로운 `locales` 인수와 `options` 인수를 사용하면 정렬에 사용될 언어를 지정하고 함수의 동작을 사용자 정의할 수 있습니다.
 `locales`와 `options`의 인수를 무시하는 오래된 구현에서는 사용되는 locale과 정렬 순서는 완전히 구현에 의존합니다.

구문
--

```js
localeCompare(compareString);
localeCompare(compareString, locales);
localeCompare(compareString, locales, options);
```

### 매개변수

* `compareString`
    + `referenceStr`가 비교되는 문자열.
* `locales`와 `options`
    + 이러한 인수는 함수의 동작을 사용자 정의하여 응용 프로그램에서 포맷 규칙을 사용할 언어를 지정합니다.
     `"locales"`와 `"options"`의 인자를 무시하는 구현에서는 사용되는 로케일과 반환되는 문자열의 형식은
     완전히 구현에 의존합니다.
     매개변수의 상세 및 사용 방법은 `Intl.Collator()`
    constructor (en-US)를 참조하세요.
### 반환 값

`compareString` 전에 `referenceStr`가 위치하는 경우 **음수**, `compareString` 후에 `referenceStr`가 위치하는 경우 **양수**, 동등할 경우 `0`이 됩니다.

설명
--

`referenceStr`가 `compareString` 전 혹은 뒤에 오는지 또는 동등한지를 나타내는 정수를 반환합니다.

* `compareString` 전에 `referenceStr`이 오면 음수
* `compareString` 뒤에 `referenceStr`이 오면 양수
* 동등한 경우 `0` 을 반환합니다.

>
> **주의:** `-1` 또는 `1`의 정확한 반환 값에 의존하지 마세요.
>
>
>
>  음의 정수와 양의 정수의 결과는 브라우저마다(브라우저 버전에 따라서도) 다릅니다.이는 W3C 사양에서는 음의 값과 양의 값만 필요하기 때문입니다.
>  브라우저에 따라서는, `-2`나 `2`를 반환하거나, 그 외의 음의 값이나 양의 값을 반환할 수도 있습니다.
>
>
>
>

성능
--

 큰 배열의 정렬과 같이 대량의 문자열을 비교하는 경우, `Intl.Collator` (en-US) 객체를 작성하고
 해당 `compare` (en-US) 프로퍼티가 제공하는 함수를 사용하는 것이 좋습니다.

예시
--

### `localeCompare()` 사용

```js
// "a"는 "c" 전에 위치하므로 음수 값을 반환
"a".localeCompare("c"); // -2 혹은 -1 (또는 다른 음수 값)

// 알파벳 순으로 단어 "check"는 "against"보다 뒤에 위치하므로 양수 값을 반환
"check".localeCompare("against"); // 2 혹은 1 (또는 다른 양수 값)

// "a"와 "a"는 서로 동등하므로 중립 값 0을 반환
"a".localeCompare("a"); // 0
```

### 배열 정렬

`localeCompare()`을 사용해 대소문자를 구분하지 않는 배열 정렬을 할 수 있습니다.

```js
let items = ["réservé", "Premier", "Cliché", "communiqué", "café", "Adieu"];
items.sort((a, b) => a.localeCompare(b, "fr", { ignorePunctuation: true }));
// ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé']
```

### 확장인수 브라우저 지원 확인

`locales`와 `options` 인자는 일부 브라우저에서 아직 지원되지 않습니다.

구현이 지원되는지 확인하려면 `"i"` 인수(잘못된 언어(illegal language) 태그가 제외되는 요건)을 사용해 `RangeError` 예외를 찾습니다.

```js
function localeCompareSupportsLocales() {
  try {
    "foo".localeCompare("bar", "i");
  } catch (e) {
    return e.name === "RangeError";
  }
  return false;
}
```

### `locales` 사용

`localeCompare()` 결과는 언어에 따라 달라집니다.
 응용 프로그램의 사용자 인터페이스에서 사용되는 언어의 정렬 순서를 얻으려면 반드시 `locales` 인자를 사용하여 해당 언어(및 폴백 언어의 일부)를 지정하세요.

```js
console.log("ä".localeCompare("z", "de")); // 음수: 독일어는 ä가 z 전에 위치
console.log("ä".localeCompare("z", "sv")); // 양수: 스웨덴어는 ä가 z 뒤에 위치
```

### `options` 사용

`localeCompare()`이 제공하는 결과는 `options` 인자를 사용해 사용자 정의할 수 있습니다.

```js
// 독일어에선 ä는 a를 기본 문자(base letter)로 가집니다.
console.log("ä".localeCompare("a", "de", { sensitivity: "base" })); // 0

// 스웨덴어에선 ä와 a는 별도의 기본 문자입니다.
console.log("ä".localeCompare("a", "sv", { sensitivity: "base" })); // 양수
```

### 숫자 정렬

```js
// 기본적으로 "2" > "10"
console.log("2".localeCompare("10")); // 1

// numeric 옵션 사용
console.log("2".localeCompare("10", undefined, { numeric: true })); // -1

// locales tag 사용
console.log("2".localeCompare("10", "en-u-kn-true")); // -1
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-string.prototype.localecompare |
| ECMAScript Internationalization API Specification # sup-String.prototype.localeCompare |

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

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

같이 보기
-----

* `Intl.Collator` (en-US)


String.prototype.match() - JavaScript

String.prototype.match()
========================

**`match()`** 메서드는 문자열이 정규식과 매치되는 부분을 검색합니다.

문법
--

```js
str.match(regexp);
```

### 매개변수

`regexp`

정규식 개체입니다. RegExp가 아닌 객체 obj가 전달되면, `new RegExp(obj)`를 사용하여 암묵적으로 `RegExp`로 변환됩니다. 매개변수를 전달하지 않고 match()를 사용하면, 빈 문자열:[""]이 있는 `Array`가 반환됩니다.

### 결과 값

문자열이 정규식과 일치하면, 일치하는 전체 문자열을 첫 번째 요소로 포함하는 `Array`를 반환한 다음 괄호 안에 캡처된 결과가 옵니다. 일치하는 것이 없으면 `null`이 반환됩니다.

설명
--

정규식에 `g` 플래그가 포함되어있지 않으면, `str.match()` 는 `RegExp.exec()` (en-US)와 같은 결과를 반환합니다. 반환된 `Array`는 원래 문자열의 값을 가지는 `input` 속성을 포함합니다. 그리고 문자열에서 제로 베이스의 인덱스를 나타내는 `index` 속성 또한 포함합니다.

정규식에 `g` 플래그가 포함되어 있으면, 일치는 객체가 아닌 일치하는 하위 문자열을 포함하는 `Array`를 반환합니다. 캡처된 그룹은 반환되지 않습니다. 일치하는 것이 없으면 null이 반환됩니다.

### 이것도 보세요: `RegExp` 메서드

* 문자열이 정규표현식`RegExp`과 일치하는지 여부를 알아야할 때, `RegExp.test()`을 이용해보세요.
* 일치하는 것 중 제일 첫번째 것만 알고싶을 때, `RegExp.exec()` (en-US)을 대신에 사용하고 싶을겁니다.
* 캡처 그룹을 알고 싶고 전역 플래그가 셋팅되어 있다면, `RegExp.exec()` (en-US)을 대신에 사용해야합니다.
예제
--

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

다음 예제에서는, `match()`를 사용하여 `'Chapter'` 라는 단어와 그에 이어지는 1 이상의 숫자, 그리고 그에 이어서 소숫점, 숫자 형태가 반복되는 문자열을 찾는다. 이 정규표현식은 i 플래그를 사용함으로써, 대소문자 구분 없이 찾고자 하는 문자열을 찾는다.

```js
var str = "For more information, see Chapter 3.4.5.1";
var re = /see (chapter \d+(\.\d)\*)/i;
var found = str.match(re);

console.log(found);

// logs [ 'see Chapter 3.4.5.1',
// 'Chapter 3.4.5.1',
// '.1',
// index: 22,
// input: 'For more information, see Chapter 3.4.5.1' ]

// 'see Chapter 3.4.5.1'는 완전한 매치 상태임.
// 'Chapter 3.4.5.1'는 '(chapter \d+(\.\d)\*)' 부분에 의해 발견된 것임.
// '.1' 는 '(\.\d)'를 통해 매치된 마지막 값임.
// 'index' 요소가 (22)라는 것은 0에서부터 셀 때 22번째 위치부터 완전 매치된 문자열이 나타남을 의미함.
// 'input' 요소는 입력된 원래 문자열을 나타냄.
```

### `match()`와 함께 글로벌(g) 및 대/소문자 무시(i) 플래그 사용하기

다음 예제는 글로벌(g) 및 대/소문자 무시(i) 플래그를 사용하여 `match()`를 사용하는 방법을 보여준다. A부터 E 까지의 모든 문자와 a부터 e 까지의 모든 문자가 배열의 각 원소를 구성하는 형태로 반환된다.

```js
var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var regexp = /[A-E]/gi;
var matches_array = str.match(regexp);

console.log(matches_array);
// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']
```

### 매개변수 없이 `match()` 사용하기

```js
var str = "Nothing will come of nothing.";

str.match(); // returns [""]
```

### 정규표현식이 아닌 객체를 매개변수로 사용하기

매개변수가 문자열이나 숫자(Number)이면, 해당 매개변수는 내부적으로 new RegExp(obj)를 사용하여 `RegExp`로 변환된다. 만약 매개변수가 플러스 기호와 이어지는 숫자형이라면, RegExp() 매서드는 플러스 기호를 무시한다.

```js
var str1 =
    "NaN means not a number. Infinity contains -Infinity and +Infinity in JavaScript.",
  str2 = "My grandfather is 65 years old and My grandmother is 63 years old.",
  str3 = "The contract was declared null and void.";
str1.match("number"); // "number"는 문자열임. ["number"]를 반환함.
str1.match(NaN); // NaN 타입은 숫자형임. ["NaN"]을 반환함.
str1.match(Infinity); // Infinity 타입은 숫자형임. ["Infinity"]를 반환함.
str1.match(+Infinity); // ["Infinity"]를 반환함.
str1.match(-Infinity); // ["-Infinity"]를 반환함.
str2.match(65); // ["65"]를 반환함
str2.match(+65); // 플러스 기호가 붙은 숫자형. ["65"]를 반환함.
str3.match(null); // ["null"]을 반환함.
```

명세
--

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

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

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

같이 보기
-----

* `RegExp`
* `RegExp.prototype.exec()` (en-US)
* `RegExp.prototype.test()`


String.prototype.toUpperCase() - JavaScript

String.prototype.toUpperCase()
==============================

**`toUpperCase()`** 메서드는 문자열을 대문자로 변환해 반환합니다.

시도해보기
-----

구문
--

```js
str.toUpperCase();
```

### 반환 값

대문자로 변환한 새로운 문자열.

### 예외

`TypeError`

`Function.prototype.call()` 등을 사용해 `null`이나 `undefined`에서 호출 시.

설명
--

`toUpperCase()` 메서드는 문자열을 대문자로 변환한 값을 반환합니다. JavaScript의 문자열은 불변하므로 원본 문자열에는 영향을 주지 않습니다.

예제
--

### 기본 사용법

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

### 문자열이 아닌 `this`의 문자열 변환

`toUpperCase()`의 `this`가 문자열이 아니고, `undefined`와 `null`도 아니면 자동으로 문자열로 변환합니다.

```js
const a = String.prototype.toUpperCase.call({
  toString: function toString() {
    return "abcdef";
  },
});

const b = String.prototype.toUpperCase.call(true);

// prints out 'ABCDEF TRUE'.
console.log(a, b);
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.toLocaleLowerCase()`
* `String.prototype.toLocaleUpperCase()`
* `String.prototype.toLowerCase()`


String.prototype.trimStart() - JavaScript

String.prototype.trimStart()
============================

**`trimStart()`** 메서드는 문자열 시작부분의 공백을 제거합니다. 또한 `trimLeft()`라는 별칭으로 호출이 가능합니다.

시도해보기
-----

구문
--

```js
trimStart();

trimLeft();
```

### 반환값

`str` 시작부분(왼쪽)에서 공백이 제거된 새 문자열을 반환합니다.
 `str` 에 공백이 없을시에도 에러가 발생하지 않고 여전히 새 문자열(본질적으로 `str` 의 복사본)이 반환됩니다.

### 별칭

`String.prototype.padStart` 표준 메서드 이름과 같은 함수의 일관성을 위해서 `trimStart` 가 되었습니다.
 그러나, 웹 호환성을 위해서 `trimLeft` 이라는 별칭을 가집니다. 일부 엔진에서 이것은 다음 예시를 의미합니다.

```js
String.prototype.trimLeft.name === "trimStart";
```

예제
--

### trimStart() 사용

다음 예제는 `'foo '` 문자열을 표시합니다.

```js
var str = " foo ";

console.log(str.length); // 8

str = str.trimStart();
console.log(str.length); // 5
console.log(str); // 'foo '
```

폴리필
---

```js
//https://github.com/FabioVergani/js-Polyfill\_String-trimStart

(function (w) {
  var String = w.String,
    Proto = String.prototype;

  (function (o, p) {
    if (p in o ? (o[p] ? false : true) : true) {
      var r = /^\s+/;
      o[p] =
        o.trimLeft ||
        function () {
          return this.replace(r, "");
        };
    }
  })(Proto, "trimStart");
})(window);

/\*
ES6:
(w=>{
 const String=w.String, Proto=String.prototype;

 ((o,p)=>{
 if(p in o?o[p]?false:true:true){
 const r=/^\s+/;
 o[p]=o.trimLeft||function(){
 return this.replace(r,'')
 }
 }
 })(Proto,'trimStart');

})(window);
\*/
```

명세서
---

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

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

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

같이 보기
-----

* `String.prototype.trimStart` 의 폴리필은 `core-js`를 참고하세요.
* `String.prototype.trim()`
* `String.prototype.trimEnd()`


String.prototype.repeat() - JavaScript

String.prototype.repeat()
=========================

**`repeat()`** 메서드는 문자열을 주어진 횟수만큼 반복해 붙인 새로운 문자열을 반환합니다.

구문
--

```js
str.repeat(count);
```

### 매개변수

`count`

문자열을 반복할 횟수. 0과 양의 무한대 사이의 정수([0, +∞)).

### 반환값

현재 문자열을 주어진 횟수만큼 반복해 붙인 새로운 문자열.

### 예외

* `RangeError`: 반복 횟수는 양의 정수여야 함.
* `RangeError`: 반복 횟수는 무한대보다 작아야 하며, 최대 문자열 크기를 넘어선 안됨.
예제
--

```js
"abc".repeat(-1); // RangeError
"abc".repeat(0); // ''
"abc".repeat(1); // 'abc'
"abc".repeat(2); // 'abcabc'
"abc".repeat(3.5); // 'abcabcabc' (count will be converted to integer)
"abc".repeat(1 / 0); // RangeError

({ toString: () => "abc", repeat: String.prototype.repeat }).repeat(2);
// 'abcabc' (repeat() is a generic method)
```

폴리필
---

`repeat`은 ECMAScript 2015 명세에 추가됐습니다. 따라서 어떤 표준 구현체에서는 사용할 수 없을 수도 있습니다. 그러나 아래 코드를 포함하면 지원하지 않는 플랫폼에서도 `repeat`을 사용할 수 있습니다.

```js
if (!String.prototype.repeat) {
  String.prototype.repeat = function (count) {
    "use strict";
    if (this == null) {
      throw new TypeError("can't convert " + this + " to object");
    }
    var str = "" + this;
    count = +count;
    if (count != count) {
      count = 0;
    }
    if (count < 0) {
      throw new RangeError("repeat count must be non-negative");
    }
    if (count == Infinity) {
      throw new RangeError("repeat count must be less than infinity");
    }
    count = Math.floor(count);
    if (str.length == 0 || count == 0) {
      return "";
    }
    // Ensuring count is a 31-bit integer allows us to heavily optimize the
    // main part. But anyway, most current (August 2014) browsers can't handle
    // strings 1 << 28 chars or longer, so:
    if (str.length \* count >= 1 << 28) {
      throw new RangeError(
        "repeat count must not overflow maximum string size",
      );
    }
    var maxCount = str.length \* count;
    count = Math.floor(Math.log(count) / Math.log(2));
    while (count) {
      str += str;
      count--;
    }
    str += str.substring(0, maxCount - str.length);
    return str;
  };
}
```

명세
--

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

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

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


String.prototype.valueOf() - JavaScript

String.prototype.valueOf()
==========================

**`valueOf()`** 메서드는 `String` 객체의 원시값을 반환합니다.

시도해보기
-----

구문
--

```js
str.valueOf();
```

### 반환 값

지정된 `String` 객체의 원시 값을 나타내는 문자열.

설명
--

`String` 의 `valueOf()` 메서드는 `String` 객체의 원시 값을 문자열 데이터 타입으로 반환 합니다. 이 값은 `String.prototype.toString()`.과 동일합니다.

이 메서드는 보통 JavaScript에 의해 내부적으로 호출되며, 코드에서 명시적으로 사용하지는 않습니다.

예제
--

### `valueOf()` 사용

```js
var x = new String("Hello world");
console.log(x.valueOf()); // 'Hello world' 가 보여집니다.
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.toString()`
* `Object.prototype.valueOf()`


String.prototype.toString() - JavaScript

String.prototype.toString()
===========================

**`toString()`** 메서드는 객체의 문자열 표현을 반환합니다.

시도해보기
-----

구문
--

```js
toString();
```

### 반환 값

메서드를 호출하는 객체의 문자열 표현.

설명
--

`String` 객체는 `Object` 객체의 `toString()` 메서드를 상속하지 않고 재정의합니다. `String` 의 `toString()` 메서드는 객체의 문자열 표현을 반환하며 `String.prototype.valueOf()` 메서드와 동일합니다.

예제
--

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

`String` 객체의 문자열 값을 표시하는 예제입니다.

```js
var x = new String("Hello world");

console.log(x.toString()); // logs 'Hello world'
```

명세
--

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

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

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

같이 보기
-----

* `String.prototype.valueOf()`


Uint8Array() constructor - JavaScript

Uint8Array() constructor
========================

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

문법
--

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

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

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

### 매개변수

`TypedArray`를 참고하세요.

### 예외

`TypedArray`를 참고하세요.

예제
--

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

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

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

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

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

// 순회로부터
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const uint8FromIterable = new Uint8Array(iterable);
console.log(uint8FromIterable);
// Uint8Array [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`에서 `Uint8Array` 폴리필
* JavaScript 형식화 배열
* `ArrayBuffer`
* `DataView`


TypedArray.prototype.set() - JavaScript

TypedArray.prototype.set()
==========================

**`set()`** 메서드는 지정된 배열로부터 입력 값을 읽어 형식화 배열 내에 여러 값을 저장합니다.

시도해보기
-----

구문
--

```js
typedarr.set(array[, offset])
typedarr.set(typedarray[, offset])
```

### 매개변수

`array`

값을 복사할 배열. 소스 배열로부터 모든 값이 대상 배열로 복사됩니다, 소스 배열의 길이 + 오프셋이 대상 배열의 길이를 초과하지 않는 한, 그 경우에는 예외가 발생됩니다.

`typedarray`

소스 배열이 형식화 배열인 경우, 두 배열은 기본 `ArrayBuffer`를 같이 공유할 수 있습니다; 브라우저는 버퍼의 소스 범위를 대상(destination) 범위로 똑똑하게 **복사**합니다.

`offset` Optional

소스 `array`에서 값을 쓰기 시작하는 대상 배열의 오프셋. 이 값이 생략된 경우, 0으로 간주됩니다 (즉, 소스 `array`는 인덱스 0에서 시작하는 대상 배열 내 값을 덮어씁니다).

### 예외

`RangeError`

`offset`이 가령 형식화 배열의 끝을 넘어서 저장하려고 설정된 경우 발생.

예제
--

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

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

uint8.set([1, 2, 3], 3);

console.log(uint8); // Uint8Array [ 0, 0, 0, 1, 2, 3, 0, 0 ]
```

명세
--

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

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

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

같이 보기
-----

* JavaScript 형식화 배열
* `TypedArray`
* `ArrayBuffer`


TypedArray.prototype.entries() - JavaScript

TypedArray.prototype.entries()
==============================

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

시도해보기
-----

구문
--

```js
entries()
```

### 반환 값

새로운 배열 반복자 객체.

예제
--

### for...of 루프를 사용하여 반복하기

```js
const array = new Uint8Array([10, 20, 30, 40, 50]);
const arrayEntries = arr.entries();
for (const element of arrayEntries) {
  console.log(element);
}
```

### 다른 반복 방법

```js
const array = new Uint8Array([10, 20, 30, 40, 50]);
const arrayEntries = arr.entries();

console.log(arrayEntries.next().value); // [0, 10]
console.log(arrayEntries.next().value); // [1, 20]
console.log(arrayEntries.next().value); // [2, 30]
console.log(arrayEntries.next().value); // [3, 40]
console.log(arrayEntries.next().value); // [4, 50]
```

명세서
---

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

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

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

같이 보기
-----

* Polyfill of `TypedArray.prototype.entries` in `core-js`
* JavaScript 형식화 배열
* `TypedArray`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype.values()`
* `TypedArray.prototype[@@iterator]()`


TypedArray.prototype.buffer - JavaScript

TypedArray.prototype.buffer
===========================

**`buffer`** 접근자 속성은 생성 시 *TypedArray*에서 참조하는 `ArrayBuffer`를 나타냅니다.

시도해보기
-----

설명
--

`buffer` 속성은 set 접근자 함수가 `undefined`인 속성으로, 이 속성은 읽을수만 있습니다. 값은 *TypedArray*가 생성될 때 설정되어 변경할 수 없습니다. *TypedArray*는 TypedArray 객체 중 하나입니다.

예제
--

### buffer 속성 사용하기

```js
const buffer = new ArrayBuffer(8);
const uint16 = new Uint16Array(buffer);
uint16.buffer; // ArrayBuffer { byteLength: 8 }
```

### 잘린 배열 보기에서 기반 버퍼에 액세스하기

```js
const buffer = new ArrayBuffer(1024);
const arr = new Uint8Array(buffer, 64, 128);
console.log(arr.byteLength); // 128
console.log(arr.buffer.byteLength); // 1024
console.log(arr.buffer === buffer); // true
```

명세서
---

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

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

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

같이 보기
-----

* JavaScript 형식화 배열
* `TypedArray`


TypedArray.prototype.sort() - JavaScript

TypedArray.prototype.sort()
===========================

**`sort()`** 메서드는 *적소에* 형식화 배열의 요소를 정렬하여 그 형식화 배열을 반환합니다. 이 메서드는 `Array.prototype.sort()`*와 같은 알고리즘입니다.* *TypedArray*는 여기 형식화 배열 유형 중 하나입니다.

구문
--

```js
typedarray.sort([compareFunction]);
```

### 매개변수

`compareFunction` Optional

정렬 순서를 정의하는 함수를 지정합니다.

예
-

더 많은 예는, `Array.prototype.sort()` 메서드도 참조하세요.

```js
var number = new Uint8Array([40, 1, 5, 200]);

function compareNumbers(a, b) {
  return a - b;
}

numbers.sort(compareNumbers);
// Uint8Array [ 1, 5, 40, 200 ]
```

명세
--

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

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

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

참조
--

* `Array.prototype.sort()`


TypedArray.prototype.byteOffset - JavaScript

TypedArray.prototype.byteOffset
===============================

**`byteOffset`** 접근자(accessor) 속성(property)은 그 `ArrayBuffer`의 시작점에서 형식화 배열의 오프셋(단위 바이트)을 나타냅니다.

구문
--

```js
typedarray.byteOffset;
```

설명
--

`byteOffset` 속성은 set 접근자 함수가 `undefined`인 접근자 속성입니다, 이 속성을 읽을 수만 있음을 뜻하는. 그 값은 *TypedArray*가 만들어질 때 수립되어 변경될 수 없습니다. *TypedArray*는 TypedArray 객체 유형 중 하나입니다.

예
-

### `byteOffset` 속성 사용

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

var uint8 = new Uint8Array(buffer);
uint8.byteOffset; // 0 (지정된 오프셋이 없음)

var uint8 = new Uint8Array(buffer, 3);
uint8.byteOffset; // 3 (Uint8Array를 만들 때 지정된 대로)
```

명세
--

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

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

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

같이 보기
-----

* JavaScript 형식화 배열
* `TypedArray`


TypedArray.prototype.every() - JavaScript

TypedArray.prototype.every()
============================

**`every()`** 메서드는 배열 안의 모든 요소가 주어진 판별 함수를 통과하는지 테스트합니다.
 이 메서드는 `Array.prototype.every()`와 같은 알고리즘을 가지고 있습니다.
 TypedArray은 형식화 배열 타입 중 하나입니다.

시도해보기
-----

구문
--

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

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

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

### 매개변수

`callbackFn`

각 요소를 시험할 함수.

다음 세 가지 인수를 받습니다.

`element`

배열에서 처리되는 현재 요소.

`index`

이 형식화 배열에서 처리할 현재 요소의 인덱스.

`array`

`every`를 호출한 형식화 배열.

`thisArg` Optional

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

### 반환 값

 콜백 함수가 모든 배열 요소가 참 같은 값을 반환하면 `true`를 반환하며,
 그렇지 않으면 `false`를 반환합니다.

설명
--

`every`는 `callbackFn`이 falsy을 반환하는 요소를 찾을 때까지 형식화 배열에 있는
 각 요소에 대해 한 번씩 `callbackFn` 함수를 실행합니다. 해당하는 요소를 발견한 경우 `every`는 즉시 `false`를
 반환합니다. 그렇지 않으면, 즉 모든 값에서 truthy을 반환하면 `true`를 반환합니다.

`callbackFn`은 요소의 값, 해당 요소의 인덱스 및 순회하고 있는 형식화 배열 세 가지 인수와 함께 호출됩니다.

`thisArg` 매개변수를 `every`에 제공한 경우 `callbackFn`의 `this`로 사용됩니다.
 그 외엔 `undefined`값을 사용합니다. 최종적으로 `callbackFn`이 볼 수 있는 `this`의 값은
 함수의 `this`를 결정하는 일반적인 규칙을 따릅니다.

`every`는 호출한 배열을 변형하지 않습니다.

예제
--

### 형식화 배열의 모든 요소의 크기 테스트

다음 예는 형식화 배열의 모든 요소가 9보다 더 큰지 테스트합니다.

```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
new Uint8Array([12, 5, 8, 130, 44]).every(isBigEnough); // false
new Uint8Array([12, 54, 18, 130, 44]).every(isBigEnough); // true
```

### 화살표 함수를 사용한 형식화 배열 테스트

화살표 함수는
 테스트 함수를 위해 더 짧은 구문을 제공합니다.

```js
new Uint8Array([12, 5, 8, 130, 44]).every((elem) => elem >= 10); // false
new Uint8Array([12, 54, 18, 130, 44]).every((elem) => elem >= 10); // true
```

명세서
---

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

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

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

같이 보기
-----

* Polyfill of `TypedArray.prototype.every` in `core-js`
* `TypedArray.prototype.some()`
* `Array.prototype.every()`


TypedArray.BYTES_PER_ELEMENT - JavaScript

TypedArray.BYTES\_PER\_ELEMENT
==============================

**`TypedArray.BYTES_PER_ELEMENT`** 속성은 각 형식화 배열 요소의 바이트 크기입니다.

시도해보기
-----

값
-

`TypedArray`의 타입에 따라 값이 달라지는 숫자입니다.

| Property attributes of `TypedArray.BYTES_PER_ELEMENT` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`TypedArray` 객체는 요소 당 바이트 수 및 바이트가 해석되는 방법이 서로 다릅니다.
 `BYTES_PER_ELEMENT` 상수는 주어진 `TypedArray`의 각 요소가 갖는 바이트 수를 포함합니다.

`BYTES_PER_ELEMENT` 속성은 인스턴스 속성이자 정적 속성입니다.
 해당 속성은 `TypedArray` 하위 클래스의 생성자와 해당 생성자의 인스턴스 모두에서 사용 가능합니다.

인스턴스 속성으로 `BYTES_PER_ELEMENT`는 생성자의 `prototype`에 정의됩니다.

```js
console.log(Object.hasOwn(Int8Array.prototype, "BYTES\_PER\_ELEMENT")); // true
```

예제
--

### BYTES\_PER\_ELEMENT 사용하기

정적 속성으로 사용하기

```js
Int8Array.BYTES\_PER\_ELEMENT; // 1
Uint8Array.BYTES\_PER\_ELEMENT; // 1
Uint8ClampedArray.BYTES\_PER\_ELEMENT; // 1
Int16Array.BYTES\_PER\_ELEMENT; // 2
Uint16Array.BYTES\_PER\_ELEMENT; // 2
Int32Array.BYTES\_PER\_ELEMENT; // 4
Uint32Array.BYTES\_PER\_ELEMENT; // 4
Float32Array.BYTES\_PER\_ELEMENT; // 4
Float64Array.BYTES\_PER\_ELEMENT; // 8
BigInt64Array.BYTES\_PER\_ELEMENT; // 8
BigUint64Array.BYTES\_PER\_ELEMENT; // 8
```

인스턴스 속성으로 사용하기

```js
new Int8Array([]).BYTES\_PER\_ELEMENT; // 1
new Uint8Array([]).BYTES\_PER\_ELEMENT; // 1
new Uint8ClampedArray([]).BYTES\_PER\_ELEMENT; // 1
new Int16Array([]).BYTES\_PER\_ELEMENT; // 2
new Uint16Array([]).BYTES\_PER\_ELEMENT; // 2
new Int32Array([]).BYTES\_PER\_ELEMENT; // 4
new Uint32Array([]).BYTES\_PER\_ELEMENT; // 4
new Float32Array([]).BYTES\_PER\_ELEMENT; // 4
new Float64Array([]).BYTES\_PER\_ELEMENT; // 8
new BigInt64Array([]).BYTES\_PER\_ELEMENT; // 8
new BigUint64Array([]).BYTES\_PER\_ELEMENT; // 8
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-typedarray.bytes\_per\_element |

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

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

같이 보기
-----

* JavaScript 형식화 배열
* `TypedArray`


TypedArray.prototype.reverse() - JavaScript

TypedArray.prototype.reverse()
==============================

**`reverse()`** 메서드는 제자리에서 형식화 배열을 뒤집습니다. 형식화 배열 첫 요소는 마지막이 되고 마지막은 첫 요소가 됩니다. 이 메서드는 `Array.prototype.reverse()`와 같은 알고리즘입니다. *TypedArray*는 여기 TypedArray 객체 유형 중 하나입니다.

시도해보기
-----

구문
--

```js
typedarray.reverse();
```

### 반환 값

뒤집힌 배열.

예제
--

```js
var uint8 = new Uint8Array([1, 2, 3]);
uint8.reverse();

console.log(uint8); // Uint8Array [3, 2, 1]
```

명세
--

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

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

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

같이 보기
-----

* `Array.prototype.reverse()`


get TypedArray[@@species] - JavaScript

get TypedArray[@@species]
=========================

**`TypedArray[@@species]`** 접근자 속성은 형식화 배열의 생성자를 반환합니다.

설명
--

`species` 접근자 속성은 형식화 배열 객체에 대한 기본 생성자를 반환합니다. 하위 클래스 생성자는 이를 재정의하여 생성자의 할당 값을 변경할 수 있습니다.

예제
--

### 일반 객체의 species

`species` 속성은 지정된 형식화 배열 객체에 대한 형식화 배열 생성자 중 하나인 기본 생성자 함수를 반환합니다.

```js
Int8Array[Symbol.species]; // function Int8Array()
Uint8Array[Symbol.species]; // function Uint8Array()
Float32Array[Symbol.species]; // function Float32Array()
```

### 파생 객체의 species

파생 컬렉션 객체(예: 사용자 지정 형식 배열 `MyTypedArray`)에서 `MyTypedArray`의 species는 `MyTypedArray` 생성자입니다. 그러나 파생 클래스 메서드에서 부모의 형식화 배열 객체를 반환하기 위해 이를 덮어쓸 수 있습니다.

```js
class MyTypedArray extends Uint8Array {
  // Overwrite MyTypedArray species to the parent Uint8Array constructor
  static get [Symbol.species]() {
    return Uint8Array;
  }
}
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%-@@species |

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

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

같이 보기
-----

* `TypedArray`
* `Symbol.species` (en-US)


TypedArray.prototype[@@iterator]() - JavaScript

TypedArray.prototype[@@iterator]()
==================================

@@iterator 속성의 초기값은 `values` 속성의 초기값과 같은 함수 객체입니다.

구문
--

```js
arr[Symbol.iterator]();
```

예
-

### `for...of` 루프를 사용하는 반복

```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
// 브라우저가 for..of 루프 및 for 루프에서
// let 스코프인 변수를 지원해야 합니다
for (let n of arr) {
  console.log(n);
}
```

### 대안 반복

```js
var arr = new Uint8Array([10, 20, 30, 40, 50]);
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // 10
console.log(eArr.next().value); // 20
console.log(eArr.next().value); // 30
console.log(eArr.next().value); // 40
console.log(eArr.next().value); // 50
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-%typedarray%.prototype-@@iterator |

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

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

참조
--

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


TypedArray.prototype.slice() - JavaScript

TypedArray.prototype.slice()
============================

**`slice()`** 메서드는 형식화 배열의 일부를 얕게 복사(shallow copy)한 새로운 형식화 배열 객체를 반환합니다. 이 메서드는 `Array.prototype.slice()`와 같은 알고리즘입니다. *TypedArray*는 여기 TypedArray 객체 유형 중 하나입니다.

구문
--

```js
typedarray.slice([begin[, end]])
```

매개변수
----

* `begin` Optional
    + 추출을 시작하는 인덱스(0부터 셈).
     음수 인덱스일 때, `begin`은 열 끝으로부터 오프셋을 나타냅니다. `slice(-2)`는 열에서 마지막 두 요소를 추출합니다.`begin`이 생략된 경우, `slice`는 인덱스 `0`에서 시작합니다.
* `end` Optional
    + 추출을 끝내는 인덱스(0부터 셈). `slice`는 `end`(를 포함하지 않음)까지만 추출합니다.
     `slice(1,4)`는 2번째부터 4번째 요소까지 추출합니다 (인덱스가 1, 2 및 3인 요소).
     음수 인덱스일 때, `end`는 열 끝으로부터 오프셋을 나타냅니다. `slice(2,-1)`은 열의 3번째부터 끝에서 2번째 요소까지 추출합니다.
     `end`가 생략된 경우, `slice`는 열의 끝까지 추출합니다 (`arr.length`).
설명
--

`slice` 메서드는 바꾸지 않습니다. 원래 형식화 배열에서 얕게 복사된 요소를 반환합니다.

새 요소가 어느 형식화 배열에든 추가된 경우, 다른 형식화 배열은 영향을 받지 않습니다.

예
-

### 기존 형식화 배열의 일부를 반환

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

명세
--

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

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

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

참조
--

* `Array.prototype.slice()`


TypedArray.prototype.join() - JavaScript

TypedArray.prototype.join()
===========================

**`join()`** 메서드는 어떤 형식화 배열의 모든 요소를 하나의 문자열로 연결합니다. 이 메서드는
 `Array.prototype.join()`와 같은 알고리즘을 가지고 있습니다. 형식화 배열(TypedArray)는
 형식화 배열의 타입 중 하나입니다.

시도해보기
-----

구문
--

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

### 매개변수

`separator` Optional

 배열의 각 요소를 구분할 문자열을 지정합니다. 이 `separator`는 필요한 경우 문자열로 변환됩니다.
 생략하면 배열의 요소들이 쉼표(",")로 구분됩니다.

### 반환 값

모든 배열 요소를 연결한 문자열.

예제
--

### join() 사용하기

```js
const uint8 = new Uint8Array([1, 2, 3]);
uint8.join(); // '1,2,3'
uint8.join(" / "); // '1 / 2 / 3'
uint8.join(""); // '123'
```

명세서
---

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

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

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

같이 보기
-----

* Polyfill of `TypedArray.prototype.join` in `core-js`
* `TypedArray`
* `Array.prototype.join()`


TypedArray.prototype.fill() - JavaScript

TypedArray.prototype.fill()
===========================

**`fill()`** 메서드는 배열의 모든 요소를 지정한 시작 인덱스부터 종료 인덱스까지 정적인 값으로 채웁니다. `fill()`은 `Array.prototype.fill()`과 동일한 알고리즘을 가지고 있습니다. TypedArray 는 typed array types 이곳에 있는 것 중 하나 입니다.

시도해보기
-----

구문
--

```js
typedarray.fill(value[, start = 0[, end = this.length]])
```

### 매개변수

`value`

배열에 채워넣을 값.

`start`

선택사항. 시작 위치. 기본값은 0.

`end`

선택사항. 종료 위치 (종료위치를 포함하지않습니다. 즉, end -1 까지만 해당됩니다.). 기본값 this.length(배열의 길이).

설명
--

start 와 end 사이에 요소들을 채웁니다.

**`fill`** 메소드는 value, start 그리고 and 3개의 매개변수를 요구합니다. start 와 end 매개변수는 선택사항이며 기본값은 0 과 지정한 배열객체의 길이값 입니다.

만약 start 매개변수가 음수이면, start 의 값은 배열의 길이값을 합한 결과가 시작지점이 되고, 만약 end 가 음수라면, end 매개변수와 배열의 길이값을 합한 결과가 종료지점이 됩니다.

예제
--

```js
new Uint8Array([1, 2, 3]).fill(4); // Uint8Array [4, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1); // Uint8Array [1, 4, 4]
new Uint8Array([1, 2, 3]).fill(4, 1, 2); // Uint8Array [1, 4, 3]
new Uint8Array([1, 2, 3]).fill(4, 1, 1); // Uint8Array [1, 2, 3]
new Uint8Array([1, 2, 3]).fill(4, -3, -2); // Uint8Array [4, 2, 3]
```

명세
--

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

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

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

같이 보기
-----

* `Array.prototype.fill()`


TypedArray.prototype.subarray() - JavaScript

TypedArray.prototype.subarray()
===============================

**`subarray()`** 메서드는 이 TypedArray 객체와 동일한 `ArrayBuffer` 저장소에 동일한 요소의 타입을 가진 새로운 TypedArray를 반환합니다. 시작 오프셋은 **포함**하고 마지막 오프셋은 **제외**합니다. TypedArray는 타입이 지정된 배열 유형 중 하나입니다.

시도해보기
-----

구문
--

```js
subarray()
subarray(begin)
subarray(begin, end)
```

### 매개변수

`begin` Optional

시작할 요소입니다. 오프셋 값은 포함되어 있습니다. 이 값을 명시하지 않으면 배열 전체가 새로운 뷰에 포함됩니다.

`end` Optional

 마지막 요소입니다. 오프셋 값은 제외합니다. 이 값을 명시하지 않으면 `begin`에 지정된 요소부터 배열 끝까지
 모든 요소가 새로운 뷰에 포함됩니다.

### 반환 값

새로운 `TypedArray` 객체.

설명
--

`begin`과 `end`으로 명시된 범위는 현재 배열의 유효한 인덱스 범위로 고정됩니다. 새 배열의 계산된 길이가 음수인 경우
 0으로 고정됩니다. `begin` 또는 `end`가 음수인 경우 배열의 시작이 아닌 끝의 인덱스를 참조합니다.

 또한 명심하셔야 할 점은 기존 버퍼에 새로운 뷰(view)를 생성하는 것뿐입니다.
 새 객체의 내용을 변경하면 원래 객체에 영향을 미치며 그 반대의 경우도 마찬가지입니다.

예제
--

### subarray() 메서드 사용하기

```js
const buffer = new ArrayBuffer(8);
const uint8 = new Uint8Array(buffer);
uint8.set([1, 2, 3]);

console.log(uint8); // Uint8Array [ 1, 2, 3, 0, 0, 0, 0, 0 ]

const sub = uint8.subarray(0, 4);

console.log(sub); // Uint8Array [ 1, 2, 3, 0 ]
```

명세서
---

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

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

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

같이 보기
-----

* Polyfill of `TypedArray.prototype.subarray` in `core-js`
* JavaScript 형식화 배열
* `TypedArray`
* `ArrayBuffer`


TypedArray.prototype.values() - JavaScript

TypedArray.prototype.values()
=============================

**`values()`** 메서드는 배열 내 각 인덱스에 대한 값을 포함하는 새로운 배열 반복자 객체를 반환합니다.

시도해보기
-----

구문
--

```js
values()
```

예제
--

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

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

### 다른 반복 방법

```js
const arr = new Uint8Array([10, 20, 30, 40, 50]);
const values = arr.values();
console.log(values.next().value); // 10
console.log(values.next().value); // 20
console.log(values.next().value); // 30
console.log(values.next().value); // 40
console.log(values.next().value); // 50
```

명세서
---

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

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

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

같이 보기
-----

* Polyfill of `TypedArray.prototype.values` in `core-js`
* JavaScript 형식화 배열
* `TypedArray`
* `TypedArray.prototype.entries()`
* `TypedArray.prototype.keys()`
* `TypedArray.prototype[@@iterator]()`


TypedArray.prototype.some() - JavaScript

TypedArray.prototype.some()
===========================

**`some()`** 메서드는 형식화 배열 내 일부 요소가 제공되는 함수에 의해 구현되는 테스트를 통과하는지 여부를 테스트합니다. 이 메서드는 `Array.prototype.some()`과 같은 알고리즘입니다. *TypedArray*는 여기 TypedArray 객체 유형 중 하나입니다.

시도해보기
-----

구문
--

```js
typedarray.some(callback[, thisArg])
```

### 매개변수

`callback`

 각 요소에 대해 테스트하는 함수, 다음 인수 셋을 취하는:\_ `currentValue`
 \_ : 형식화 배열에서 현재 처리 중인 요소.

`index`

형식화 배열에서 현재 처리 중인 요소의 인덱스.

`array`

`some`이 호출한 형식화 배열.

`thisArg`

선택 사항. `callback`을 실행할 때 `this`로서 사용하는 값.

설명
--

`some` 메서드는 `callback`이 true 값을 반환하는 요소를 찾을 때까지 형식화 배열에 있는 각 요소에 대해 한 번 `callback` 함수를 실행합니다. 그런 요소가 발견된 경우, `some`은 즉시 `true`를 반환합니다. 그렇지 않으면, `some`은 `false`를 반환합니다.

`callback`은 세 인수와 함께 호출됩니다: 요소값, 요소 인덱스 및 순회(traverse)되는 배열 객체.

`thisArg` 매개변수가 `some`에 제공되는 경우, 호출될 때 `callback`에 전달됩니다, 그 `this` 값으로 사용하기 위해. 그렇지 않으면, `undefined` 값이 그 `this` 값으로 사용하기 위해 전달됩니다. `callback`에 의해 결국 관찰할 수 있는 `this` 값은 함수에 의해 보이는 `this`를 결정하는 평소 규칙에 따라 결정됩니다.

`some`은 호출된 형식화 배열을 변화시키지(mutate) 않습니다.

예제
--

### 모든 형식화 배열 요소의 크기 테스트

다음 예는 형식화 배열의 모든 요소가 10보다 더 큰지 테스트합니다.

```js
function isBiggerThan10(element, index, array) {
  return element > 10;
}
new Uint8Array([2, 5, 8, 1, 4]).some(isBiggerThan10); // false
new Uint8Array([12, 5, 8, 1, 4]).some(isBiggerThan10); // true
```

### 화살표 함수를 사용하여 형식화 배열 요소 테스트

화살표 함수는 같은 테스트에 대해 더 짧은 구문을 제공합니다.

```js
new Uint8Array([2, 5, 8, 1, 4]).some((elem) => elem > 10); // false
new Uint8Array([12, 5, 8, 1, 4]).some((elem) => elem > 10); // true
```

명세
--

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

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

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

같이 보기
-----

* `TypedArray.prototype.every()`
* `Array.prototype.some()`


TypedArray.prototype.forEach() - JavaScript

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 - JavaScript

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() - JavaScript

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 - JavaScript

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() - JavaScript

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() - JavaScript

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() - JavaScript

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() - JavaScript

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*`