recursal/MDN huggingface dataset:
Object.prototype.toString()
===========================

The **`toString()`** 은 문자열을 반환하는 object의 대표적인 방법이다

시도해보기
-----

구문
--


```js
obj.toString();
```

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

모든 객체에는 객체가 텍스트 값으로 표시되거나 객체가 문자열이 예상되는 방식으로 참조 될 때 자동으로 호출되는 `toString()` 메서드가 있습니다. 기본적으로 `toString()` 메서드는 Object에서 비롯된 모든 객체에 상속됩니다. 이 메서드가 사용자 지정 개체에서 재정의되지 않으면 `toString()`은 "`[object type]`"을 반환합니다. 여기서 `type`은 object type입니다. 다음 코드는 이것을 설명합니다


```js
var o = new Object();
o.toString(); // returns [object Object]
```


**참고:** JavaScript 1.8.5부터 `null`의 `toString()`을 호출하는 경우 `[object Null]`을 반환하며, `undefined`는 `[object Undefined]`를 반환합니다. 이는 ECMAScript 제 5판과 후속 정오표에 정의되어 있습니다. See toString으로 객체 클래스 검사.

매개변수
----

숫자 및 BigInts의 경우 `toString()`은 선택적으로 기수(radix)를 매개변수로 취합니다. 기수의 값은 최소 2부터 36까지입니다.

`기수`를 이용함으로써 10진수를 (1, 2, 3, 4, 5...) 다른 진수로 변환할 수 있습니다. 아래는 10진수를 2진수로 변환하는 예제입니다.


```js
let baseTenInt = 10;
console.log(baseTenInt.toString(2));
// "1010"이 출력됩니다
```


big integers도 이와 같습니다


```js
let bigNum = BigInt(20);
console.log(bigNum.toString(2));
// "10100"이 출력됩니다
```


몇 가지 일반적인 기수들은 아래와 같습니다

* 2 : 2진법
* 8 : 8진법
* 10 : 10진법
* 16 : 16진법
Examples
--------

### 기본 `toString` 메소드 재정의

기본 `toString()` 메서드 대신에 호출될 함수를 정의할 수 있습니다. `toString()` 메서드는 인자를 취하지 않고 문자열을 반환합니다. 직접 생성한 `toString()` 메서드는 원하는 어떤 값이든 될 수 있지만 해당 객체에 대한 정보를 전달하고 있을 때 가장 유용할 것입니다.

다음 코드는 `Dog` 객체 타입을 정의하고 `Dog` 타입을 따르는 `theDog`를 생성합니다:


```js
function Dog(name, breed, color, sex) {
  this.name = name;
  this.breed = breed;
  this.color = color;
  this.sex = sex;
}

theDog = new Dog("Gabby", "Lab", "chocolate", "female");
```


커스텀 객체의 `toString()` 메서드를 호출하는 경우 `Object`로부터 상속받은 기본 값을 반환하게 됩니다:


```js
theDog.toString(); // returns [object Object]
```


다음 코드는 기본 `toString()` 메서드를 재정의하는 `dogToString()`을 생성하고 할당합니다. 이 함수는 객체의 name, breed, color, sex를 포함하는 문자열을 "`property = value;`"의 형태로 만들어냅니다.


```js
Dog.prototype.toString = function dogToString() {
  var ret =
    "Dog " +
    this.name +
    " is a " +
    this.sex +
    " " +
    this.color +
    " " +
    this.breed;
  return ret;
};
```


앞선 코드를 사용하면 문자열 컨텍스트에서 `theDog`가 사용될 때마다 JavaScript는 자동으로 `dogToString()` 함수를 호출하여 다음 문자열을 반환합니다:


```js
"Dog Gabby is a female chocolate Lab";
```

### `toString()`으로 객체 클래스 검사

`toString()`은 모든 객체에 사용되어 해당 객체의 클래스를 가져올 수 있습니다. Object.prototype.toString()을 모든 객체에 사용하기 위해서는 `Function.prototype.call()` 나 `Function.prototype.apply()`를 사용해서 검사하고자 하는 객체를 `thisArg`로 불리는 첫번째 파라미터로 넘겨야 합니다.


