recursal/MDN huggingface dataset:
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()
============

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

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

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

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

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

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

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

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

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

**`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=&gt;{
 const String=w.String, Proto=String.prototype;

 ((o,p)=&gt;{
 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()
=========================

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

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