```js
var toString = Object.prototype.toString;

toString.call(new Date()); // [object Date]
toString.call(new String()); // [object String]
toString.call(Math); // [object Math]

// Since JavaScript 1.8.5
toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]
```

명세서
---

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

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

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

See also
--------

* `Object.prototype.toSource()` (en-US)
* `Object.prototype.valueOf()`
* `Number.prototype.toString()`
* `Symbol.toPrimitive`
Object.isExtensible()
=====================

**`Object.isExtensible()`** 메서드는 객체가 확장 가능한지(객체에 새 속성을 추가할 수 있는지 여부)를 결정합니다.

시도해보기
-----

구문
--


```js
Object.isExtensible(obj);
```

### 매개변수

`obj`

판별할 객체.

### 반환 값

객체의 확장 가능 여부를 나타내는 `Boolean`.

설명
--

객체는 기본으로 확장 가능입니다: 새로운 속성이 추가될 수 있고 (`Object.prototype.__proto__` 
지원이 중단되었습니다
 속성을 지원하는 엔진에서는) 수정될 수 있습니다. 객체는 `Object.preventExtensions()`, `Object.seal()` 또는 `Object.freeze()`를 사용하여 확장 불가로 표시될 수 있습니다.

예제
--


```js
// 새로운 객체는 확장 가능입니다.
var empty = {};
Object.isExtensible(empty); // === true

// ...하지만 변경될 수 있습니다.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// 봉인된 객체는 정의에 의해 확장 불가입니다.
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// 동결된 객체 또한 정의에 의해 확장 불가입니다.
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false
```

주의
--

ES5에서, 이 메서드의 인수가 비객체(원시형)인 경우, 그러면 `TypeError`가 발생합니다. ES6에서, 비객체 인수는 확장 불가인 보통 객체처럼 다뤄집니다, 그저 `false`를 반환하는.


```js
Object.isExtensible(1);
// TypeError: 1은 객체가 아닙니다 (ES5 코드)

Object.isExtensible(1);
// false (ES6 코드)
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.isextensible |

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

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

같이 보기
-----

* `Object.preventExtensions()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.isExtensible()`
Object.fromEntries()
====================

**`Object.fromEntries()`** 메서드는 키값 쌍의 목록을 객체로 바꿉니다.

시도해보기
-----

구문
--


```js
Object.fromEntries(iterable);
```

### 매개변수

`iterable`

반복 가능한 객체. 즉, `Array`, `Map` 또는 반복 규약을 구현한 기타 객체.

### 반환 값

속성의 키와 값을 반복 가능한 객체에서 가져온 새로운 객체.

설명
--

`Object.fromEntries()` 메서드는 키값 쌍 목록을 받고, 그 목록을 사용해 속성을 부여한 새로운 객체를 반환합니다. `iterable` 인자는 `@@iterator` 메서드를 구현하여 반복기 객체를 반환해야 하고, 그 반복기는 또 배열 형태의 객체로 요소 2개를 반환해야 합니다. 반환된 요소 중 첫 번째는 생성할 객체의 속성 키로, 두 번째는 속성 값으로 사용합니다.

`Object.fromEntries()`는`Object.entries()`의 역을 수행합니다.

예제
--

### `Map`에서 `Object`로


```js
const map = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }
```

### `Array`에서 `Object`로


```js
const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
```

### 객체 변환

`Object.fromEntries()`와 그 역인 `Object.entries()`, 그리고 배열 변형 메서드를 통해 객체를 변환할 수 있습니다.


```js
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val \* 2]),
);

console.log(object2);
// { a: 2, b: 4, c: 6 }
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.fromentries |

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

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

같이 보기
-----

* `Object.entries()`
* `Object.keys()`
* `Object.values()`
* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`
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()
============================

**`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()
=============================

**`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.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()
==========================

**`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()
========================

**`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()
=========================

**`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()
====================================

**`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()
=======================

**`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()`