Proxy - JavaScript

Proxy
=====

`Proxy` 객체를 사용하면 한 객체에 대한 기본 작업을 가로채고 재정의하는 프록시를 만들 수 있습니다.

설명
--

`Proxy` 객체를 사용하면 원래 `Object` 대신 사용할 수 있는 객체를 만들지만, 이 객체의 속성 가져오기, 설정 및 정의와 같은 기본 객체 작업을 재정의할 수 있습니다. 프록시 객체는 일반적으로 속성 액세스를 기록하고, 입력의 유효성을 검사하고, 형식을 지정하거나, 삭제하는 데 사용됩니다.

두 개의 매개변수를 사용하여 `Proxy`를 생성합니다.

* `target`: 프록시할 원본 객체
* `handler`: 가로채는 작업과 가로채는 작업을 재정의하는 방법을 정의하는 객체입니다.

예를 들어 아래 코드는 속성이 두 개뿐인 간단한 대상과 속성이 없는 훨씬 더 간단한 핸들러를 정의합니다.

```js
const target = {
  message1: "hello",
  message2: "everyone",
};

const handler1 = {};

const proxy1 = new Proxy(target, handler1);
```

핸들러가 비어 있기 때문에 이 프록시는 원래 대상처럼 작동합니다.

```js
console.log(proxy1.message1); // hello
console.log(proxy1.message2); // everyone
```

프록시를 커스텀하기 위해 처리기 객체에 함수를 정의합니다.

```js
const target = {
  message1: "hello",
  message2: "everyone",
};

const handler2 = {
  get(target, prop, receiver) {
    return "world";
  },
};

const proxy2 = new Proxy(target, handler2);
```

대상 객체의 속성 액세스를 가로채는 `get()` 처리기를 제공했습니다.

처리기 함수는 대상 객체에 대한 호출을 잡아내기 때문에 *트랩(traps)* 이라고도 부릅니다. 위의 `handler2`에 있는 매우 간단한 트랩은 모든 속성 접근자를 재정의합니다.

```js
console.log(proxy2.message1); // world
console.log(proxy2.message2); // world
```

`Reflect` 클래스의 도움으로 일부 접근자에게 원래 동작을 제공하고 다른 접근자를 재정의할 수 있습니다.

```js
const target = {
  message1: "hello",
  message2: "everyone",
};

const handler3 = {
  get(target, prop, receiver) {
    if (prop === "message2") {
      return "world";
    }
    return Reflect.get(...arguments);
  },
};

const proxy3 = new Proxy(target, handler3);

console.log(proxy3.message1); // hello
console.log(proxy3.message2); // world
```

생성자
---

`Proxy()`

새 `Proxy` 객체를 생성합니다.

정적 메서드
------

`Proxy.revocable()` (en-US)

취소 가능한 `Proxy` 객체를 생성합니다.

예제들
---

### 기본 예제

이 간단한 예에서는 속성 이름이 객체에 없으면 숫자 `37`을 기본값으로 반환합니다. `get()` 처리기를 사용합니다.

```js
const handler = {
  get(obj, prop) {
    return prop in obj ? obj[prop] : 37;
  },
};

const p = new Proxy({}, handler);
p.a = 1;
p.b = undefined;

console.log(p.a, p.b);
// 1, undefined

console.log("c" in p, p.c);
// false, 37
```

### No-op 포워딩 프록시

이 예에서는 기본 JavaScript 객체를 사용하여 프록시가 모든 작업을 대상 객체에게 전달합니다.

```js
const target = {};
const p = new Proxy(target, {});

p.a = 37;
// 대상 객체에게 작업 전달

console.log(target.a);
// 37
// (작업이 제대로 전달됨!)
```

이 "no-op"는 일반 JavaScript 객체에 대해 작동하지만 DOM 요소, `Map` 객체 또는 내부 슬롯이 있는 모든 기본 객체에는 작동하지 않습니다. 자세한 내용은 프라이빗 속성 포워딩 없음을 참조하십시오.

### 프라이빗 속성 포워딩 없음

프록시는 여전히 다른 ID를 가진 또 다른 객체로, 래핑된 객체와 외부 사이에서 작동하는 **프록시**일 뿐입니다. 따라서 프록시는 원래 객체의 프라이빗 속성에 직접 접근할 수 없습니다.

```js
class Secret {
  #secret;
  constructor(secret) {
    this.#secret = secret;
  }
  get secret() {
    return this.#secret.replace(/\d+/, "[REDACTED]");
  }
}

const aSecret = new Secret("123456");
console.log(aSecret.secret); // [REDACTED]
// no-op 포워딩 같지만...
const proxy = new Proxy(aSecret, {});
console.log(proxy.secret); // TypeError: Cannot read private member #secret from an object whose class did not declare it
```

이는 프록시의 `get` 트랩이 호출될 때 `this` 값이 원래 `secret`이 아닌 `proxy`이므로 `#secret`에 액세스할 수 없기 때문입니다. 이 문제를 해결하려면 원래 `secret`을 `this`로 사용하세요.

```js
const proxy = new Proxy(aSecret, {
  get(target, prop, receiver) {
    // 기본적으로 'this'값이 다른
    // Reflect.get(target, prop, receiver)처럼 보입니다.
    return target[prop];
  },
});
console.log(proxy.secret);
```

메서드의 경우 메서드의 `this` 값도 원래 객체로 리디렉션해야 합니다.

```js
class Secret {
  #x = 1;
  x() {
    return this.#x;
  }
}

const aSecret = new Secret();
const proxy = new Proxy(aSecret, {
  get(target, prop, receiver) {
    const value = target[prop];
    if (value instanceof Function) {
      return function (...args) {
        return value.apply(this === receiver ? target : this, args);
      };
    }
    return value;
  },
});
console.log(proxy.x());
```

일부 기본 JavaScript 객체에는 JavaScript 코드에서 액세스할 수 없는 **내부 슬롯** 이라는 속성이 있습니다. 예를 들어, `Map` 객체에는 맵의 키-값 쌍을 저장하는 `[[MapData]]`라는 내부 슬롯이 있습니다. 따라서 맵에 대한 전달 프록시는 간단하게 만들 수 없습니다.

```js
const proxy = new Proxy(new Map(), {});
console.log(proxy.size); // TypeError: get size method called on incompatible Proxy
```

이 문제를 해결하려면 위에 설명된 "`this`-recovering" 프록시를 사용해야 합니다.

### 검증

프록시를 사용하면 객체에 대해 전달된 값을 쉽게 확인할 수 있습니다. 이 예제에서는 `set()` 처리기를 사용합니다.

```js
const validator = {
  set(obj, prop, value) {
    if (prop === "age") {
      if (!Number.isInteger(value)) {
        throw new TypeError("The age is not an integer");
      }
      if (value > 200) {
        throw new RangeError("The age seems invalid");
      }
    }

    // 값을 저장하는 기본 동적
    obj[prop] = value;

    // 성공 표시
    return true;
  },
};

const person = new Proxy({}, validator);

person.age = 100;
console.log(person.age); // 100
person.age = "young"; // 예외 발생
person.age = 300; // 예외 발생
```

### 생성자 확장하기

함수 프록시는 새 생성자로 생성자를 쉽게 확장할 수 있습니다. 이 예제에서는 `construct()`과 `apply()` 처리기를 사용합니다.

```js
function extend(sup, base) {
  base.prototype = Object.create(sup.prototype);
  base.prototype.constructor = new Proxy(base, {
    construct(target, args) {
      const obj = Object.create(base.prototype);
      this.apply(target, obj, args);
      return obj;
    },
    apply(target, that, args) {
      sup.apply(that, args);
      base.apply(that, args);
    },
  });
  return base.prototype.constructor;
}

const Person = function (name) {
  this.name = name;
};

const Boy = extend(Person, function (name, age) {
  this.age = age;
});

Boy.prototype.gender = "M";

const Peter = new Boy("Peter", 13);

console.log(Peter.gender); // "M"
console.log(Peter.name); // "Peter"
console.log(Peter.age); // 13
```

### DOM 노드 조작

이 예에서는 `Proxy`를 사용하여 두 개의 다른 요소의 속성을 토글합니다. 따라서 한 요소에 속성을 설정하면 다른 요소에 속성이 설정되지 않습니다.

`selected` 속성을 가진 객체에 대한 프록시인 `view` 객체를 생성합니다. 프록시 핸들러는 `set()` 처리기를 정의합니다.

`view.selected`에 HTML 요소를 할당하면 요소의 `'aria-selected'` 속성이 `true`로 설정됩니다. 그런 다음 `view.selected`에 다른 요소를 할당하면 이 요소의 `'aria-selected'` 속성이 `true`로 설정되고 이전 요소의 `'aria-selected'` 속성이 자동으로 `false`로 설정됩니다.

```js
const view = new Proxy(
  {
    selected: null,
  },
  {
    set(obj, prop, newval) {
      const oldval = obj[prop];

      if (prop === "selected") {
        if (oldval) {
          oldval.setAttribute("aria-selected", "false");
        }
        if (newval) {
          newval.setAttribute("aria-selected", "true");
        }
      }

      // 값을 저장하는기본 동작
      obj[prop] = newval;

      // 성공 표시
      return true;
    },
  },
);

const item1 = document.getElementById("item-1");
const item2 = document.getElementById("item-2");

// item1 선택
view.selected = item1;

console.log(`item1: ${item1.getAttribute("aria-selected")}`);
// item1: true

// item2를 선택하고 item1은 선택 해제
view.selected = item2;

console.log(`item1: ${item1.getAttribute("aria-selected")}`);
// item1: false

console.log(`item2: ${item2.getAttribute("aria-selected")}`);
// item2: true
```

### 값 수정 및 추가 속성

`products` 프록시 객체는 전달된 값을 계산하고 필요한 경우 배열로 변환합니다. 또한 객체는 getter 및 setter 모두에게 `latestBrowser`라는 추가 속성을 지원합니다.

```js
const products = new Proxy(
  {
    browsers: ["Internet Explorer", "Netscape"],
  },
  {
    get(obj, prop) {
      // 추가 속성
      if (prop === "latestBrowser") {
        return obj.browsers[obj.browsers.length - 1];
      }

      // 값을 저장하는 기본 동작
      return obj[prop];
    },
    set(obj, prop, value) {
      // 추가 속성
      if (prop === "latestBrowser") {
        obj.browsers.push(value);
        return true;
      }

      // 값이 배열이 아닌 경우 배열로 변환
      if (typeof value === "string") {
        value = [value];
      }

      // 값을 저장하는 기본 동작
      obj[prop] = value;

      // 성공 표시
      return true;
    },
  },
);

console.log(products.browsers);
// ['Internet Explorer', 'Netscape']

products.browsers = "Firefox";
// (실수로) 문자열을 넘겨줌

console.log(products.browsers);
// ['Firefox'] <- 문제없이 값은 배열로 변환됨

products.latestBrowser = "Chrome";

console.log(products.browsers);
// ['Firefox', 'Chrome']

console.log(products.latestBrowser);
// 'Chrome'
```

### 속성으로 배열 아이템 객체 찾기

이 프록시는 일부 유틸리티 기능으로 배열을 확장합니다. 보시다시피 `Object.defineProperties()`를 사용하지 않고도 속성을 유연하게 "정의"할 수 있습니다. 이 예제는 해당 셀로 테이블 행을 찾는 데 적용할 수 있습니다. 이 경우 대상은 `table.rows` (en-US)가 됩니다.

```js
const products = new Proxy(
  [
    { name: "Firefox", type: "browser" },
    { name: "SeaMonkey", type: "browser" },
    { name: "Thunderbird", type: "mailer" },
  ],
  {
    get(obj, prop) {
      // 값을 저장하는 기본 동작. prop은 보통 int
      if (prop in obj) {
        return obj[prop];
      }

      // product의 수를 가져옴. products.length에 대한 별칭
      if (prop === "number") {
        return obj.length;
      }

      let result;
      const types = {};

      for (const product of obj) {
        if (product.name === prop) {
          result = product;
        }
        if (types[product.type]) {
          types[product.type].push(product);
        } else {
          types[product.type] = [product];
        }
      }

      // 이름으로 product 가져오기
      if (result) {
        return result;
      }

      // type으로 product 가져오기
      if (prop in types) {
        return types[prop];
      }

      // types로 product 가져오기
      if (prop === "types") {
        return Object.keys(types);
      }

      return undefined;
    },
  },
);

console.log(products[0]); // { name: 'Firefox', type: 'browser' }
console.log(products["Firefox"]); // { name: 'Firefox', type: 'browser' }
console.log(products["Chrome"]); // undefined
console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }]
console.log(products.types); // ['browser', 'mailer']
console.log(products.number); // 3
```

### 완전한 trap 예제

교훈적인 목적으로 완전한 샘플 `traps` 목록을 생성하기 위해 이 유형의 작업에 특히 적합한 네이티브 객체가 아닌 간단한 쿠키 프레임워크에 의해 생성된 전역 객체 `docCookies`를 프록시화하려고 합니다.

```js
/\*
 const docCookies = ... 여기서 "docCookies"를 가져옵니다.
 https://reference.codeproject.com/dom/document/cookie/simple\_document.cookie\_framework
\*/

const docCookies = new Proxy(docCookies, {
  get(target, key) {
    return target[key] || target.getItem(key) || undefined;
  },
  set(target, key, value) {
    if (key in target) {
      return false;
    }
    return target.setItem(key, value);
  },
  deleteProperty(target, key) {
    if (!(key in target)) {
      return false;
    }
    return target.removeItem(key);
  },
  ownKeys(target) {
    return target.keys();
  },
  has(target, key) {
    return key in target || target.hasItem(key);
  },
  defineProperty(target, key, descriptor) {
    if (descriptor && "value" in descriptor) {
      target.setItem(key, descriptor.value);
    }
    return target;
  },
  getOwnPropertyDescriptor(target, key) {
    const value = target.getItem(key);
    return value
      ? {
          value,
          writable: true,
          enumerable: true,
          configurable: false,
        }
      : undefined;
  },
});

/\* 쿠키 테스트 \*/

console.log((docCookies.myCookie1 = "First value"));
console.log(docCookies.getItem("myCookie1"));

docCookies.setItem("myCookie1", "Changed value");
console.log(docCookies.myCookie1);
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-proxy-objects |

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

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

같이 보기
-----

* "Proxies are awesome" Brendan Eich presentation at JSConf (slides)
* Tutorial on proxies


Int16Array - JavaScript

Int16Array
==========

**`Int16Array`** 형식화 배열(TypedArray)은 플랫폼의 바이트 순서를 따르는 2의 보수 16비트의 부호있는 정수의
 배열입니다. 바이트 순서를 제어해야 하는 경우 대신 `DataView`를 사용합니다. 배열의 내용은 0으로 초기화됩니다.
 배열이 생성되면 객체의 메서드를 사용하거나 표준 배열 인덱스 구문(즉, 대괄호 표기법 사용)을 사용하여 배열의 요소를 참조할 수 있습니다.

생성자
---

`Int16Array()`

새로운 `Int16Array` 객체를 생성합니다.

정적 속성
-----

부모 `TypedArray`에서 정적 속성을 상속합니다.

`Int16Array.BYTES_PER_ELEMENT`

요소 크기를 숫자로 반환합니다. `Int16Array`의 경우 `2` 입니다.

`Int16Array.name`

생성자 이름을 문자열로 반환합니다. `Int16Array` 타입의 경우 `"Int16Array"`입니다.

정적 메서드
------

부모 `TypedArray`에서 정적 메서드를 상속합니다.

인스턴스 속성
-------

부모 `TypedArray`에서 인스턴스 속성을 상속합니다.

`Int16Array.prototype.BYTES_PER_ELEMENT`

요소 크기를 숫자로 반환합니다. `Int16Array`의 경우 `2` 입니다.

인스턴스 메서드
--------

부모 `TypedArray`에서 인스턴스 메서드를 상속합니다.

예제
--

### Int16Array을 생성하기 위한 각기 다른 방법

```js
// 길이로 부터
const int16 = new Int16Array(2);
int16[0] = 42;
console.log(int16[0]); // 42
console.log(int16.length); // 2
console.log(int16.BYTES\_PER\_ELEMENT); // 2

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

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

// ArrayBuffer로부터
const buffer = new ArrayBuffer(16);
const z = new Int16Array(buffer, 2, 4);
console.log(z.byteOffset); // 2

// 순회로부터
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const int16FromIterable = new Int16Array(iterable);
console.log(int16FromIterable);
// Int16Array [1, 2, 3]
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

같이 보기
-----

* `core-js`에서 `Int16Array` 폴리필
* JavaScript 형식화 배열
* `ArrayBuffer`
* `DataView`


GeneratorFunction - JavaScript

GeneratorFunction
=================

**`GeneratorFunction` 생성자**는 새로운 `generator function` 객체를 생성한다. JavaScript 에서 모든 generator function 은 실제로 `GeneratorFunction` object 이다.

주의할 점은, `GeneratorFunction` 이 전역 객체(global object)가 아니란 점이다. GeneratorFunction은 다음의 코드를 실행해서 얻을 수 있다.

```js
Object.getPrototypeOf(function\* () {}).constructor;
```

Syntax
------

```js
new Function(arg1, functionBody)
new Function(arg1, arg2, functionBody)
new Function(arg1, ... , argN, functionBody)
```

### Parameters

`arg1, arg2, ... argN`

이 함수에서 공식적인 argument 이름들로 사용되는 이름들이다. 각각은 유효한 Javascript 식별자이거나 쉼표로 구분된 문자열 리스트에 해당되는 문자열이어야 한다; for example "`x`", "`theValue`", or "`a,b`".

`functionBody`

함수 정의를 구성하는 JavaScript 문이 포함된 문자열.

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

`GeneratorFunction` 생성자로 생성된 `generator function` 객체는 그 함수가 생성될 때 분석한다. 이러한 함수들이 나머지 코드들과 함께 분석되기 때문에, `function* expression`으로 generator function을 선언하고 코드 내에서 호출하는 것보다 덜 효율적입니다.

그 함수로 전달된 모든 arguments는 생성될 함수 안에서 파라미터의 식별자 이름으로 그것들이 전달된 순서대로 처리된다.

**참고:** `generator function` created with the `GeneratorFunction` constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the `GeneratorFunction` constructor was called. This is different from using `eval` with code for a generator function expression.

new 없이 `GeneratorFunction` 생성자를 함수처럼 사용하는 것은 생성자처럼 사용하는 것과 동일한 효과를 갖는다.

Examples
--------

### GeneratorFunction 생성자로 generator function 생성하기

```js
var GeneratorFunction = Object.getPrototypeOf(function\* () {}).constructor;
var g = new GeneratorFunction("a", "yield a \* 2");
var iterator = g(10);
console.log(iterator.next().value); // 20
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-generatorfunction-objects |

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

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

See also
--------

* `function* function`
* `function* expression`
* `Function`
* `function statement`
* `function expression`
* Functions and function scope (en-US)


eval() - JavaScript

eval()
======

**경고:** **주의:** 문자열로부터 \*\*`eval()`\*\*을 실행하는 것은 엄청나게 위험합니다. \*\*`eval()`\*\*을 사용하면 해커가 위험한 코드를 사용할 수 있습니다. 아래에 eval을 절대 사용하지 말 것!을 확인하세요.

\*\*`eval()`\*\*은 문자로 표현된 JavaScript 코드를 실행하는 함수입니다.

시도해보기
-----

구문
--

```js
eval(string);
```

### 매개변수

`string`

JavaScript 표현식, 명령문, 또는 연속되는 다수의 명령문을 나타내는 문자열. 표현식은 이미 존재하는 객체의 변수나 속성을 포함할 수 있습니다.

### 반환값

주어진 코드를 평가하여 얻은 값. 값이 없다면 `undefined`를 반환합니다.

설명
--

`eval()`은 전역 객체의 함수 속성입니다.

`eval()`의 인자는 문자열입니다. 인자가 표현식을 나타낸다면 `eval()`은 표현식을 평가합니다. 인자가 하나 이상의 JavaScript 명령문을 나타낸다면 모두 실행합니다. 연산식을 계산하기 위해 `eval()`을 호출하지 마세요. JavaScript는 연산식을 알아서 계산합니다.

문자열로 연산식을 구성하면 나중에 `eval()`로 계산할 수 있습니다. `x` 라는 변수가 있다고 가정하면 `x`가 포함된 연산식을 문자열로, 예를 들어 "`3 * x + 2`"로 나타내고 나중에 `eval()`을 호출해서 계산을 연기할 수 있습니다.

`eval()`의 인자가 문자열이 아니면 `eval()`은 인자를 그대로 반환합니다. 다음 예시에서, `String` 생성자가 명시된 경우 문자열을 계산하는 대신 `String` 객체를 반환합니다.

```js
eval(new String("2 + 2")); // "2 + 2"를 포함한 String 객체를 반환
eval("2 + 2"); // 4를 반환
```

`toString()`을 사용하는 일반적인 방식으로 제약을 피할 수 있습니다.

```js
var expression = new String("2 + 2");
eval(expression.toString()); // 4를 반환
```

`eval`을 직접 호출하지 않고 참조를 통해 *간접적으로* 사용한다면 ECMAScript 5부터는 지역 범위가 아니라 전역 범위에서 동작합니다. 예를 들어 `eval()`로 함수를 선언하면 전역 함수가 되고, 실행되는 코드는 실행되는 위치의 지역 범위에 접근할 수 없습니다.

```js
function test() {
  var x = 2,
    y = 4;
  console.log(eval("x + y")); // 직접 호출, 지역 범위 사용, 결과값은 6
  var geval = eval; // eval을 전역 범위로 호출하는 것과 같음
  console.log(geval("x + y")); // 간접 호출, 전역 범위 사용, `x`가 정의되지 않았으므로 ReferenceError 발생
  (0, eval)("x + y"); // 다른 방식으로 간접 호출
}
```

`eval`을 절대 사용하지 말 것!
--------------------

`eval()`은 인자로 받은 코드를 caller의 권한으로 수행하는 위험한 함수입니다. 악의적인 영향을 받았을 수 있는 문자열을 `eval()`로 실행한다면, 당신의 웹페이지나 확장 프로그램의 권한으로 사용자의 기기에서 악의적인 코드를 수행하는 결과를 초래할 수 있습니다. 또한, 제3자 코드가 `eval()`이 호출된 위치의 스코프를 볼 수 있으며, 이를 이용해 비슷한 함수인 `Function`으로는 실현할 수 없는 공격이 가능합니다.

또한 최신 JS 엔진에서 여러 코드 구조를 최적화하는 것과 달리 `eval()`은 JS 인터프리터를 사용해야 하기 때문에 다른 대안들보다 느립니다.

추가로, 최신 JavaScript 인터프리터는 JavaScript를 기계 코드로 변환합니다. 즉, 변수명의 개념이 완전히 없어집니다. 그러나 `eval`을 사용하면 브라우저는 기계 코드에 해당 변수가 있는지 확인하고 값을 대입하기 위해 길고 무거운 변수명 검색을 수행해야 합니다. 또한 `eval()`을 통해 자료형 변경 등 변수에 변화가 일어날 수 있으며, 브라우저는 이에 대응하기 위해 기계 코드를 재작성해야 합니다. 그러나, (다행히) window.Function이라는 `eval`보다 훨씬 나은 대안이 있습니다. `eval()`을 사용하는 코드를 `Function()`으로 바꾸는 방법에 대해서는 아래를 참조하세요.

`eval`을 사용하는 나쁜 코드:

```js
function looseJsonParse(obj) {
  return eval(obj);
}
console.log(looseJsonParse("{a:(4-1), b:function(){}, c:new Date()}"));
```

`eval`이 없는 코드:

```js
function looseJsonParse(obj) {
  return Function('"use strict";return (' + obj + ")")();
}
console.log(looseJsonParse("{a:(4-1), b:function(){}, c:new Date()}"));
```

위의 두 코드는 얼핏 보면 같은 방식으로 실행되는 것처럼 보이지만, `eval`이 있는 코드가 훨씬 느립니다. 평가되는 객체의 `c: new Date()`를 주목하세요. `eval`이 없는 함수의 경우 이 객체는 전역 범위에서 평가되기 때문에 브라우저에서는 `Date`를 같은 이름의 지역 변수가 아니라 `window.Date`로 취급할 수 있습니다. 그러나 `eval()`을 사용하는 코드에서는 아래와 같은 경우도 존재할 수 있기 때문에 `Date`를 이렇게 취급할 수 없습니다.

```js
function Date(n) {
  return [
    "Monday",
    "Tuesday",
    "Wednesday",
    "Thursday",
    "Friday",
    "Saturday",
    "Sunday",
  ][n % 7 || 0];
}
function looseJsonParse(obj) {
  return eval(obj);
}
console.log(looseJsonParse("{a:(4-1), b:function(){}, c:new Date()}"));
```

그러므로 `eval()`이 있는 코드의 경우 브라우저는 `Date()`라는 지역 변수의 존재를 확인하기 위해 무거운 변수명 탐색을 수행해야 하며, 이는 `Function()`과 비교하면 매우 느립니다.

만약 위의 상황에서 실제로 새로 선언한 `Date` 함수를 `Function()`에서 실행해야 하는 상황을 생각해 봅시다. 이렇게 되면 `eval()`로 돌아가야 할까요? 물론 아닙니다. 아래의 접근을 시도해 보세요.

```js
function Date(n) {
  return [
    "Monday",
    "Tuesday",
    "Wednesday",
    "Thursday",
    "Friday",
    "Saturday",
    "Sunday",
  ][n % 7 || 0];
}
function runCodeWithDateFunction(obj) {
  return Function('"use strict";return (' + obj + ")")()(Date);
}
console.log(runCodeWithDateFunction("function(Date){ return Date(5) }"));
```

위 코드는 삼중 중첩 함수를 사용하기 때문에 매우 비효율적으로 보일 수 있지만, 이 방법의 이점을 우선 살펴봅시다.

1. `runCodeWithDateFunction`에 문자열로 전달된 코드를 최소화할 수 있다.

2. Function call overhead is minimal, making the far smaller code size well worth the benefit

3. `Function()`은 `"use strict";`를 사용함으로써 코드의 성능을 최적화할 수 있다.

4. `eval()`을 사용하지 않으므로 실행 속도가 훨씬 빠르다.

마지막으로 코드 최소화의 측면에서 살펴보면, 위와 같이 `Function()`을 사용했을 때는 아래의 최소화된 코드와 같이 함수의 인자 이름 역시 짧게 줄일 수 있으므로 runCodeWithDateFunction에 전달하는 코드 문자열을 더욱 효율적으로 줄일 수 있습니다.

```js
console.log(
  Function('"use strict";return(function(a){return a(5)})')()(function (a) {
    return "Monday Tuesday Wednesday Thursday Friday Saturday Sunday".split(
      " ",
    )[a % 7 || 0];
  }),
);
```

자주 쓰이는 용례에 대해서는 `eval()`이나 `Function()`보다 안전하고 빠른 대안도 존재합니다.

### 객체의 속성에 접근하기

속성명으로 속성을 찾는 데 `eval()`을 사용해서는 안 됩니다. 다음 예제와 같이 코드를 실행하기 전까지는 접근할 속성을 알 수 없는 상황을 생각해 봅시다. 이 상황은 `eval`로 처리할 수 있습니다.

```js
var obj = { a: 20, b: 30 };
var propname = getPropName(); // "a" 또는 "b"를 반환

eval("var result = obj." + propname);
```

그러나 여기에서 `eval()`을 쓸 필요가 없고, 지양되어야 합니다. 그 대신 훨씬 빠르고 안전한 속성 접근자를 사용하여야 합니다.

```js
var obj = { a: 20, b: 30 };
var propname = getPropName(); // "a" 또는 "b"를 반환
var result = obj[propname]; // obj[ "a" ]는 obj.a와 동일함
```

이 방법으로 더 깊은 속성에도 접근할 수 있습니다. `eval()`을 사용한다면 다음과 같을 것입니다.

```js
var obj = { a: { b: { c: 0 } } };
var propPath = getPropPath(); // "a.b.c"를 반환한다고 가정

eval("var result = obj." + propPath);
```

여기서 `eval()`의 사용을 피하려면 속성 경로를 `split`한 다음 순서대로 접근할 수도 있습니다.

```js
function getDescendantProp(obj, desc) {
  var arr = desc.split(".");
  while (arr.length) {
    obj = obj[arr.shift()];
  }
  return obj;
}

var obj = { a: { b: { c: 0 } } };
var propPath = getPropPath(); // "a.b.c"를 반환한다고 가정
var result = getDescendantProp(obj, propPath);
```

속성에 값을 대입하는 것도 비슷하게 할 수 있습니다.

```js
function setDescendantProp(obj, desc, value) {
  var arr = desc.split(".");
  while (arr.length > 1) {
    obj = obj[arr.shift()];
  }
  return (obj[arr[0]] = value);
}

var obj = { a: { b: { c: 0 } } };
var propPath = getPropPath(); // "a.b.c"를 반환한다고 가정
var result = setDescendantProp(obj, propPath, 1); // test.a.b.c의 값은 1로 지정됨
```

### 단편적인 코드 수행 대신 함수 사용하기

JavaScript의 함수는 1급 객체이므로 다른 API에 함수를 인자로 전달할 수도 있고, 변수나 객체의 속성으로 대입할 수도 있습니다. 다수의 DOM API는 이 점을 염두에 두고 설계되므로, 다음과 같이 코드를 짜야 합니다.

```js
// setTimeout(" ... ", 1000) 대신에
setTimeout(function() { ... }, 1000);

// elt.setAttribute("onclick", "...") 대신에
elt.addEventListener("click", function() { ... } , false);
```

또한 클로저를 이용해 문자열을 합치는 등의 연산 없이 매개변수화된 함수를 생성할 수 있습니다.

### JSON 파싱 (문자열을 JavaScript 객체로 변환)

`eval()`을 호출하려는 문자열에 코드가 아니라 데이터가 포함되어 있다면(예를 들어 `"[1, 2, 3]"`과 같은 배열), 대신 JavaScript의 문법 일부를 이용해 문자열로 데이터를 표현할 수 있는 JSON을 사용하는 것을 고려해 보세요. Downloading JSON and JavaScript in extensions도 참고해 보세요.

JSON 문법은 JavaScript 문법에 비해 제약이 있기 때문에, 유효한 JavaScript 리터럴이 JSON으로 변환되지 않는 경우도 있습니다. 예를 들어, JSON에서는 배열이나 객체를 콤마로 끝낼 수 없고, 객체 리터럴에서 속성명(키)은 반드시 따옴표로 감싸야 합니다. 나중에 JSON으로 파싱할 문자열을 생성할 때는 JSON 직렬 변환기를 사용하여야 합니다.

### 코드 대신 데이터 전달하기

예를 들어, 웹 페이지의 내용을 추출하는 확장 프로그램은 JavaScript 코드 대신 XPath에 스크랩 규칙을 정의할 수 있습니다.

### 제한된 권한으로 코드 실행하기

제3자 코드를 실행해야 할 때는 제한된 권한으로 실행하는 것을 고려해야 합니다. 이는 주로 확장 프로그램이나 XUL 어플리케이션에 적용되며, 이때 Components.utils.evalInSandbox를 사용할 수 있습니다.

예제
--

### `eval` 사용하기

아래 코드에서 `eval()`를 포함하는 문장은 모두 42를 반환합니다. 전자는 문자열 "`x + y + 1`"을, 후자는 문자열 "`42`"를 평가합니다.

```js
var x = 2;
var y = 39;
var z = "42";
eval("x + y + 1"); // 42를 반환
eval(z); // 42를 반환
```

### `eval`을 사용해서 JavaScript 코드 문자열 평가하기

다음 예제에서는 `eval()`을 사용하여 `str` 문자열을 평가합니다. 이 문자열은 `x`가 5이면 로그를 출력한 다음 `z`에 42를 할당하고, 그렇지 않으면 `z`에 0 을 할당하는 JavaScript 코드입니다. 두 번째 문장이 실행되면, `eval()`은 이 문장의 집합을 수행하고, `z`에 할당된 값을 반환합니다.

```js
var x = 5;
var str = "if (x == 5) {console.log('z is 42'); z = 42;} else z = 0; ";

console.log("z is ", eval(str));
```

여러 값을 정의할 경우 마지막 값을 반환합니다.

```js
var x = 5;
var str = "if (x == 5) {console.log('z is 42'); z = 42; x = 420; } else z = 0;";

console.log("x is ", eval(str)); // z는 42, x는 420
```

### 마지막 표현식이 수행된다

`eval()` 은 마지막 표현식의 평가값을 반환합니다.

```js
var str = "if ( a ) { 1+1; } else { 1+2; }";
var a = true;
var b = eval(str); // 2를 반환

console.log("b is : " + b);

a = false;
b = eval(str); // 3을 반환

console.log("b is : " + b);
```

### 함수 정의 문자열로서의 `eval` 은 앞뒤를 "("와 ")"로 감싸야 한다

```js
var fctStr1 = "function a() {}";
var fctStr2 = "(function a() {})";
var fct1 = eval(fctStr1); // undefined를 반환
var fct2 = eval(fctStr2); // 함수를 반환
```

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

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

참고
--

* `uneval()` (en-US)
* 속성 접근자
* WebExtensions: Using eval in content scripts


undefined - JavaScript

undefined
=========

 전역 **`undefined`** 속성은 `undefined` 원시 값을 나타내며,
 JavaScript의 원시 자료형 중 하나입니다.

시도해보기
-----

값
-

`undefined`의 원시 값입니다.

| Property attributes of `undefined` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`undefined`는 전역 객체의 속성입니다. 즉, 전역 범위에서의 변수입니다.

최신 브라우저에서 `undefined`는 설정 불가, 쓰기 불가한 속성입니다. 그렇지 않더라도 덮어쓰는건 피하는게 좋습니다.

값을 할당하지 않은 변수는 `undefined` 자료형입니다. 메서드나 선언도 평가할 변수가 값을 할당받지 않은 경우에 `undefined`를 반환합니다. 함수는 값을 명시적으로 `반환`하지 않으면 `undefined`를 반환합니다.

**참고:** 전역 범위 이외의 모든 범위에서 식별자 (변수 이름)로 `undefined`를 사용할 수 있지만(`undefined`는 예약어 (en-US)가 아니기 때문에), 그렇게 하는 것은 매우 나쁜 생각입니다. 코드를 유지보수하고 디버깅하기 어렵게 만듭니다.

```js
// DON'T DO THIS

(() => {
  const undefined = "foo";
  console.log(undefined, typeof undefined); // foo string
})();

((undefined) => {
  console.log(undefined, typeof undefined); // foo string
})("foo");
```

예제
--

### 엄격한 일치 연산과 `undefined`

`undefined`와 엄격한 일치, 불일치 연산자를 사용해 변수에 값이 있는지 확인할 수 있습니다. 다음 코드에서 변수 `x`는 초기화되지 않았으며, `if`문은 참으로 평가됩니다.

```js
let x;
if (x === undefined) {
  // 이 문이 실행됨
} else {
  // 이 문이 실행되지 않음
}
```

**참고:**: `x == undefined`는 `x`가 `null`일 때도 참이기 때문에, 엄격한 동등 연산자(표준 동등 연산자와 반대로)를 사용해야 합니다.
 반면에, 엄격한 동등 연산자는 그렇지 않습니다. 이것은 `null`이 `undefined`하고 동일하지 않기 때문입니다.

자세한 내용은 Equality comparison and sameness 문서를 확인하세요.

### `typeof` 연산자와 `undefined`

위의 예제 대신 `typeof`를 사용할 수도 있습니다.

```js
let x;
if (typeof x === "undefined") {
  // 이 문이 실행됨
}
```

`typeof`를 사용하는 한 가지 이유는 변수가 선언되지 않은 경우 오류를 발생시키지 않기 때문입니다.

```js
// x를 선언한 적 없음
// 오류 없이 true로 평가
if (typeof x === "undefined") {
  // 이 문이 실행됨
}

// ReferenceError 발생
if (x === undefined) {
}
```

그러나 다른 방법도 있습니다. JavaScript는 정적 범위를 가지는 언어이므로, 변수의 선언 여부는 현재 컨텍스트의 코드를 읽어 알 수 있습니다.

전역 범위는 전역 객체에 바인딩되므로, 전역 컨텍스트에서 변수의 존재 유무는 `in` 연산자를 전역 객체 대상으로 실행해 알 수 있습니다. 예를들어,

```js
if ("x" in window) {
  // x가 전역으로 정의된 경우 이 문이 실행됨
}
```

### `void` 연산자와 `undefined`

`void` 연산자는 세번째 대안입니다.

```js
let x;
if (x === void 0) {
  // 이 문이 실행됨
}

// y를 이전에 선언하지 않음
if (y === void 0) {
  // throws Uncaught ReferenceError: y is not defined
}
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-undefined |

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

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

같이 보기
-----

* JavaScript의 원시 값
* `null`


Date - JavaScript

Date
====

 JavaScript **`Date`** 객체는 시간의 한 점을 플랫폼에 종속되지 않는 형태로 나타냅니다.
 `Date` 객체는 1970년 1월 1일 UTC(협정 세계시) 자정과의 시간 차이를 밀리초로 나타내는 정수 값을 담습니다.

**참고:** TC39에서 새로운 날짜/시간 API인 Temporal을 작업 중입니다. Igalia 블로그에서 더 알아보세요. 아직 프로덕션에는 적합하지 않습니다!

설명
--

### ECMAScript 시간과 타임스탬프

 JavaScript 날짜의 기반은 1970년 1월 1일 UTC 자정과의 시간 차이를 밀리초 단위로 나타낸 것으로, 날짜와 시간의 컴퓨터
 기록물을 대부분 차지하고 있는 **UNIX 시간**(UNIX epoch, 1970년 1월 1일 자정과의 시간 차이를 초 단위로
 나타냄)과는 다릅니다.

**참고:** `Date` 객체의 중심을 구성하는 시간 값은 UTC 기준이지만, 날짜와 시간 등 구성 요소를
 가져오는 메서드는 모두 현지(호스트 시스템의 위치)의 시간대를 사용한다는 것을 기억해야 합니다.

`Date`의 최대 값은 JavaScript에서의 안전한 최대 정수와 같지 않습니다.
 (`Number.MAX_SAFE_INTEGER`는 9,007,199,254,740,991입니다.) 대신, ECMA-262는 1970년 1월 1일 UTC에서
 ±100,000,000일(1억일)을 표준 `Date` 객체의 최대 범위로 규정하고 있습니다. 이는 기원전 271821년 4월 20일부터
 서력 275760년 9월 13일까지에 해당하는 범위로, ±8,640,000,000,000,000 밀리초와 같습니다.

### 날짜 형식과 시간대 변환

 날짜를 얻거나 시간대끼리 변환하는 메서드가 다수 존재하며, 그 중 특히 유용한 함수는 날짜 및 시간을 국제 표준 시간인
 협정 세계시(UTC)로 반환하는 함수입니다. (UTC는 그리니치 시간대라고도 불리는데, 기준 시간대가 영국의 런던 인근인
 그리니치를 지나는 경선이기 때문입니다.) 사용자의 장치는 현지 시간을 제공합니다.

`getDay()`와 `setHours()`처럼 구성 요소를 현지 시간 기준으로
 읽고 쓰는 메서드에는 `getUTCDay()`와 `setUTCHours()`처럼
 UTC를 기준으로 하는 읽기/쓰기 메서드도 존재합니다.

생성자
---

`Date()`

함수로 호출할 경우 `new Date().toString()`과 동일하게 현재 날짜와 시간을 나타내는 문자열을 반환합니다.

`new Date()`

생성자로 호출할 경우 새로운 `Date` 객체를 반환합니다.

정적 메서드
------

`Date.now()`

1970년 1월 1일 00:00:00 UTC로부터 지난 시간을 밀리초 단위의 숫자 값으로 반환합니다. 윤초는 무시합니다.

`Date.parse()`

날짜를 나타내는 문자열을 분석한 후, 해당 날짜와 1970년 1월 1일 00:00:00 UTC의 시간 차이를 밀리초 단위의 숫자 값으로 반환합니다.

**참고:** `Date.parse()`를 사용한 날짜 분석은 브라우저 간 차이 및 일관적이지 못한 동작을
 가지고 있으므로 사용하지 않는 것이 좋습니다.

`Date.UTC()`

 생성자가 받을 수 있는 제일 많은 매개변수(구성요소 각각, 2개 ~ 7개)를 동일하게 받아서, 1970년 1월 1일 00:00:00 UTC의
 시간 차이를 밀리초 단위의 숫자 값으로 반환합니다. 윤초는 무시합니다.

인스턴스 메서드
--------

`Date.prototype.getDate()`

`Date`에서 현지 시간 기준 일(`1`–`31`)을 반환합니다.

`Date.prototype.getDay()`

`Date`에서 현지 시간 기준 요일(`0`–`6`)을 반환합니다.

`Date.prototype.getFullYear()`

`Date`에서 현지 시간 기준 연도(네 자리 연도면 네 자리로)를 반환합니다.

`Date.prototype.getHours()`

`Date`에서 현지 시간 기준 시(`0`–`23`)를 반환합니다.

`Date.prototype.getMilliseconds()`

`Date`에서 현지 시간 기준 밀리초(`0`–`999`)를 반환합니다.

`Date.prototype.getMinutes()`

`Date`에서 현지 시간 기준 분(`0`–`59`)을 반환합니다.

`Date.prototype.getMonth()`

`Date`에서 현지 시간 기준 월(`0`–`11`)을 반환합니다.

`Date.prototype.getSeconds()`

`Date`에서 현지 시간 기준 초(`0`–`59`)를 반환합니다.

`Date.prototype.getTime()`

 1970년 1월 1일 00:00:00 UTC로부터의 경과시간을 밀리초 단위로 반환합니다. `Date`가 기준
 시간 이전을 나타낼 경우 음수 값을 반환합니다.

`Date.prototype.getTimezoneOffset()`

현지 시간대와 UTC의 차이를 분 단위로 반환합니다.

`Date.prototype.getUTCDate()`

`Date`에서 국제 시간 기준 일(`1`–`31`)을 반환합니다.

`Date.prototype.getUTCDay()`

`Date`에서 국제 시간 기준 요일(`0`–`6`)을 반환합니다.

`Date.prototype.getUTCFullYear()`

`Date`에서 국제 시간 기준 연도(네 자리 연도면 네 자리로)를 반환합니다.

`Date.prototype.getUTCHours()`

`Date`에서 국제 시간 기준 시(`0`–`23`)를 반환합니다.

`Date.prototype.getUTCMilliseconds()`

`Date`에서 국제 시간 기준 밀리초(`0`–`999`)를 반환합니다.

`Date.prototype.getUTCMinutes()`

`Date`에서 국제 시간 기준 분(`0`–`59`)을 반환합니다.

`Date.prototype.getUTCMonth()`

`Date`에서 국제 시간 기준 월(`0`–`11`)을 반환합니다.

`Date.prototype.getUTCSeconds()`

`Date`에서 국제 시간 기준 초(`0`–`59`)를 반환합니다.

`Date.prototype.setDate()`

현지 시간 기준으로 일을 설정합니다.

`Date.prototype.setFullYear()`

현지 시간 기준으로 연도(네 자리 연도면 네 자리로)를 설정합니다.

`Date.prototype.setHours()`

현지 시간 기준으로 시를 설정합니다.

`Date.prototype.setMilliseconds()`

현지 시간 기준으로 밀리초를 설정합니다.

`Date.prototype.setMinutes()`

현지 시간 기준으로 분을 설정합니다.

`Date.prototype.setMonth()`

현지 시간 기준으로 월을 설정합니다.

`Date.prototype.setSeconds()`

현지 시간 기준으로 초를 설정합니다.

`Date.prototype.setTime()`

`Date`가 나타낼 시간을 1970년 1월 1일 00:00:00 UTC로부터의 경과시간(밀리초)으로 설정합니다. 기준 이전의 시간은 음수 값을 사용해 설정할 수 있습니다.

`Date.prototype.setUTCDate()`

국제 시간 기준으로 일을 설정합니다.

`Date.prototype.setUTCFullYear()`

국제 시간 기준으로 연도(네 자리 연도면 네 자리로)를 설정합니다.

`Date.prototype.setUTCHours()`

국제 시간 기준으로 시를 설정합니다.

`Date.prototype.setUTCMilliseconds()`

국제 시간 기준으로 밀리초를 설정합니다.

`Date.prototype.setUTCMinutes()`

국제 시간 기준으로 분을 설정합니다.

`Date.prototype.setUTCMonth()`

국제 시간 기준으로 월을 설정합니다.

`Date.prototype.setUTCSeconds()`

국제 시간 기준으로 초를 설정합니다.

`Date.prototype.toDateString()` (en-US)

`Date`의 날짜 부분만 나타내는, 사람이 읽을 수 있는 문자열을 반환합니다.

`Date.prototype.toISOString()`

`Date`를 나타내는 문자열을 ISO 8601 확장 형식에 맞춰 반환합니다.

`Date.prototype.toJSON()`

`toISOString()`을 사용해서 `Date`를 나타내는 문자열을
 반환합니다. `JSON.stringify()`에서 사용합니다.

`Date.prototype.toLocaleDateString()` (en-US)

`Date`의 날짜 부분을 나타내는 문자열을 시스템에 설정된 현재 지역의 형식으로 반환합니다.

`Date.prototype.toLocaleFormat()`

형식 문자열을 사용해서 `Date`를 나타내는 문자열을 생성합니다.

`Date.prototype.toLocaleString()`

`Date`를 나타내는 문자열을 현재 지역의 형식으로 반환합니다.
 `Object.prototype.toLocaleString()` 메서드를 재정의합니다.

`Date.prototype.toLocaleTimeString()` (en-US)

`Date`의 시간 부분을 나타내는 문자열을 시스템에 설정된 현재 지역의 형식으로 반환합니다.

`Date.prototype.toString()`

`Date`를 나타내는 시간 문자열을 반환합니다. `Object.prototype.toString()` 메서드를
 재정의합니다.

`Date.prototype.toTimeString()` (en-US)

`Date`의 시간 부분만 나타내는, 사람이 읽을 수 있는 문자열을 반환합니다.

`Date.prototype.toUTCString()`

`Date`를 나타내는 문자열을 UTC 기준으로 반환합니다.

`Date.prototype.valueOf()`

`Date` 객체의 원시 값을 반환합니다. `Object.prototype.valueOf()` 메서드를 재정의합니다.

예제
--

### Date 객체를 만드는 여러가지 방법

아래 예제는 JavaScript 날짜를 생성하는 몇 가지 방법을 보입니다.

**참고:** `Date` 생성자(및 동일한 동작의 `Date.parse()`)를 사용한 날짜 분석은
 동작이 일관적이지 못하고 브라우저끼리 차이가 존재하므로 사용하지 않는 것이 좋습니다.

```js
let today = new Date();
let birthday = new Date("December 17, 1995 03:24:00");
let birthday = new Date("1995-12-17T03:24:00");
let birthday = new Date(1995, 11, 17); // 월은 0부터 시작
let birthday = new Date(1995, 11, 17, 3, 24, 0);
```

### 두 자리 연도는 1900년대로

`Date`의 연도에 `0`부터 `99`까지의 정수를 제공하면 `1900`부터
 `1999`로 처리합니다. 다른 모든 값은 그대로 사용합니다.

 1900년대가 아닌, 실제 `0` ~ `99`년을 지정해야 하면 `Date.prototype.setFullYear()`와
 `Date.prototype.getFullYear()` 메서드를 사용해야 합니다.

```js
let date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0900 (대한민국 표준시)

// 구형 메서드: 여기서도 98을 1998로 처리
date.setYear(98); // Sun Feb 01 1998 00:00:00 GMT+0900 (대한민국 표준시)

date.setFullYear(98); // Sat Feb 01 0098 00:00:00 GMT+0827 (대한민국 표준시)
```

### 경과시간 계산

다음은 두 개의 JavaScript 날짜의 간격을 밀리초로 나타내는 예제입니다.

 연, 월, 일(서머타임)의 길이가 계속해서 달라지므로, 두 시간의 간격을 시/분/초보다 큰 단위로 나타낼 땐 여러가지 문제가
 생기므로 이 방법을 시도하기 전에 관련 문제를 먼저 자세히 알아보세요.

```js
// Date 객체 사용법
let start = Date.now();

// 시간이 오래 걸리는 어떤 작업
doSomethingForALongTime();
let end = Date.now();
let elapsed = end - start; // 밀리초로 나타낸 경과시간
```

```js
// 내장 메서드 사용법
let start = new Date();

// 시간이 오래 걸리는 어떤 작업
doSomethingForALongTime();
let end = new Date();
let elapsed = end.getTime() - start.getTime(); // 밀리초로 나타낸 경과시간
```

```js
// 임의의 함수를 테스트하고, 호출에 걸린 시간을 출력하려면
function printElapsedTime(fTest) {
  let nStartTime = Date.now(),
    vReturn = fTest(),
    nEndTime = Date.now();

  console.log(`Elapsed time: ${String(nEndTime - nStartTime)} milliseconds`);
  return vReturn;
}

let yourFunctionReturn = printElapsedTime(yourFunction);
```

**참고:** Web Performance API (en-US)의 고해상도 시간 기능을
 지원하는 브라우저에서는 `Performance.now()` (en-US)를 사용해서 `Date.now()`보다 더 안정적이고
 정확한 경과 시간을 알아낼 수 있습니다.

### ECMAScript 시간으로부터 경과한 시간을 초 단위로 가져오기

```js
let seconds = Math.floor(Date.now() / 1000);
```

 여기서는 정수만 반환하는 것이 중요하므로, 단순히 나누기만 해서는 충분하지 않습니다. 그리고 실제로 "지나간" 초를
 반환해야 하므로 `Math.round()`를 사용하지 않고 `Math.floor()`를 사용합니다.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date-objects |

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

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

같이 보기
-----

* `Date()` 생성자


Uint8ClampedArray - JavaScript

Uint8ClampedArray
=================

**`Uint8ClampedArray`** 형식화 배열(TypedArray)은 0-255로 고정된 8비트 부호 없는 정수의 배열입니다.
 [0,255] 범위를 벗어나는 값을 지정하면 대신 0 또는 255가 대신 설정됩니다. 정수가 아닌 값을 지정하면 그 값과 가장 가까운 정수가
 설정됩니다. 배열의 내용은 0으로 초기화됩니다. 배열이 생성되면 객체의 메서드를 사용하거나 표준 배열 인덱스 구문(즉, 대괄호 표기법 사용)을
 사용하여 배열의 요소를 참조할 수 있습니다.

생성자
---

`Uint8ClampedArray()`

새로운 `Uint8ClampedArray` 객체를 생성합니다.

정적 속성
-----

부모 `TypedArray`에서 정적 속성을 상속합니다.

`Uint8ClampedArray.BYTES_PER_ELEMENT`

요소 크기를 숫자 값으로 반환합니다. `Uint8ClampedArray`의 경우 `1` 입니다.

`Uint8ClampedArray.name`

생성자 이름을 문자열로 반환합니다. `Uint8ClampedArray` 타입의 경우 `"Uint8ClampedArray"`입니다.

정적 메서드
------

부모 `TypedArray`에서 정적 메서드를 상속합니다.

인스턴스 속성
-------

부모 `TypedArray`에서 인스턴스 속성을 상속합니다.

`Uint8ClampedArray.prototype.BYTES_PER_ELEMENT`

요소 크기를 숫자 값으로 반환합니다. `Uint8ClampedArray`의 경우 `1`입니다.

인스턴스 메서드
--------

부모 `TypedArray`에서 인스턴스 메서드를 상속합니다.

예제
--

### Uint8ClampedArray 를 생성하기 위한 각기 다른 여러 방법

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

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

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

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

// 순회로부터 생성
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const uintc8FromIterable = new Uint8ClampedArray(iterable);
console.log(uintc8FromIterable);
// Uint8ClampedArray [1, 2, 3]
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

같이 보기
-----

* `core-js`에서 `Uint8ClampedArray`의 폴리필
* JavaScript 형식화 배열
* `ArrayBuffer`
* `DataView`


Boolean - JavaScript

Boolean
=======

**`Boolean`** 객체는 불리언 값을 감싸고 있는 객체입니다.

설명
--

첫 번째 매개변수로서 전달한 값은 필요한 경우 불리언 값으로 변환됩니다. 값이 없거나 `0`, `-0`, `null`, `false`, `NaN`, `undefined`, 빈 문자열 (`""`)이라면 객체의 초기값은 `false`가 됩니다. 문자열 `"false"`를 포함한 그 외 모든 다른 값은 초기값을 `true`로 설정합니다.

`Boolean` 객체의 `true`와 `false` 값을 원시 `Boolean` 값 `true`, `false`와 혼동해선 안됩니다.

값이 `undefined`, `null`이 아닌 **모든** 객체는 조건문에서 `true`로 계산됩니다. 이는 값이 `false`인 `Boolean` 객체도 포함합니다. 즉 아래 `if` 문의 조건은 참입니다.

```js
var x = new Boolean(false);
if (x) {
  // 이 코드는 실행됨
}
```

그러나 원시 `Boolean` 값에는 적용되지 않습니다. 따라서 아래 `if` 문의 조건은 거짓입니다.

```js
var x = false;
if (x) {
  // 이 코드는 실행되지 않음
}
```

불리언이 아닌 값을 변환할 때 `Boolean` 객체를 사용해선 안됩니다. 대신 `Boolean` 함수를 사용하세요.

```js
var x = Boolean(expression); // 추천
var x = new Boolean(expression); // 사용하지 말것
```

값이 `false`인 `Boolean` 객체를 포함한 어떠한 객체를 `Boolean` 객체의 초기값으로 넘겨주더라도 새로운 `Boolean` 객체는 `true`를 가집니다.

```js
var myFalse = new Boolean(false); // 초기값 거짓
var g = Boolean(myFalse); // 초기값 참
var myString = new String("Hello"); // 문자열 객체
var s = Boolean(myString); // 초기값 참
```

`Boolean` 원시 값의 자리에서 `Boolean` 객체를 이용해선 안됩니다.

생성자
---

`Boolean()`

`Boolean` 객체를 생성합니다.

인스턴스 메서드
--------

`Boolean.prototype.toString()`

객체의 값에 따라 문자열 `"true"` 또는 `"false"`를 반환합니다. `Object.prototype.toString()` 메서드를 재정의합니다.

`Boolean.prototype.valueOf()`

`Boolean` 객체의 원시값을 반환합니다. `Object.prototype.valueOf()` 메서드를 재정의합니다.

예제
--

### `false` 값으로 초기화한 `Boolean` 객체 만들기

```js
var bNoParam = new Boolean();
var bZero = new Boolean(0);
var bNull = new Boolean(null);
var bEmptyString = new Boolean("");
var bfalse = new Boolean(false);
```

### `true` 값으로 초기화한 `Boolean` 객체 만들기

```js
var btrue = new Boolean(true);
var btrueString = new Boolean("true");
var bfalseString = new Boolean("false");
var bSuLin = new Boolean("Su Lin");
var bArrayProto = new Boolean([]);
var bObjProto = new Boolean({});
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean-objects |

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

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

같이 보기
-----

* Boolean
* 불리언 자료형


WeakSet - JavaScript

WeakSet
=======

**`WeakSet`** 객체는 약하게 유지되는(held, 잡아두는) *객체*를 컬렉션에 저장할 수 있습니다.

설명
--

`WeakSet` 객체는 객체 컬렉션입니다. `WeakSet` 내 객체는 오직 한 번만 발생할 수 있습니다. 즉, `WeakSet` 컬렉션 내에서 유일합니다.

`Set` (en-US) 객체와 주된 차이는 다음과 같습니다:

* `Set`과 달리, `WeakSet`은 **객체 만의 컬렉션**이며 모든 유형의 임의 값(의 컬렉션)은 아닙니다.
* `WeakSet`은 약합니다(*weak*): 컬렉션 내 객체 참조는 약하게 유지됩니다. `WeakSet` 내 저장된 객체에 다른 참조가 없는 경우, 쓰레기 수집(garbage collection)될 수 있습니다. 이는 또한 컬렉션 내 현재 저장된 객체 목록이 없음을 뜻합니다. `WeakSets`은 열거불가입니다.
생성자
---

`WeakSet()` (en-US)

Creates a new `WeakSet` object.

인스턴스 메서드
--------

`WeakSet.prototype.add(value)` (en-US)

Appends `value` to the `WeakSet` object.

`WeakSet.prototype.delete(value)` (en-US)

Removes `value` from the `WeakSet`. `WeakSet.prototype.has(value)` will return `false` afterwards.

`WeakSet.prototype.has(value)` (en-US)

Returns a boolean asserting whether `value` is present in the `WeakSet` object or not.

예제
--

### `WeakSet` 객체 사용

```js
var ws = new WeakSet();
var obj = {};
var foo = {};

ws.add(window);
ws.add(obj);

ws.has(window); // true
ws.has(foo); // false, foo가 집합에 추가되지 않았음

ws.delete(window); // 집합에서 window 제거함
ws.has(window); // false, window가 제거되었음
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakset-objects |

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

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

같이 보기
-----

* Polyfill of `WeakSet` in `core-js`
* `Map`
* `Set` (en-US)
* `WeakMap`


decodeURI() - JavaScript

decodeURI()
===========

**`decodeURI()`** 함수는 `encodeURI`이나 비슷한 루틴으로 사전에 만들어진 URI(Uniform Resource Identifier, 인터넷식별자)를 디코딩합니다.

시도해보기
-----

구문
--

```js
decodeURI(encodedURI)
```

### 매개변수

`encodedURI`

완전하고 인코딩된 인터넷식별자(URI)

### 반환값

주어진 인코딩된 URI를 디코딩한 새 문자열을 반환합니다.

### 예외

`encodedURI`에 유효하지 않은 문자열이 포함된 경우 `URIError` ("malformed URI sequence") 예외가 발생합니다.

설명
--

인코딩된 URI의 각 이스케이프 시퀀스(확장문자열)를 자신을 나타내는 문자로 바꾸지만 `encodeURI`에서 도입할 수 없었던 이스케이프 시퀀스는 해독하지 않습니다. `#`문자는 이스케이프 시퀀스에서 디코딩되지 않습니다.

예제
--

### 키릴 URL 디코딩

```js
decodeURI(
  "https://developer.mozilla.org/ru/docs/JavaScript\_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B",
);
// "https://developer.mozilla.org/ru/docs/JavaScript\_шеллы"
```

### 예외 처리

```js
try {
  var a = decodeURI("%E0%A4%A");
} catch (e) {
  console.error(e);
}

// URIError: malformed URI sequence
```

사양
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-decodeuri-encodeduri |

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

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

같이 보기
-----

* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`


ArrayBuffer - JavaScript

ArrayBuffer
===========

**`ArrayBuffer`** 객체는 일반적인 고정 길이 원시 이진 데이터 버퍼를 나타냅니다.

ArrayBuffer는 바이트로 구성된 배열로, 다른 언어에서는 종종 "바이트 배열"이라고 부릅니다. `ArrayBuffer`에 담긴 정보를 직접 수정하는 것은 불가능하지만, 대신 형식화 배열이나 `DataView` 객체를 통해 버퍼를 특정 형식으로 나타내고, 이를 통해 버퍼의 내용을 읽거나 쓸 수 있습니다.

`ArrayBuffer()` 생성자는 주어진 길이(바이트)를 가진 새로운 `ArrayBuffer`를 생성합니다. Base64 문자열이나 로컬 파일 (en-US)과 같은 기존 데이터에서도 배열 버퍼를 생성할 수 있습니다.

`ArrayBuffer`는 Transferable objects (en-US)입니다.

생성자
---

`ArrayBuffer()`

새로운 `ArrayBuffer` 객체를 생성합니다.

정적 속성
-----

`get ArrayBuffer[@@species]` (en-US)

파생 개체를 만드는 데 사용되는 생성자 함수입니다.

정적 메서드
------

`ArrayBuffer.isView(arg)`

`arg` 유형이 형식화 배열 객체이거나 `DataView`와 같은 ArrayBuffer 중 하나인 경우, `true`를 반환합니다. 그렇지 않으면 `false`를 반환합니다.

인스턴스 속성
-------

`ArrayBuffer.prototype.byteLength`

ArrayBuffer의 읽기 전용 크기(바이트)입니다. 배열리 구성될 때 설정되며 변경할 수 없습니다.

인스턴스 메서드
--------

`ArrayBuffer.prototype.slice()`

컨탠츠의 `begin`(포함)부터 `end`(제외)까지 해당 `ArrayBuffer`의 바이트 복사본인 새 `ArrayBuffer`를 반환합니다. `begin` 또는 `end`가 음수이면 처음부터가 아니라 배열 끝에서 인덱스를 참조합니다.

예제
--

### ArrayBuffer 만들기

이 예에서는 버퍼를 참조하는 `Int32Array` 뷰가 있는 8바이트 버퍼를 만듭니다.

```js
const buffer = new ArrayBuffer(8);
const view = new Int32Array(buffer);
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-arraybuffer-objects |

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

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

같이 보기
-----

* Polyfill of `ArrayBuffer` in `core-js`
* JavaScript 형식화 배열
* `SharedArrayBuffer`
* RangeError: invalid array length


JSON - JavaScript

JSON
====

**`JSON`** 객체는 JavaScript Object Notation(JSON)을 분석하거나 값을 JSON으로 변환하는 메서드를 가지고 있습니다. `JSON`을 직접 호출하거나 인스턴스를 생성할 수 없으며, 두 개의 메서드를 제외하면 자신만의 흥미로운 기능은 없습니다.

JavaScript와 JSON의 차이
--------------------

JSON은 객체, 배열, 숫자, 문자열, 불리언과 `null`을 직렬화하기 위한 구문으로, JavaScript 구문에 기반을 두고 있지만 분명한 차이점을 가지고 있습니다. 즉, 어떤 JavaScript는 JSON이 아닙니다.

객체와 배열

속성의 이름은 반드시 큰따옴표로 표시된 문자열이어야 합니다. 후행 쉼표는 허용하지 않습니다.

숫자

선행 0은 허용하지 않습니다. 소숫점 뒤에는 적어도 한 자릿수가 뒤따라야 합니다. `NaN`과 `Infinity`는 지원하지 않습니다.

모든 JSON 텍스트는 유효한 JavaScript 표현식...

...이지만, 모든 JSON 텍스트를 올바른 ECMA-262로 만드는 제안을 구현한 JavaScript 엔진에서만 그러합니다. 다른 엔진에서는, U+2028 LINE SEPARATOR와 U+2029 PARAGRAPH SEPARATOR를 JSON에서 스트링 리터럴과 속성의 키로 사용할 수 있지만, JavaScript 문자열 리터럴에서 사용하면 `SyntaxError`가 발생합니다.

`JSON.parse()`로 JSON 문자열을 분석하고 `eval` (en-US)이 JavaScript 문자열로 실행하는 다음 예시를 참고하세요.

```js
const code = '"\u2028\u2029"';
JSON.parse(code); // 모든 엔진에서 "\u2028\u2029"로 평가
eval(code); // 오래된 엔진에서 SyntaxError
```

다른 차이점으로는 문자열의 작은따옴표 금지와, 주석 및 `undefined` 미지원이 있습니다. JSON에 기반한, 보다 사람 친화적인 설정 형식을 원하면 Babel 컴파일러가 사용하는 JSON5가 있고, 좀 더 많이 쓰이는 YAML도 있습니다.

전체 JSON 구문
----------

```js
    JSON = null
        or true or false
        or JSONNumber
        or JSONString
        or JSONObject
        or JSONArray

    JSONNumber = - PositiveNumber
              or PositiveNumber
    PositiveNumber = DecimalNumber
                  or DecimalNumber . Digits
                  or DecimalNumber . Digits ExponentPart
                  or DecimalNumber ExponentPart
    DecimalNumber = 0
                 or OneToNine Digits
    ExponentPart = e Exponent
                or E Exponent
    Exponent = Digits
            or + Digits
            or - Digits
    Digits = Digit
          or Digits Digit
    Digit = 0 through 9
    OneToNine = 1 through 9

    JSONString = ""
              or " StringCharacters "
    StringCharacters = StringCharacter
                    or StringCharacters StringCharacter
    StringCharacter = any character
                      except " or \ or U+0000 through U+001F
                   or EscapeSequence
    EscapeSequence = \" or \/ or \\ or \b or \f or \n or \r or \t
                  or \u HexDigit HexDigit HexDigit HexDigit
    HexDigit = 0 through 9
            or A through F
            or a through f

    JSONObject = { }
              or { Members }
    Members = JSONString : JSON
           or Members , JSONString : JSON

    JSONArray = [ ]
             or [ ArrayElements ]
    ArrayElements = JSON
                 or ArrayElements , JSON
```

중요하지 않은 공백은 `JSONNumber`(숫자에는 공백이 없어야 함) 또는 `JSONString`(문자열에서 해당 문자로 해석되거나 오류를 일으킴) 내를 제외하고 어디에나 존재할 수 있습니다. 탭 문자(U+0009), 캐리지 리턴(U+000D), 라인 피드(U+000A) 및 스페이스(U+0020) 문자만이 유효한 공백 문자입니다.

메서드
---

`JSON.parse()`

문자열을 JSON으로서 구문 분석하고, 선택적으로 분석 결과의 값과 속성을 변환해 반환합니다.

`JSON.stringify()`

주어진 값에 해당하는 JSON 문자열을 반환합니다. 선택 사항으로 특정 속성만 포함하거나 사용자 정의 방식으로 속성을 대체합니다.

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-json-object |

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

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

같이 보기
-----

* `Date.prototype.toJSON()`


EvalError - JavaScript

EvalError
=========

**`EvalError`** 객체는 전역 `eval()` 함수에 관한 오류를 나타냅니다. 이 예외는 JavaScript에 의해 더 이상 발생하지 않지만 `EvalError` 객체는 하위 호환성을 위해 남아있습니다.

Constructor
-----------

`EvalError()` (en-US)

Creates a new `EvalError` object.

Instance properties
-------------------

`EvalError.prototype.message`

Error message.

`EvalError.prototype.name`

Error name. Inherited from `Error`.

`EvalError.prototype.fileName`

Path to file that raised this error. Inherited from `Error`.

`EvalError.prototype.lineNumber`

Line number in file that raised this error. Inherited from `Error`.

`EvalError.prototype.columnNumber`

Column number in line that raised this error. Inherited from `Error`.

`EvalError.prototype.stack` (en-US)

Stack trace. Inherited from `Error`.

예제
--

`EvalError`는 현재 ECMAScript 사양에서 사용되지 않으므로 런타임에 의해 throw되지 않습니다. 그러나 개체 자체는 이전 버전의 사양과의 하위 호환성을 유지합니다.

### Creating an EvalError

```js
try {
  throw new EvalError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof EvalError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "EvalError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-native-error-types-used-in-this-standard-evalerror |

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

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

같이 보기
-----

* `Error`
* `eval()`


String - JavaScript

String
======

**`String`** 전역 객체는 문자열(문자의 나열)의 생성자입니다.

구문
--

문자열 리터럴은 다음과 같은 형식을 사용합니다.
```

'string text'
"string text"
"中文 español Deutsch English देवनागरी العربية português বাংলা русский 日本語 norsk bokmål ਪੰਜਾਬੀ 한국어 தமிழ் עברית"
```

문자열은 `String` 전역 객체를 직접 사용하여 생성할 수 있습니다.

```js
String(thing);
```

### 매개변수

`thing`
문자열로 변환할 아무 값.
### 템플릿 리터럴

ECMAScript 2015 이후, 문자열 리터럴은 소위 템플릿 리터럴이 될 수 있습니다.
```

`hello world` `hello! world!` `hello ${who}` tag `<a>${who}</a>`
```
### 이스케이프 표현

일반적인 출력 문자 외의 특수 문자는 이스케이프 표현을 사용해 적을 수 있습니다.

| 코드 | 출력 |
| --- | --- |
| `\XXX` | 8진수 Latin-1 문자 |
| `\'` | 작은따옴표 |
| `\"` | 큰따옴표 |
| `\\` | 역슬래시 |
| `\n` | 개행 |
| `\r` | 캐리지 리턴 |
| `\v` | 세로 탭 |
| `\t` | 탭 |
| `\b` | 백 스페이스 |
| `\f` | 폼 피드 |
| `\uXXXX` | 유니코드 코드포인트 |
| `\u{X}` ... `\u{XXXXXX}` | 유니코드 코드포인트
Experimental
 |
| `\xXX` | Latin-1 문자 |

**참고:** 일부 다른 프로그래밍 언어와 달리, JavaScript는 작은따옴표와 큰따옴표 문자열을 구분하지 않습니다. 따라서 위의 이스케이프 문자는 작은따옴표나 큰따옴표에서 상관 없이 작동합니다.

### 긴 문자열 리터럴

작성한 코드가 매우 긴 문자열을 포함해야 하는 경우, 끝 없이 뻗어나가는 한 줄이나 편집기의 재량에 따라 자동으로 줄을 넘기는 대신 직접 여러 줄로 나누되 내용에는 영향을 주지 않고 싶을 때가 있을겁니다. 이런 상황에는 두 가지 방법을 사용할 수 있습니다.

우선 다음과 같이 + (en-US) 연산자를 사용할 수 있습니다.

```js
let longString =
  "여러 줄에 걸쳐 작성해야 할 정도로 " +
  "긴 문자열인데 왜 한 줄에 다 적으면 안되냐면 " +
  "코드를 읽기 힘들어지니까요.";
```

아니면 역슬래시 문자("\")를 각 줄의 맨 끝에 붙여 문자열이 이어진다는걸 표시할 수도 있습니다. 역슬래시 다음에 공백을 포함한 어떤 문자라도 붙으면 제대로 작동하지 않으므로 주의해야 합니다.

```js
let longString =
  "여러 줄에 걸쳐 작성해야 할 정도로 \
긴 문자열인데 왜 한 줄에 다 적으면 안되냐면 \
코드를 읽기 힘들어지니까요.";
```

두 예시 모두 동일한 문자열을 생성합니다.

설명
--

문자열은 텍스트 형태로 표현될 수있는 데이터를 보관하는 데 유용합니다. 문자열에서 가장 많이 사용되는 작업들은 문자열의 길이를 확인하는 (`length`), 문자열을 생성하고 연결하는 + 와 += 문자열 연산자, 서브문자열(substring)이 있는지 확인하고, 있으면 위치를 확인하는 `indexOf()` 메서드, 서브문자열(substring)을 추출해내는 `substring()` 메서드가 있습니다.

### 문자 접근

문자열에서 개개의 문자에 접근할 수 있는 방법은 두가지가 있습니다. 첫번째는 `charAt()` 메서드를 이용하는 것입니다:

```js
return "cat".charAt(1); // returns "a"
```

다른 방법(ECMAScript 5에서 소개하고 있는)은 문자열을 배열과 같은 오브젝트로 취급하여, 문자에 해당하는 숫자 인덱스를 사용하는 방법입니다 :

```js
return "cat"[1]; // returns "a"
```

브라켓([ ]) 표기법을 사용하여 문자에 접근하는 경우 , 이러한 프로퍼티들에 새로운 값을 할당하거나 삭제할 수는 없습니다. 포함되어 있는 프로퍼티들은 작성할 수도, 수정할 수도 없습니다. (더 자세한 정보는 `Object.defineProperty()`를 참고 바랍니다 .)

### 문자열 비교

C 개발자는 문자열 비교를 위하여 `strcmp()` 함수를 사용합니다. JavaScript에서는 단지 less-than와 greater-than 연산자 (en-US)만을 사용하여 문자열을 비교할 수 있습니다:

```js
var a = "a";
var b = "b";
if (a < b) {
  // true
  console.log(a + " is less than " + b);
} else if (a > b) {
  console.log(a + " is greater than " + b);
} else {
  console.log(a + " and " + b + " are equal.");
}
```

비슷한 결과를 얻을 수 있는 방법으로 String 인스턴스에서 상속된 `localeCompare()` 메서드를 사용할 수 있습니다.

### 문자열 원형과 `String` 객체의 차이

JavaScript는 `String` 오브젝트와 원형의 문자열을 다르게 취급한다는 것에 주의해야 합니다. (`Boolean`과 숫자의 true도 마찬가지입니다.)

문자열 리터럴(작은 따옴표 또는 큰 따옴표로 생성되는)과 생성자 없이(즉. `new` 키워드를 사용하지 않고) `String`을 호출하여 반환된 문자열은 원형 문자열(primitive strings)입니다. JavaScript는 자동적으로 원형을 `String` 오브젝트로 변환하기 때문에, `String` 오브젝트 메서드를 사용하여 원형문자열을 생성할 수 있습니다. 문맥 안의 메서드에서 프로퍼티 조회 또는 원형의 문자열 호출이 발생하면, JavaScript는 자동으로 문자열 원형을 감싸고 프로퍼티 조회를 수행 하거나 메서드를 호출합니다.

```js
var s_prim = "foo";
var s_obj = new String(s_prim);

console.log(typeof s_prim); // Logs "string"
console.log(typeof s_obj); // Logs "object"
```

문자열 원형과 `String` 오브젝트는 `eval()`을 사용할 때 다른 결과를 제공합니다. `eval`에 전달되는 문자열 원형들은 소스 코드 취급을 받습니다; `String` 오브젝트들은 다른 모든 오브젝트들과 마찬가지로 취급하며, 오브젝트를 반환합니다. 예를 들면:

```js
var s1 = "2 + 2"; // creates a string primitive
var s2 = new String("2 + 2"); // creates a String object
console.log(eval(s1)); // returns the number 4
console.log(eval(s2)); // returns the string "2 + 2"
```

이러한 이유로, 비록 코드 상에서 원형 문자열을 사용하는 대신에 `String` 오브젝트를 사용하게 되면 코드가 손상될 수 있지만, 일반적인 개발자는 차이를 걱정할 필요는 없습니다.

`String` 오브젝트는 언제든지 `valueOf()` 메서드로 원형에 대응하도록 전환할 수 있습니다.

```js
console.log(eval(s2.valueOf())); // returns the number 4
```

생성자
---

`String()` (en-US)

 Creates a new `String` object. It performs type conversion when called as
 a function, rather than as a constructor, which is usually more useful.

정적 메서드
------

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

지정된 유니코드 값의 순서를 이용하여 만든 문자열을 반환합니다.

`String.fromCodePoint(num1 [, ...[,
 numN)` (en-US)

지정된 코드 포인트 순서를 이용하여 만든 문자열을 반환합니다.

`String.raw()`

원형 템플릿 문자열(raw template string)에서 생성된 문자열을 반환합니다.

인스턴스 속성
-------

`String.prototype.length`

Reflects the `length` of the string. Read-only.

인스턴스 메서드
--------

`String.prototype.at(index)`
Experimental

Returns the character (exactly one UTF-16 code unit) at the specified `index`. Accepts negative integers, which count back from the last string character.

`String.prototype.charAt(index)`

 Returns the character (exactly one UTF-16 code unit) at the specified
 `index`.

`String.prototype.charCodeAt(index)` (en-US)

 Returns a number that is the UTF-16 code unit value at the given
 `index`.

`String.prototype.codePointAt(pos)` (en-US)

 Returns a nonnegative integer Number that is the code point value of the UTF-16
 encoded code point starting at the specified `pos`.

`String.prototype.concat(str [,
 ...strN ])`

Combines the text of two (or more) strings and returns a new string.

`String.prototype.includes(searchString [, position])`

Determines whether the calling string contains `searchString`.

`String.prototype.endsWith(searchString [, length])`

 Determines whether a string ends with the characters of the string
 `searchString`.

`String.prototype.indexOf(searchValue [, fromIndex])`

 Returns the index within the calling `String` object of the first
 occurrence of `searchValue`, or `-1` if not found.

`String.prototype.lastIndexOf(searchValue [, fromIndex])`

 Returns the index within the calling `String` object of the last
 occurrence of `searchValue`, or `-1` if not found.

`String.prototype.localeCompare(compareString [, locales [,
 options]])`

 Returns a number indicating whether the reference string
 `compareString` comes before, after, or is equivalent to the
 given string in sort order.

`String.prototype.match(regexp)`

Used to match regular expression `regexp` against a string.

`String.prototype.matchAll(regexp)` (en-US)

Returns an iterator of all `regexp`'s matches.

`String.prototype.normalize([form])`

Returns the Unicode Normalization Form of the calling string value.

`String.prototype.padEnd(targetLength [, padString])`

 Pads the current string from the end with a given string and returns a new string of
 the length `targetLength`.

`String.prototype.padStart(targetLength [, padString])`

 Pads the current string from the start with a given string and returns a new string
 of the length `targetLength`.

`String.prototype.repeat(count)`

 Returns a string consisting of the elements of the object repeated
 `count` times.

`String.prototype.replace(searchFor, replaceWith)` (en-US)

 Used to replace occurrences of `searchFor` using
 `replaceWith`. `searchFor` may be a string
 or Regular Expression, and `replaceWith` may be a string or
 function.

`String.prototype.replaceAll(searchFor, replaceWith)`

 Used to replace all occurrences of `searchFor` using
 `replaceWith`. `searchFor` may be a string
 or Regular Expression, and `replaceWith` may be a string or
 function.

`String.prototype.search(regexp)` (en-US)

 Search for a match between a regular expression `regexp` and
 the calling string.

`String.prototype.slice(beginIndex[,
 endIndex])`

Extracts a section of a string and returns a new string.

`String.prototype.split([sep [,
 limit] ])`

 Returns an array of strings populated by splitting the calling string at occurrences
 of the substring `sep`.

`String.prototype.startsWith(searchString [, length])`

 Determines whether the calling string begins with the characters of string
 `searchString`.

`String.prototype.substring(indexStart [, indexEnd])`

 Returns a new string containing characters of the calling string from (or between)
 the specified index (or indices).

`String.prototype.toLocaleLowerCase( [locale, ...locales])`

 The characters within a string are converted to lowercase while respecting the
 current locale.For most languages, this will return the same as
 `toLowerCase()`.

`String.prototype.toLocaleUpperCase( [locale, ...locales])`

 The characters within a string are converted to uppercase while respecting the
 current locale.For most languages, this will return the same as
 `toUpperCase()`.

`String.prototype.toLowerCase()`

Returns the calling string value converted to lowercase.

`String.prototype.toString()`

 Returns a string representing the specified object. Overrides the
 `Object.prototype.toString()` method.

`String.prototype.toUpperCase()`

Returns the calling string value converted to uppercase.

`String.prototype.trim()`

 Trims whitespace from the beginning and end of the string. Part of the ECMAScript 5
 standard.

`String.prototype.trimStart()`

Trims whitespace from the beginning of the string.

`String.prototype.trimEnd()`

Trims whitespace from the end of the string.

`String.prototype.valueOf()`

 Returns the primitive value of the specified object. Overrides the
 `Object.prototype.valueOf()` method.

`String.prototype.@@iterator()` (en-US)

 Returns a new iterator object that iterates over the code points of a String value,
 returning each code point as a String value.

예제
--

### 문자열 변환

비록 일반적으로 toString() 함수를 많이 사용하고 있지만, `toString()`의 "안전한" 대안으로 String을 사용할 수 있습니다. String은 `null`과 `undefined`에 대해서도 잘 동작합니다. 예를 들면:

```js
var outputStrings = [];
for (var i = 0, n = inputValues.length; i < n; ++i) {
  outputStrings.push(String(inputValues[i]));
}
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-string-objects |

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

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

같이 보기
-----

* `DOMString`
* Binary strings


DataView - JavaScript

DataView
========

**`DataView`** 뷰는 플랫폼의 자체 엔디언(바이트 정렬 방법)에 신경 쓰지 않으면서 `ArrayBuffer`에서 다양한 숫자 자료형의 데이터를 읽고 쓰기 위한 저수준 인터페이스를 제공합니다.

설명
--

### 엔디언

다중 바이트 숫자 자료형은 장치의 아키텍처에 따라 메모리에 다르게 표현됩니다. 엔디언 용어 사전을 참고하세요. `DataView` 접근자는 코드를 실행하는 컴퓨터의 엔디언에 관계 없이 데이터의 접근법을 명시적으로 통제할 수 있습니다.

```js
var littleEndian = (function () {
  var buffer = new ArrayBuffer(2);
  new DataView(buffer).setInt16(0, 256, true /\* littleEndian \*/);
  // Int16Array uses the platform's endianness.
  return new Int16Array(buffer)[0] === 256;
})();
console.log(littleEndian); // true or false
```

### 64비트 정수 자료형

JavaScript는 64비트 정수형 값에 대한 표준 지원을 아직 제공하지 않으므로 `DataView`도 64비트 연산을 지원하지 않습니다. 필요한 경우 최대 정확도 `Number.MAX_SAFE_INTEGER`의 값을 가져올 수 있는 `getUint64()` 함수를 만들 수는 있으며, 어느 정도까지는 충분할 것입니다.

```js
function getUint64(dataview, byteOffset, littleEndian) {
  // split 64-bit number into two 32-bit (4-byte) parts
  const left = dataview.getUint32(byteOffset, littleEndian);
  const right = dataview.getUint32(byteOffset + 4, littleEndian);

  // combine the two 32-bit values
  const combined = littleEndian
    ? left + 2 \*\* 32 \* right
    : 2 \*\* 32 \* left + right;

  if (!Number.isSafeInteger(combined))
    console.warn(combined, "exceeds MAX\_SAFE\_INTEGER. Precision may be lost");

  return combined;
}
```

완전한 범위의 64비트를 지원해야 할 경우 `BigInt`를 사용하세요. 단, `BigInt`는 사용자 계층 라이브러리 구현체보다는 훨씬 빠르지만, 가변 크기라는 성질로 인해 JavaScript 32비트 정수보다는 항상 느릴 수밖에 없습니다.

```js
const BigInt = window.BigInt,
  bigThirtyTwo = BigInt(32),
  bigZero = BigInt(0);
function getUint64BigInt(dataview, byteOffset, littleEndian) {
  // split 64-bit number into two 32-bit (4-byte) parts
  const left = BigInt(dataview.getUint32(byteOffset | 0, !!littleEndian) >>> 0);
  const right = BigInt(
    dataview.getUint32(((byteOffset | 0) + 4) | 0, !!littleEndian) >>> 0,
  );

  // combine the two 32-bit values and return
  return littleEndian
    ? (right << bigThirtyTwo) | left
    : (left << bigThirtyTwo) | right;
}
```

생성자
---

`DataView()`

새로운 `DataView` 객체를 생성합니다.

속성
--

`DataView.prototype.constructor`

객체의 프로토타입을 생성한 함수를 나타냅니다. 초깃값은 내장 `DataView` 생성자입니다.

`DataView.prototype.buffer` (en-US) 읽기 전용

뷰가 참조하는 `ArrayBuffer`입니다.

`DataView.prototype.byteLength` (en-US) 읽기 전용

뷰의 시작점부터 측정한 `ArrayBuffer`의 길이(바이트 단위)입니다.

`DataView.prototype.byteOffset` (en-US) 읽기 전용

뷰의 시작점 오프셋(바이트 단위)입니다.

메서드
---

### 읽기

`DataView.prototype.getInt8()`

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 8비트 정수(byte)를 가져옵니다.

`DataView.prototype.getUint8()`

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 8비트 부호 없는 정수(unsigned byte)를 가져옵니다.

`DataView.prototype.getInt16()`

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 16비트 정수(short)를 가져옵니다.

`DataView.prototype.getUint16()`

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 16비트 부호 없는 정수(unsigned short)를 가져옵니다.

`DataView.prototype.getInt32()`

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 32비트 정수(long)를 가져옵니다.

`DataView.prototype.getUint32()`

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 32비트 부호 없는 정수(unsigned short)를 가져옵니다.

`DataView.prototype.getFloat32()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 32비트 실수(float)를 가져옵니다.

`DataView.prototype.getFloat64()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 64비트 실수(double)를 가져옵니다.

`DataView.prototype.getBigInt64()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 64비트 정수(long long)를 가져옵니다.

`DataView.prototype.getBigUint64()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치의 64비트 부호 없는 정수(unsigned long long)를 가져옵니다.

### 쓰기

`DataView.prototype.setInt8()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 8비트 정수(byte)를 저장합니다.

`DataView.prototype.setUint8()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 8비트 부호 없는 정수(unsigned byte)를 저장합니다.

`DataView.prototype.setInt16()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 16비트 정수(short)를 저장합니다.

`DataView.prototype.setUint16()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 16비트 부호 없는 정수(unsigned short)를 저장합니다.

`DataView.prototype.setInt32()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 32비트 정수(long)를 저장합니다.

`DataView.prototype.setUint32()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 32비트 부호 없는 정수(unsigned long)를 저장합니다.

`DataView.prototype.setFloat32()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 32비트 실수(float)를 저장합니다.

`DataView.prototype.setFloat64()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 64비트 실수(double)를 저장합니다.

`DataView.prototype.setBigInt64()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 64비트 정수(long long)를 저장합니다.

`DataView.prototype.setBigUint64()` (en-US)

뷰의 시작점에서부터 주어진 오프셋을 적용한 위치에 64비트 부호 없는 정수(unsigned long long)를 저장합니다.

예제
--

```js
var buffer = new ArrayBuffer(16);
var view = new DataView(buffer, 0);

view.setInt16(1, 42);
view.getInt16(1); //42
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-dataview-objects |

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

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

같이 보기
-----

* `ArrayBuffer`
* `SharedArrayBuffer`


Uint16Array - JavaScript

Uint16Array
===========

**`Uint16Array`** 형식화 배열(TypedArray)은 플랫폼의 바이트 순서를 따르는 16비트 부호 없는 정수의 배열을
 나타냅니다. 바이트 순서를 제어해야 하는 경우 대신 `DataView`를 사용합니다. 배열의 내용은 0으로 초기화됩니다.
 배열이 생성되면 객체의 메서드를 사용하거나 표준 배열 인덱스 구문(즉, 대괄호 표기법 사용)을 사용하여 배열의 요소를 참조할 수 있습니다.

생성자
---

`Uint16Array()`

새로운 `Uint16Array` 객체를 생성합니다.

정적 속성
-----

부모 `TypedArray`에서 정적 속성을 상속합니다.

`Uint16Array.BYTES_PER_ELEMENT`

요소 크기를 숫자 값으로 반환합니다. `Uint16Array`의 경우 `2` 입니다.

`Uint16Array.name`

생성자 이름을 문자열로 반환합니다. `Uint16Array` 타입의 경우 `"Uint16Array"`입니다.

정적 메서드
------

부모 `TypedArray`에서 정적 메서드를 상속합니다.

인스턴스 속성
-------

부모 `TypedArray`에서 인스턴스 속성을 상속합니다.

`Uint16Array.prototype.BYTES_PER_ELEMENT`

요소 크기를 숫자 값으로 반환합니다. `Uint16Array`의 경우 `2`입니다.

인스턴스 메서드
--------

부모 `TypedArray`에서 인스턴스 메서드를 상속합니다.

예제
--

### Uint16Array를 생성하기 위한 각기 다른 여러 방법

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

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

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

// ArrayBuffer로부터 생성
const buffer = new ArrayBuffer(16);
const z = new Uint16Array(buffer, 2, 4);
console.log(z.byteOffset); // 2

// 순회로부터 생성
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const uint16FromIterable = new Uint16Array(iterable);
console.log(uint16FromIterable);
// Uint16Array [1, 2, 3]
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

같이 보기
-----

* `core-js`에서 `Uint16Array` 폴리필
* JavaScript 형식화 배열
* `ArrayBuffer`
* `DataView`


BigInt - JavaScript

BigInt
======

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

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

* Learn more
* See full compatibility
* Report feedback
**`BigInt`** 는 `Number` 원시 값이 안정적으로 나타낼 수 있는 최대치인 2^53 - 1보다 큰 정수를 표현할 수 있는 내장 객체입니다.

설명
--

`BigInt`는 정수 리터럴의 뒤에 `n`을 붙이거나(`10n`) 함수 `BigInt()`를 호출해 생성할 수 있습니다.

```js
const theBiggestInt = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);
// ↪ 9007199254740991n

const hugeString = BigInt("9007199254740991");
// ↪ 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");
// ↪ 9007199254740991n

const hugeBin = BigInt(
  "0b11111111111111111111111111111111111111111111111111111",
);
// ↪ 9007199254740991n
```

`BigInt`와 `Number`는 어떤 면에서 비슷하지만 중요한 차이점이 있습니다. 예컨대 `BigInt`는 내장 `Math` 객체의 메서드와 함께 사용할 수 없고, 연산에서 `Number`와 혼합해 사용할 수 없습니다. 따라서 먼저 같은 자료형으로 변환해야 합니다. 그러나, `BigInt`가 `Number`로 바뀌면 정확성을 잃을 수 있으니 주의해야 합니다.

### 자료형 정보

`BigInt`의 `typeof` 판별 결과는 `"bigint"`입니다.

```js
typeof 1n === "bigint"; // true
typeof BigInt("1") === "bigint"; // true
```

`Object`로 감싼 `BigInt`는 일반적인 `object` 자료형으로 취급합니다.

```js
typeof Object(1n) === "object"; // true
```

### 연산자

`+`, `*`, `-`, `**`, `%` 연산자를 `BigInt`나 객체로 감싼 `BigInt`에서 사용할 수 있습니다. 비트 연산자 (en-US)도 사용할 수 있으나, 모든 `BigInt`는 부호를 가져야 하므로 `>>>` (부호 버림 오른쪽 시프트)는 사용할 수 없습니다. asm.js에서 문제를 일으키지 않도록, 단항 `+` 연산자도 지원하지 않습니다.

```js
const previousMaxSafe = BigInt(Number.MAX\_SAFE\_INTEGER);
// ↪ 9007199254740991

const maxPlusOne = previousMaxSafe + 1n;
// ↪ 9007199254740992n

const theFuture = previousMaxSafe + 2n;
// ↪ 9007199254740993n, this works now!

const multi = previousMaxSafe \* 2n;
// ↪ 18014398509481982n

const subtr = multi – 10n;
// ↪ 18014398509481972n

const mod = multi % 10n;
// ↪ 2n

const bigN = 2n \*\* 54n;
// ↪ 18014398509481984n

bigN \* -1n
// ↪ –18014398509481984n
```

`/` 연산자도 정수 연산에서 예상할 수 있는 결과를 동일하게 도출합니다. 그러나 `BigInt`는 `BigDecimal`이 아니므로, 연산의 결과는 언제나 소수점 이하를 버립니다. 즉, 정수가 아닌 결과는 나오지 않습니다.

**경고:** 소수점 결과를 포함하는 연산을 `BigInt`와 사용하면 소수점 이하는 사라집니다.

```js
const expected = 4n / 2n;
// ↪ 2n

const rounded = 5n / 2n;
// ↪ 2.5n이 아니라 2n
```

### 비교

`BigInt`는 `Number`와 일치하지 않지만 동등합니다.

```js
0n === 0;
// ↪ false

0n == 0;
// ↪ true
```

`Number`와 `BigInt`는 일반적인 방법으로 비교할 수 있습니다.

```js
1n < 2;
// ↪ true

2n > 1;
// ↪ true

2 > 2;
// ↪ false

2n > 2;
// ↪ false

2n >= 2;
// ↪ true
```

배열의 요소로 함께 사용했을 땐 정렬도 가능합니다.

```js
const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
// ↪ [4n, 6, -12n, 10, 4, 0, 0n]

mixed.sort();
// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]
```

`Object`로 감싼 `BigInt`의 경우 다른 객체와 마찬가지로 자기 자신과 비교했을 때만 일치합니다.

```js
0n === Object(0n); // false
Object(0n) === Object(0n); // false

const o = Object(0n);
o === o; // true
```

### 조건

`BigInt`는 다음의 상황에서는 `Number`처럼 행동합니다.

* `Boolean` 함수를 사용해 Boolean 객체로 변환
* 논리 연산자 `||`, `&&`, `!`와 함께 사용
* `if`문 등 조건 판별 시

```js
if (0n) {
  console.log("if에서 안녕!");
} else {
  console.log("else에서 안녕!");
}

// ↪ "else에서 안녕!"

0n || 12n;
// ↪ 12n

0n && 12n;
// ↪ 0n

Boolean(0n);
// ↪ false

Boolean(12n);
// ↪ true

!12n;
// ↪ false

!0n;
// ↪ true
```

생성자
---

`BigInt()`

`BigInt` 객체를 생성합니다.

정적 메서드
------

`BigInt.asIntN()` (en-US)

주어진 `BigInt`를 `-2^(width - 1)`과 `2^(width - 1) - 1`의 범위로 자릅니다.

`BigInt.asUintN()` (en-US)

주어진 `BigInt`를 `0`과 `2^width - 1`의 범위로 자릅니다.

인스턴스 메서드
--------

`BigInt.prototype.toLocaleString()` (en-US)

BigInt를 주어진 언어에 적합한 형태를 가진 문자열로 변환해 반환합니다. `Object.prototype.toLocaleString()` 메서드를 재정의합니다.

`BigInt.prototype.toString()` (en-US)

`BigInt`의 값을 주어진 진수로 표현한 문자열을 반환합니다. `Object.prototype.toString()` 메서드를 재정의합니다.

`BigInt.prototype.valueOf()` (en-US)

`BigInt` 객체의 원시 값 표현을 반환합니다. `Object.prototype.valueOf()` 메서드를 재정의합니다.

권장사항
----

### 변환

`BigInt`를 `Number`로 변환하는 과정에서 정확도를 유실할 수 있으므로, 2^53보다 큰 값을 예상할 수 있는 경우 `BigInt`만 사용하는 것이 좋습니다.

### 암호화

`BigInt`가 지원하는 연산의 소요시간은 상수 시간이 아니기 때문에 암호화에 적합하지 않습니다.

### JSON과 함께 사용하기

`BigInt`는 직렬화할 수 없기 때문에, `JSON.stringify()`에 `BigInt`를 포함한 값을 전달한다면 `TypeError`가 발생합니다. 대신, 필요한 경우 자신만의 `toJSON` 메서드를 만들 수 있습니다.

```js
BigInt.prototype.toJSON = function () {
  return this.toString();
};
```

이제 아래 코드가 오류를 던지지 않고 문자열을 반환합니다.

```js
JSON.stringify(BigInt(1));
// '"1"'
```

예제
--

### 소수 구하기

```js
// 주어진 BigInt가 소수이면 true 반환
function isPrime(p) {
  for (let i = 2n; i \* i <= p; i++) {
    if (p % i === 0n) return false;
  }
  return true;
}

// BigInt를 받아, n번째 소수를 BigInt로 반환
function nthPrime(nth) {
  let maybePrime = 2n;
  let prime = 0n;

  while (nth >= 0n) {
    if (isPrime(maybePrime)) {
      nth -= 1n;
      prime = maybePrime;
    }
    maybePrime += 1n;
  }

  return prime;
}

nthPrime(20n);
// ↪ 73n
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-bigint-objects |

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

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

같이 보기
-----

* `Number`


parseFloat() - JavaScript

parseFloat()
============

**`parseFloat()`** 함수는 주어진 값을 필요한 경우 문자열로 변환한 후 부동소수점 실수로 파싱해 반환합니다.

시도해보기
-----

구문
--

```js
parseFloat(string);
```

### 매개변수

`string`

파싱할 값입니다. 문자열이 아닐 경우 `ToString` 추상 연산을 사용해 문자열로 변환합니다. 문자열의 선행 공백은 무시합니다.

### 반환 값

주어진 문자열에서 파싱한 부동소수점 실수입니다.

공백이 아닌 첫 글자를 숫자로 변환할 수 없는 경우 `NaN`을 반환합니다.

설명
--

`parseFloat`은 전역 객체의 함수 속성입니다.

* `parseFloat`이 양의 부호(`+`), 음의 부호(`-` U+002D HYPHEN-MINUS), 숫자(`0`-`9`), 소수점(`.`), 지수(`e`, `E`) 외의 다른 글자를 발견할 경우 해당 문자 이전까지의 문자만 사용해 파싱하며 문제의 문자와 그 이후는 모두 무시합니다.
* 소수점이 두 개 이상 존재할 경우 두 번째 소수점 역시 위와 같이 무시됩니다.
* 주어진 값의 선행 및 후행 공백은 무시합니다.
* 주어진 값의 첫 글자를 숫자로 변환할 수 없는 경우 `NaN`을 반환합니다.
* `parseFloat`은 `Infinity`도 파싱 후 반환할 수 있습니다.
* `parseFloat`은 `BigInt` 구문을 `Number`로 반환하므로 정확도를 잃습니다. 마지막 `n` 문자를 무시하기 때문입니다.

더 엄격한 파싱이 필요하면, 유효하지 않은 문자가 어디에나 존재할 시 `NaN`을 반환하는 `Number(value)`를 고려하세요.

`parseFloat`은 `toString`이나 `valueOf` 메서드를 구현한 객체도 파싱할 수 있습니다. 이 때의 결과는 객체의 `toString()`, `valueOf()`의 반환 값을 `parseFloat`에 전달한 것과 동일합니다.

예제
--

### 숫자를 반환하는 경우

아래 예제는 모두 `3.14`를 반환합니다.

```js
parseFloat(3.14);
parseFloat("3.14");
parseFloat(" 3.14 ");
parseFloat("314e-2");
parseFloat("0.0314E+2");
parseFloat("3.14와 숫자가 아닌 문자들");
parseFloat({
  toString: function () {
    return "3.14";
  },
});
```

### `NaN`을 반환하는 경우

다음 예제는 `NaN`을 반환합니다.

```js
parseFloat("FF2");
```

### `parseFloat`과 `BigInt`

다음 예제는 부동소수점 실수로 표현하기엔 너무 큰 수를 받거나 `n`을 무시해서 정확도를 잃어버린 `900719925474099300`을 반환합니다.

```js
parseFloat(900719925474099267n);
parseFloat("900719925474099267n");
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-parsefloat-string |

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

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

같이 보기
-----

* `parseInt()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `Number.toFixed()`
* `isNaN()`


Function - JavaScript

Function
========

**`Function` 생성자**는 새 `Function` 객체를 만듭니다. 이 생성자를 직접 호출하여 동적으로 함수를 생성할 수도 있으나, 보안 문제 및 `eval` (en-US)과 유사한(그러나 훨씬 덜 심각한) 성능 문제가 발생할 수 있습니다. 하지만 `eval`과 달리, `Function` 생성자는 전역 범위로 한정된 함수만 생성합니다.

시도해보기
-----

모든 JavaScript 함수는 사실 `Function` 객체입니다. 이는 `(function(){}).constructor === Function`이 참을 반환하는 것에서 알 수 있습니다.

구문
--

```js
    new Function ([arg1[, arg2[, ...argN]],] functionBody)
```

### 매개변수

`arg1, arg2, ... argN`

형식 인수 이름으로 사용할 이름. 각 이름은 유효한 JavaScript 식별자거나, 쉼표로 구분한 유효한 식별자 목록이어야 합니다. 즉, "`x`", "`theValue`", "`x,theValue`"등의 값을 사용할 수 있습니다.

`functionBody`

함수 정의를 구성하는 JavaScript 문을 담은 문자열.

설명
--

`Function` 생성자로 생성한 `Function` 객체는 함수를 생성할 때 구문 분석을 수행합니다. 반면, 함수 표현식이나 함수 선언문으로 함수를 정의하고 코드 내에서 호출한 경우 나머지 코드와 함께 구문 분석되므로, `Function` 생성자가 더 비효율적입니다.

함수로 전달되는 모든 인수는 생성될 함수의 매개 변수 식별자 이름으로 전달되는 순서대로 처리됩니다.

(`new` 연산자를 사용하지 않고) 함수로써 `Function` 생성자를 호출하는 것은 생성자로 호출하는 것과 같습니다. 하지만, new 연산자가 제거됨으로써 코드의 크기를 약간(4 바이트 더 작게) 줄일 수 있으므로 `Function`에 대해서는 `new` 연산자를 사용하지 않는 것이 좋습니다.

`Function`의 속성과 메서드
-------------------

전역 `Function` 객체는 자신만의 메서드 또는 속성이 없습니다. 그러나, 그 자체로 함수이기에 `Function.prototype`에서 프로토타입 체인을 통해 일부 메서드 및 속성을 상속받습니다.

`Function` 프로토타입 객체
-------------------

### 속성

`Function.arguments`
지원이 중단되었습니다

함수에 전달되는 인수(argument)에 해당하는 배열. 이는 `Function`의 속성으로 사라지므로(deprecated), 대신 함수 내에서 이용 가능한 `arguments` 객체를 사용하세요.

`Function.arity`
지원이 중단되었습니다

함수에 의해 기대되는 인수의 수를 지정하기 위해 사용됐으나 제거되었습니다. 대신 `length` 속성을 사용하세요.

`Function.caller` (en-US)
비표준

현재 실행 중인 함수를 호출한 함수를 지정합니다.

`Function.length`

함수에 의해 기대되는 인수의 수를 지정합니다.

`Function.name`

함수명.

`Function.displayName` (en-US)
비표준

함수의 표시명.

`Function.prototype.constructor`

객체의 프로토타입을 만드는 함수를 지정합니다. 자세한 사항은 `Object.prototype.constructor` 참조.

### 메서드

`Function.prototype.apply()`

함수를 호출하고 *this*를 제공된 값으로 설정합니다, 인수는 `Array` 객체로 전달될 수 있습니다.

`Function.prototype.bind()`

호출될 때 *this*를 제공된 값으로 설정하는 새로운 함수를 만듭니다, 새로운 함수가 호출됐을 때 주어진 순서로 모두 제공되는 선행 인수와 함께.

`Function.prototype.call()`

함수를 호출(실행)하고 *this*를 제공된 값으로 설정합니다, 인수는 그대로 전달될 수 있습니다.

`Function.prototype.isGenerator()`
비표준

함수가 생성기인 경우 `true`를 반환합니다; 그렇지 않으면 `false`를 반환합니다.

`Function.prototype.toSource()`
비표준

함수의 소스 코드를 나타내는 문자열을 반환합니다. `Object.prototype.toSource` (en-US) 메서드를 재정의(override)합니다.

`Function.prototype.toString()`

함수의 소스 코드를 나타내는 문자열을 반환합니다. `Object.prototype.toString` 메서드를 재정의합니다.

`Function` 인스턴스
---------------

`Function` 인스턴스는 `Function.prototype`에서 메서드 및 속성을 상속받습니다. 모든 생성자와 마찬가지로, 생성자의 프로토타입 객체를 바꿈으로써 모든 `Function` 인스턴스에 변화를 줄 수 있습니다.

예제
--

### `Function` 생성자에 인수 지정하기

다음 코드는 인수 두 개를 갖는 `Function` 객체를 생성합니다.

```js
// 예제는 JavaScript 콘솔에서 직접 실행하실 수 있습니다

// 두 개의 인수를 가지고 그 둘의 합을 반환하는 함수 생성
var adder = new Function("a", "b", "return a + b");

// 함수 호출
adder(2, 6);
// > 8
```

인수 "`a`" 및 "`b`"는 함수 몸통(body)의 "`return a + b`"에 사용되는 형식 인수명입니다.

### Function 생성자와 함수 선언의 차이

`Function` 생성자로 만들어지는 함수는 생성 컨텍스트에 대한 클로저(closure)를 생성하지 않습니다; 이들 함수는 항상 전역 범위에서 생성됩니다. 함수가 실행될 때, 자신의 지역 변수와 전역 변수에만 접근할 수 있으며 `Function` 생성자가 호출된 그 범위의 변수에는 접근할 수 없습니다. 이 점이 함수 표현식 코드에서 `eval` (en-US)을 사용하는 것과 다른 점입니다.

```js
var x = 10;

function createFunction1() {
  var x = 20;
  return new Function("return x;"); // 여기서 |x|는 전역 범위에 있는 |x|를 참조함.
}

function createFunction2() {
  var x = 20;
  function f() {
    return x; // 여기서 |x|는 위의 지역에 있는 |x|를 참조함.
  }
  return f;
}

var f1 = createFunction1();
console.log(f1()); // 10
var f2 = createFunction2();
console.log(f2()); // 20
```

위 코드는 브라우저에서는 정상 동작하지만, Node.js에서는 `x`를 찾을 수 없어, `f1()`이 `ReferenceError`를 생성합니다. 이는 Node.js의 최상위 스크립트 범위가 전역이 아닌 모듈이므로, `x`도 모듈 범위에 종속되기 때문입니다.

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-objects |

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

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

같이 보기
-----

* `Functions and function scope`
* `function statement`
* `function expression`
* `function* statement`
* `function* expression`
* `AsyncFunction`
* `GeneratorFunction`


NaN - JavaScript

NaN
===

전역 **`NaN`** 속성은 Not-A-Number(숫자가 아님)를 나타냅니다.

시도해보기
-----

값
-

`Number.NaN`와 동일한 숫자 값입니다.

| Property attributes of `NaN` |
| --- |
| Writable | 불가능 |
| Enumerable | 불가능 |
| Configurable | 불가능 |

설명
--

`NaN`은 전역 객체의 속성입니다. 즉 전역 범위의 변수입니다.

최신 브라우저에서 `NaN`은 설정 불가, 쓰기 불가 속성입니다. 그렇지 않다고 하더라도 덮어쓰는 건 피하는 게 좋습니다.

`NaN`을 반환하는 연산에는 다섯 가지 종류가 있습니다.

* 숫자로 변환 실패 (예시: `parseInt("blabla")`, `Number(undefined)`와 같은 명시적인 것 또는 `Math.abs(undefined)`와 같은 암시적인 것)
* 결과가 허수인 수학 계산식 (예시: `Math.sqrt(-1)`)
* 정의할 수 없는 계산식 (예시: `0 * Infinity`, `1 ** Infinity`, `Infinity / Infinity`, `Infinity - Infinity`)
* 피연산자가 `NaN`이거나 `NaN`으로 강제 변환되는 메서드 또는 표현식 (예시: `7 ** NaN`, `7 * "blabla"`) - 이것은 `NaN`이 전염성 있다는 것을 의미합니다.
* 유효하지 않은 값이 숫자로 표시되는 기타 경우 (예시: 잘못된 날짜 `new Date("blabla").getTime()`, `"".charCodeAt(1)`)

`NaN`과 `NaN`의 동작은 JavaScript에서 발명한 것이 아닙니다. 부동 소수점 산술의 의미(`NaN !== NaN` 포함)는 IEEE 754에 의해 지정됩니다. `NaN`의 동작은 다음과 같습니다.

* `NaN`이 수학 연산에 포함된 경우 (그러나 비트 연산는 아님) 결과도 일반적으로 `NaN` 입니다. (아래의 counter-example 참조)
* `NaN`이 관계 비교(`>`, `<`, `>=`, `<=`)의 피연산자 중 하나인 경우 결과는 항상 `false`입니다.
* `NaN`은 ( `==`, `!=`, `===` (en-US) 및 `!==` (en-US) 를 통해) 다른 `NaN` 값을 포함하여 다른 값과 같지 않은 것으로 비교됩니다.

`NaN`은 JavaScript의 falsy 값 중 하나이기도 합니다.

예제
--

### `NaN` 판별

값이 `NaN`인지 확인하려면, `Number.isNaN()` 또는 `isNaN()`를 사용하여 값이 `NaN`인지 여부를 확인 할 수 있습니다. 또는 `NaN`은 자신과 같지 않다고 비교되는 유일한 값이므로 `x !== x`와 같은 자체 비교를 수행할 수 있습니다.

```js
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true

function valueIsNaN(v) {
  return v !== v;
}
valueIsNaN(1); // false
valueIsNaN(NaN); // true
valueIsNaN(Number.NaN); // true
```

그러나 `isNaN()`과 `Number.isNaN()`의 차이를 유의해야 합니다. `isNaN`은 현재 값이 `NaN`이거나, 숫자로 변환했을 때 `NaN`이 되면 참을 반환하지만, `Number.isNaN`은 현재 값이 `NaN`이어야만 참을 반환합니다.

```js
isNaN("hello world"); // true
Number.isNaN("hello world"); // false
```

같은 이유로 BigInt 값을 사용하면 `Number.isNaN()`이 아닌 `isNaN()`에서 오류가 발생합니다.

```js
isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false
```

또한 일부 배열 메서드는 `NaN`을 찾을 수 없는 반면에 다른 배열 메서드들은 찾을 수 있습니다. 즉, (`indexOf()`, `lastIndexOf()`)는 `NaN`을 찾을 수 없지만, `includes()`는 값을 찾을 수 있습니다.

```js
const arr = [2, 4, NaN, 12];
arr.indexOf(NaN); // -1
arr.includes(NaN); // true

// 적절하게 정의된 조건자를 허용하는 메서드는 항상 NaN을 찾을 수 있습니다.
arr.findIndex((n) => Number.isNaN(n)); // 2
```

`NaN`과 그 비교에 대한 자세한 내용은 평등 비교 및 동일성를 참조.

### 눈에 띄게 구별되는 NaN 값

`NaN`이 자신과 동등하지 않은 데는 동기가 있습니다. IEEE 754 인코딩에서 지수 `0x7ff`와 0이 아닌 가수부가 있는 부동 소수점 숫자는 `NaN`이기 때문에 서로 다른 이진 표현을 가진 두 개의 부동 소수점 숫자를 생성할 수 있지만 둘 다 `NaN`입니다. JavaScript에서 typed arrays를 사용하여 비트 수준 조작을 수행할 수 있습니다.

```js
const f2b = (x) => new Uint8Array(new Float64Array([x]).buffer);
const b2f = (x) => new Float64Array(x.buffer)[0];
// NaN의 byte 표현을 가져옵니다.
const n = f2b(NaN);
// 부호 비트이고 NaN에 중요하지 않은 첫 번째 비트를 변경합니다.
n[0] = 1;
const nan2 = b2f(n);
console.log(nan2); // NaN
console.log(Object.is(nan2, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan2)); // Uint8Array(8) [1, 0, 0, 0, 0, 0, 248, 127]
```

### 조용히 NaN 탈출

`NaN`은 수학적 연산을 통해 전파되므로 일반적으로 오류 조건을 감지하기 위해 계산이 끝날 때 한 번 `NaN`을 테스트하는 것으로 충분합니다. `NaN`이 자동으로 이스케이프되는 유일한 경우는 지수가 `0`인 거듭제곱을 사용할 때입니다. 그러면 기본값을 검사하지 않고 즉시 `1`이 반환됩니다.

```js
NaN \*\* 0 === 1; // true
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-value-properties-of-the-global-object-nan |

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

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

같이 보기
-----

* `Number.NaN`
* `Number.isNaN()`
* `isNaN()`


Reflect - JavaScript

Reflect
=======

**`Reflect`** 는 중간에서 가로챌 수 있는 JavaScript 작업에 대한 메서드를 제공하는 내장 객체입니다. 메서드의 종류는 프록시 처리기와 동일합니다. `Reflect`는 함수 객체가 아니므로 생성자로 사용할 수 없습니다.

설명
--

다른 대부분의 전역 객체와 다르게, `Reflect`는 생성자가 아닙니다. 따라서 함수처럼 호출하거나 `new` 연산자로 인스턴스를 만들 수 없습니다. `Math` 객체처럼, `Reflect`의 모든 속성과 메서드는 정적입니다.

`Reflect` 객체의 정적 메서드 이름은 프록시 처리기 메서드의 이름과 같습니다.

일부 메서드는 `Object`에도 존재하는 메서드이지만 약간의 차이 (en-US)가 있습니다.

정적 메서드
------

`Reflect.apply()`

대상 함수를 주어진 매개변수로 호출합니다. `Function.prototype.apply()`도 참고하세요.

`Reflect.construct()`

함수로 사용하는 `new` 연산자입니다. `new target(...args)`을 호출하는 것과 같습니다. 다른 프로토타입을 지정하는 추가 기능도 가지고 있습니다.

`Reflect.defineProperty()`

`Object.defineProperty()`와 비슷합니다. `Boolean`을 반환합니다.

`Reflect.deleteProperty()`

함수로 사용하는 `delete` 연산자 (en-US)입니다. `delete target[name]`을 호출하는 것과 같습니다.

`Reflect.get()`

대상 속성의 값을 반환하는 함수입니다.

`Reflect.getOwnPropertyDescriptor()`

`Object.getOwnPropertyDescriptor()`와 비슷합니다. 주어진 속성이 대상 객체에 존재하면, 그 속성의 서술자를 반환합니다. 그렇지 않으면 `undefined`를 반환합니다.

`Reflect.getPrototypeOf()`

`Object.getPrototypeOf()`와 같습니다.

`Reflect.has()`

함수로 사용하는 `in` 연산자입니다. 자신의, 혹은 상속한 속성이 존재하는지 나타내는 `Boolean`을 반환합니다.

`Reflect.isExtensible()`

`Object.isExtensible()`과 같습니다.

`Reflect.ownKeys()`

대상 객체의 자체 키(상속하지 않은 키) 목록을 배열로 반환합니다.

`Reflect.preventExtensions()`

`Object.preventExtensions()`와 비슷합니다. `Boolean`을 반환합니다.

`Reflect.set()`

속성에 값을 할당하는 함수입니다. 할당 성공 여부를 나타내는 `Boolean`을 반환합니다.

`Reflect.setPrototypeOf()`

객체의 프로토타입을 지정하는 함수입니다. 지정 성공 여부를 나타내는 `Boolean`을 반환합니다.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect-object |

예제
--

### 객체가 특정 속성을 가지고 있는지 검사하기

```js
const duck = {
  name: "Maurice",
  color: "white",
  greeting: function () {
    console.log(`Quaaaack! My name is ${this.name}`);
  },
};

Reflect.has(duck, "color");
// true
Reflect.has(duck, "haircut");
// false
```

### 객체 자체 키를 반환하기

```js
Reflect.ownKeys(duck);
// [ "name", "color", "greeting" ]
```

### 객체에 새로운 속성 추가하기

```js
Reflect.set(duck, "eyes", "black");
// returns "true" if successful
// "duck" now contains the property "eyes: 'black'"
```

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

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

같이 보기
-----

* `Proxy` 전역 객체.
* `handler` 객체.


Int32Array - JavaScript

Int32Array
==========

**`Int32Array`** 형식화 배열(TypedArray)은 플랫폼의 바이트 순서를 따르는 2의 보수 32비트의 부호있는 정수
 배열입니다. 바이트 순서를 제어해야 하는 경우 대신 `DataView`를 사용합니다. 배열의 내용은 0으로 초기화됩니다.
 배열이 생성되면 객체의 메서드를 사용하거나 표준 배열 인덱스 구문(즉, 대괄호 표기법 사용)을 사용하여 배열의 요소를 참조할 수 있습니다.

생성자
---

`Int32Array()`

새로운 `Int32Array` 객체를 생성합니다.

정적 속성
-----

부모 `TypedArray`에서 정적 속성을 상속합니다.

`Int32Array.BYTES_PER_ELEMENT`

요소 크기의 숫자 값을 반환합니다. `Int32Array`의 경우 `4` 입니다.

`Int32Array.name`

생성자 이름을 문자열로 반환합니다. `Int32Array` 타입의 경우 `"Int32Array"`입니다.

정적 메서드
------

부모 `TypedArray`에서 정적 메서드를 상속합니다.

인스턴스 속성
-------

부모 `TypedArray`에서 인스턴스 속성을 상속합니다.

`Int32Array.prototype.BYTES_PER_ELEMENT`

요소 크기의 숫자 값을 반환합니다. `Int32Array`의 경우 `4` 입니다.

인스턴스 메서드
--------

부모 `TypedArray`에서 인스턴스 메서드를 상속합니다.

예제
--

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

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

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

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

// ArrayBuffer로부터
const buffer = new ArrayBuffer(32);
const z = new Int32Array(buffer, 4, 4);
console.log(z.byteOffset); // 4

// 순회로부터
const iterable = (function\* () {
  yield\* [1, 2, 3];
})();
const int32FromIterable = new Int32Array(iterable);
console.log(int32FromIterable);
// Int32Array [1, 2, 3]
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # table-49 |

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

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

같이 보기
-----

* `core-js`에서 `Int32Array` 폴리필
* JavaScript 형식화 배열
* `ArrayBuffer`
* `DataView`


Float32Array() constructor - JavaScript

Float32Array() constructor
==========================

**`Float32Array`** 형식화 배열(TypedArray) 생성자는 플랫폼의 바이트 순서를 따르는 32비트 부동 소수점(C의
 `float` 데이터 타입에 대응) 배열을 생성합니다. 바이트 순서를 제어해야 하는 경우 대신 `DataView`를
 사용합니다. 배열의 내용은 0으로 초기화됩니다. 배열이 생성되면 객체의 메서드를 사용하거나 표준 배열 인덱스 구문
 (즉, 대괄호 표기법 사용)을 사용하여 배열의 요소를 참조할 수 있습니다.

구문
--

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

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

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

### 매개변수

`TypedArray`를 참고하세요.

### 예외

`TypedArray`를 참고하세요.

예제
--

### Float32Array를 생성하기 위한 각기 다른 여러 방법

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

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

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

// ArrayBuffer로부터 생성
const buffer = new ArrayBuffer(32);
const z = new Float32Array(buffer, 4, 4);
console.log(z.byteOffset); // 4

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


Date.prototype.setUTCMinutes() - JavaScript

Date.prototype.setUTCMinutes()
==============================

**`setUTCMinutes()`** 메서드는 표준시에 따라 지정된 날짜의 분을 설정합니다.

시도해보기
-----

구문
--

```js
setUTCMinutes(minutesValue)
setUTCMinutes(minutesValue, secondsValue)
setUTCMinutes(minutesValue, secondsValue, msValue)
```

### 매개변수

`minutesValue`

분을 나타내는 0에서 59 사이의 정수입니다.

`secondsValue`

선택적 입력 값. 초를 나타내는 0에서 59 사이의 정수입니다. `secondsValue` 매개 변수를 지정하면 `minutesValue`도 지정해야합니다.

`msValue`

선택적 입력 값. 밀리 초를 나타내는 0에서 999 사이의 숫자입니다. `msValue` 매개 변수를 지정하는 경우 `minutesValue` 및 `secondsValue`도 지정해야합니다.

### 반환 값

1970년 1월 1일 00:00:00 UTC와 업데이트 된 날짜 사이의 밀리 초 숫자입니다.

설명
--

`secondsValue` 및 `msValue` 매개 변수를 지정하지 않으면 `getUTCSeconds()` 및 `getUTCMilliseconds()` 메소드가 사용됩니다.

지정한 매개 변수가 예상 범위를 벗어나면 `setUTCMinutes()`는 그에 따라 `Date` 객체의 날짜 정보를 업데이트하려고 시도합니다. 예를 들어 `secondsValue`에 100을 사용하면 분은 1 (`minutesValue + 1`)만큼 증가하고 40은 초 단위로 사용됩니다.

예제
--

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

```js
var theBigDay = new Date();
theBigDay.setUTCMinutes(43);
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.setutcminutes |

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

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

See also
--------

* `Date.prototype.getUTCMinutes()`
* `Date.prototype.setMinutes()`


Date.prototype.getUTCSeconds() - JavaScript

Date.prototype.getUTCSeconds()
==============================

**getUTCSeconds()** 메서드는 표준시에 따라 지정된 날짜의 초를 반환합니다.

Syntax
------

```js
dateObj.getUTCSeconds();
```

### Return value

0부터 59까지의 정수로, 표준시에 따라 지정된 날짜의 초를 나타냅니다.

Examples
--------

### Using `getUTCSeconds()`

다음 예제에서는 현재 시간의 초 부분을 초 변수에 지정합니다.

```js
var today = new Date();
var seconds = today.getUTCSeconds();
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getutcseconds |

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

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

See also
--------

* `Date.prototype.getSeconds()`
* `Date.prototype.setUTCSeconds()`


Date.parse() - JavaScript

Date.parse()
============

Date.parse () 메서드는 날짜의 문자열 표현을 구문 분석하고 1970 년 1 월 1 일 00:00:00 UTC 이후의 밀리 초 수를 반환하거나 문자열이 인식되지 않거나 경우에 따라 잘못된 날짜 값을 포함하는 경우 NaN을 반환합니다. (예 : 2015-02-31).

ES5까지는 Date.parse를 사용하지 않는 것이 좋습니다. 문자열 구문 분석은 전적으로 구현에 따라 다릅니다. 다른 호스트가 날짜 문자열을 구문 분석하는 방법에는 여전히 많은 차이점이 있으므로 날짜 문자열을 수동으로 구문 분석해야합니다 (다양한 형식을 수용하면 라이브러리가 도움이 될 수 있습니다).

Syntax
------

Direct call:

```js
Date.parse(dateString);
```

Implicit call:

```js
new Date(dateString);
```

### Parameters

`dateString`

RFC2822 또는 ISO 8601 날짜를 나타내는 문자열 (다른 형식도 사용할 수 있지만 예기치 않은 결과 일 수 있음)

### Return value

1970 년 1 월 1 일 00:00:00 UTC 이후 경과 된 밀리 초를 나타내는 숫자 및 주어진 문자열 표현을 파싱하여 얻은 날짜입니다. 인수가 유효한 날짜를 나타내지 않으면 `NaN`이 반환됩니다.

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

parse () 메서드는 날짜 문자열 (예 : "Dec 25, 1995")을 사용하고 1970 년 1 월 1 일 00:00:00 UTC 이후의 밀리 초 수를 반환합니다. 이 함수는 예를 들어 `setTime()` 메서드 및 `Date`  객체를 반환합니다.

주어진 시간을 나타내는 문자열이 주어지면 parse ()는 시간 값을 반환합니다. RFC2822 / IETF 날짜 구문 (RFC2822 섹션 3.3)을 받아들입니다. "Mon, 25 Dec 1995 13:30:00 GMT". 미국 대륙의 표준 시간대 약어를 이해하지만, 일반적으로 "Mon, 25 Dec 1995 13:30:00 +0430"(그리니치 자오선의 동쪽으로 4 시간 30 분)과 같이 시간대 오프셋을 사용하십시오.

GMT와 UTC는 동등한 것으로 간주됩니다. 현지 시간대는 시간대 정보가없는 RFC2822 섹션 3.3 형식의 인수를 해석하는 데 사용됩니다.

날짜 문자열 구문 분석의 차이로 인해 결과가 일관되지 않아 문자열을 수동으로 구문 분석하는 것이 좋습니다. 특히 "2015-10-12 12:00:00"과 같은 문자열을 NaN으로 구문 분석 할 수있는 다른 ECMAScript 구현, UTC 또는 현지 시간대.

### ECMAScript 5 ISO-8601 format support

날짜 시간 문자열은 ISO 8601 형식 일 수 있습니다. 예를 들어, "2011-10-10"(날짜 만) 또는 "2011-10-10T14 : 48 : 00"(날짜 및 시간)을 전달하고 구문 분석 할 수 있습니다. 문자열이 ISO 8601 날짜 인 경우 UTC 시간대는 인수를 해석하는 데 사용됩니다. 문자열이 ISO 8601 형식의 날짜 및 시간이면 로컬로 처리됩니다.

날짜 문자열 구문 분석 중에 시간대 지정자를 사용하여 인수를 해석하지만 반환되는 값은 1970 년 1 월 1 일 00:00:00 UTC와 인수 또는 NaN이 나타내는 시점 사이의 밀리 초입니다.

parse ()는 `Date`의 정적 메서드이기 때문에 `Date` 인스턴스의 메서드가 아닌 Date.parse ()로 호출됩니다.

### 가정 된 시간대의 차이점

"March 7, 2014"이라는 날짜 문자열이 주어지면 parse ()는 현지 시간대를 사용하지만 "2014-03-07"과 같은 ISO 형식이 주어지면 UTC (ES5 및 ECMAScript 2015)의 시간대로 가정합니다. 따라서 `Date` 이러한 문자열을 사용하여 생성 된 객체는 시스템이 현지 표준 시간대 (UTC)로 설정되어 있지 않으면 지원되는 ECMAScript 버전에 따라 다른 순간을 나타낼 수 있습니다. 즉, 변환되는 문자열의 형식에 따라 동등하게 나타나는 두 개의 날짜 문자열이 서로 다른 두 개의 값을 가질 수 있습니다.

### 구현 특정 날짜 형식으로 폴백

ECMAScript 사양은 다음과 같이 설명합니다. String이 표준 형식을 준수하지 않으면 함수는 구현 특정 휴리스틱 또는 구현 특정 파싱 알고리즘으로 폴백 할 수 있습니다. 인식 할 수없는 문자열 또는 ISO 형식의 문자열에 잘못된 요소 값이 포함 된 날짜로 인해 Date.parse ()가 `NaN`을 반환합니다.

그러나 ECMA-262에 정의 된 ISO 형식으로 인식되지 않는 날짜 문자열의 잘못된 값은 제공된 브라우저 및 값에 따라 `NaN`이 될 수도 있고 그렇지 않을 수도 있습니다 (예 :

```js
// Non-ISO string with invalid date values
new Date("23/25/2014");
```

Firefox 30에서는 2015 년 11 월 25 일, Safari 7에서는 유효하지 않은 날짜로 처리됩니다. 그러나 문자열이 ISO 형식 문자열로 인식되고 유효하지 않은 값을 포함하면 `NaN`  ES5 이상을 준수하는 모든 브라우저에서 :

```js
// ISO string with invalid values
new Date("2014-25-23").toISOString();
// returns "RangeError: invalid date" in all es5 compliant browsers
```

SpiderMonkey의 구현 관련 추론은 jsdate.cpp에서 찾을 수 있습니다. 문자열 "10 06 2014"는 부적합한 ISO 형식의 예이므로 맞춤 루틴으로 되돌아갑니다. 파싱이 어떻게 작동하는지에 대한 대략적인 개요를 참조하십시오.

```js
new Date("10 06 2014");
```

2014 년 10 월 6 일과 2014 년 6 월 10 일이 아닌 현지 날짜로 취급됩니다. 다른 예 :

```js
new Date("foo-bar 2014").toString();
// returns: "Invalid Date"

Date.parse("foo-bar 2014");
// returns: NaN
```

Examples
--------

### Using `Date.parse()`

IPOdate가 기존의 `Date` 객체 인 경우 다음과 같이 1995 년 8 월 9 일 (현지 시간)으로 설정할 수 있습니다.

```js
IPOdate.setTime(Date.parse("Aug 9, 1995"));
```

표준이 아닌 날짜 문자열을 파싱하는 몇 가지 다른 예는 다음과 같습니다.

```js
Date.parse("Aug 9, 1995");
```

문자열이 표준 시간대를 지정하지 않고 ISO 형식이 아니므로 표준 시간대 GMT-0300의 807937200000과 다른 표준 시간대의 다른 값을 반환하므로 표준 시간대는 기본적으로 local입니다.

```js
Date.parse("Wed, 09 Aug 1995 00:00:00 GMT");
```

GMT (UTC)가 제공되는 현지 시간대와 상관없이 807926400000을 반환합니다.

```js
Date.parse("Wed, 09 Aug 1995 00:00:00");
```

인수에 표준 시간대 지정자가 없으므로 ISO 형식이 아니기 때문에 표준 시간대 GMT-0300에서 807937200000과 다른 표준 시간대의 다른 값을 반환하므로 로컬로 처리됩니다.

```js
Date.parse("Thu, 01 Jan 1970 00:00:00 GMT");
```

현지 시간대와 상관없이 0을 반환합니다. GMT (UTC)가 제공됩니다.

```js
Date.parse("Thu, 01 Jan 1970 00:00:00");
```

표준 시간대가 제공되지 않고 문자열이 ISO 형식이 아니기 때문에 표준 시간대 GMT-0400의 14400000과 다른 표준 시간대의 다른 값을 반환하므로 현지 표준 시간대가 사용됩니다.

```js
Date.parse("Thu, 01 Jan 1970 00:00:00 GMT-0400");
```

현지 시간대와 관계없이 14400000을 반환합니다. GMT (UTC)가 제공됩니다.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.parse |

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

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

See also
--------

* `Date.UTC()`


Date.prototype.setTime() - JavaScript

Date.prototype.setTime()
========================

**`setTime()`** 메서드는 `Date` 객체를 1970년 1월 1일 00:00:00 UTC부터
 밀리 초 단위로 나타내는 시간으로 설정합니다.

시도해보기
-----

구문
--

```js
setTime(timeValue)
```

### 매개변수

`timeValue`

1970년 1월 1일 00:00:00 UTC 이후의 밀리 초 수를 나타내는 정수 값 입니다.

### 반환 값

1970년 1월 1일 00:00:00 UTC와 업데이트 된 날짜 (사실상 인수의 값) 사이의 밀리 초 수입니다.

설명
--

`setTime()` 메서드를 사용하면 다른 `Date` 객체에 날짜와 시간을 지정할 수 있습니다.

예제
--

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

```js
const theBigDay = new Date("July 1, 1999");
const sameAsBigDay = new Date();
sameAsBigDay.setTime(theBigDay.getTime());
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.settime |

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

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

같이 보기
-----

* `Date.prototype.getTime()`
* `Date.prototype.setUTCHours()`


Date.prototype.setMonth() - JavaScript

Date.prototype.setMonth()
=========================

**`setMonth()`** 메서드는 현재 설정된 연도에 따라 지정된 날짜의 월을 설정합니다.

시도해보기
-----

구문
--

```js
setMonth(monthValue)
setMonth(monthValue, dayValue)
```

### 매개변수

`monthValue`

 연도의 시작에서 오프셋된 연도의 월을 나타내는 0 기반 정수입니다.
 그래서 0은 1월, 11은 12월, -1은 전년도의 12월, 12는 다음 해의 1월을 나타냅니다.

`dayValue`

선택 사항. 한 달의 날짜를 나타내는 1에서 31 사이의 정수입니다.

### 반환 값

1970년 1월 1일 00:00:00 UTC와 업데이트 된 날짜 사이의 밀리 초 숫자입니다.

설명
--

`dayValue` 매개 변수를 지정하지 않으면 `getDate()`
 메서드에서 반환 된 값이 사용됩니다.

 지정한 매개 변수가 예상 범위를 벗어나면 `setMonth()`는 그에 따라 `Date` 객체의 날짜 정보를
 업데이트하려고 시도합니다. 예를 들어 `monthValue`에 15를 사용하면 연도 값이 1 증가하고
 월 값은 3이 됩니다.

 현재 날짜가 이 메서드의 동작에 영향을 미칩니다.
 개념적으로 새로운 날짜를 반환하기 위해 매개 변수로 지정된 새 달의 첫 번째 날에 해당 월의 현재 날짜로 지정된 일 수를 추가합니다.
 예를 들어 현재 값이 2016년 8월 31일인 경우 setMonth의 매개 변수에 1을 넣고 함께 호출하면 2016년 3월 2일을 반환됩니다.
 이는 2016년 2월에 29일이 있기 때문입니다.

예제
--

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

```js
const theBigDay = new Date();
theBigDay.setMonth(6);

// Watch out for end of month transitions
const endOfMonth = new Date(2016, 7, 31);
endOfMonth.setMonth(1);
console.log(endOfMonth); //Wed Mar 02 2016 00:00:00
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.setmonth |

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

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

같이 보기
-----

* `Date.prototype.getMonth()`
* `Date.prototype.setUTCMonth()`


Date.prototype.getUTCHours() - JavaScript

Date.prototype.getUTCHours()
============================

getUTCHours () 메서드는 표준시에 따라 지정된 날짜의 시간을 반환합니다.

Syntax
------

```js
dateObj.getUTCHours();
```

### Return value

0부터 23까지의 정수로, 표준시에 따라 지정된 날짜의 시간을 나타냅니다.

Examples
--------

### Using `getUTCHours()`

다음 예제에서는 현재 시간의 시간 부분을 시간 변수로 지정합니다.

```js
var today = new Date();
var hours = today.getUTCHours();
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getutchours |

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

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

See also
--------

* `Date.prototype.getHours()`
* `Date.prototype.setUTCHours()`


Date.prototype.getSeconds() - JavaScript

Date.prototype.getSeconds()
===========================

**`getSeconds()`** 메서드는 `Date` 객체의 초 값을 현지 시간에 맞춰 반환합니다.

시도해보기
-----

구문
--

```js
dateObj.getSeconds();
```

### 반환 값

현지 시간 기준 초를 나타내는 0에서 59 사이의 정수.

예제
--

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

다음 예제는 `Date` 객체 `Xmas95`의 값을 사용해 변수 `seconds`에 30을 할당합니다.

```js
var Xmas95 = new Date("December 25, 1995 23:15:30");
var seconds = Xmas95.getSeconds();

console.log(seconds); // 30
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getseconds |

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

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

같이 보기
-----

* `Date.prototype.getUTCSeconds()`
* `Date.prototype.setSeconds()`


Date() 생성자 - JavaScript

Date() 생성자
==========

**`Date`** 생성자는 시간의 특정 지점을 나타내는 `Date` 객체를 플랫폼에 종속되지 않는 형태로 생성합니다.
 `Date` 객체는 1970년 1월 1일 UTC(국제표준시) 자정으로부터 지난 시간을 밀리초로 나타내는 UNIX 타임스탬프를
 담습니다.

시도해보기
-----

구문
--

```js
new Date();
new Date(value);
new Date(dateString);

new Date(year, monthIndex);
new Date(year, monthIndex, day);
new Date(year, monthIndex, day, hours);
new Date(year, monthIndex, day, hours, minutes);
new Date(year, monthIndex, day, hours, minutes, seconds);
new Date(year, monthIndex, day, hours, minutes, seconds, milliseconds);
```

**참고:** 새로운 `Date<` 객체를 생성하는 방법은 `new` 연산자를
 사용하는 것이 유일합니다. `now = Date()<`처럼 `Date<`를 직접 호출하면 새로운
 `Date<` 객체가 아니라 문자열을 반환합니다.

### 매개변수

`Date()` 생성자는 네 가지 형태로 사용할 수 있습니다.

#### 매개변수 없음

매개변수를 제공하지 않으면, 생성 순간의 날짜와 시간을 나타내는 `Date` 객체를 생성합니다.

#### UNIX 타임스탬프 값

`value`

UNIX 타임스탬프,
 즉 1970년 1월 1일 00:00:00 UTC(UNIX 시간)부터의 시간을 밀리초 단위로 표현하되 윤초는 무시한 정수 값입니다.
 대부분의 UNIX 타임스탬프 함수는 초 단위까지만 정확함을 유의하세요.

#### 타임스탬프 문자열

`dateString`

`Date.parse()` 메서드가 인식할 수 있는 형태로 나타낸 날짜 문자열입니다.
 IETF 호환 RFC 2822 타임스탬프와,
 ISO8601의 특정 버전을 인식할 수
 있습니다.

**참고:** `Date` 생성자(및 동일한 동작의 `Date.parse()`)를 사용한 날짜
 파싱은 동작이 일관적이지 못하고 브라우저끼리 차이가 존재하므로 사용하지 않는 것이 좋습니다.

* RFC 2822
 형식 문자열은 관례적으로만 지원하는 것 뿐입니다.
* ISO 8601 형식 문자열은 시간 정보 없는 문자열(`"1970-01-01"`
 등)을 현지 시간이 아닌 UTC 기준으로 처리하는 점에서 표준과 다릅니다.

#### 개별 날짜 및 시간 구성 요소

 최소한 연도와 월이 주어졌을 때, `Date()`의 이 형태는 `Date` 객체를 생성할 때 모든 구성
 요소(연, 월, 일, 시, 분, 초, 밀리초)를 모두 매개변수에서 가져옵니다. 누락한 요소에는 가장 낮은
 값(`day`는 1, 나머지는 0)을 사용합니다. 모든 매개변수 값은 UTC가 아닌 현지 시간으로 취급합니다.

`year`

 연도를 나타내는 정수 값입니다.`0`부터 `99`까지는 `1900`부터 `1999`로 처리합니다. 다른 모든 값은
 그대로 사용합니다.
 예제를 참고하세요.

`monthIndex`

 월을 나타내는 정수 값입니다. 1월을 나타내는 `0`부터 12월을 나타내는 `11`까지 사용할 수
 있습니다.

`day` Optional

일을 나타내는 정수 값입니다. 기본값은 `1`입니다.

`hours` Optional

 시를 나타내는 정수 값입니다. 기본 값은 자정을 나타내는
 `0`입니다.

`minutes` Optional

 분을 나타내는 정수 값입니다. 기본 값은 정각을 나타내는
 `0`입니다.

`seconds` Optional

 초를 나타내는 정수 값입니다. 기본 값은
 `0`초입니다.

`milliseconds` Optional

 밀리초를 나타내는 정수 값입니다. 기본 값은
 `0`밀리초입니다.

예제
--

### Date 객체를 만드는 여러가지 방법

아래 예제는 JavaScript 날짜를 생성하는 몇 가지 방법을 보입니다.

**참고:** `Date` 생성자(및 동일한 동작의 `Date.parse()`)를 사용한 날짜 파싱은
 동작이 일관적이지 못하고 브라우저끼리 차이가 존재하므로 사용하지 않는 것이 좋습니다.

```js
let today = new Date();
let birthday = new Date("December 17, 1995 03:24:00");
let birthday = new Date("1995-12-17T03:24:00");
let birthday = new Date(1995, 11, 17); // 월은 0부터 시작
let birthday = new Date(1995, 11, 17, 3, 24, 0);
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date-constructor |

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

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

같이 보기
-----

* `Date`


Date.prototype.getUTCDay() - JavaScript

Date.prototype.getUTCDay()
==========================

**getUTCDay()** 메서드는 지정된 날짜의 요일을 표준시에 따라 반환합니다. 여기서 0은 일요일을 나타냅니다.

Syntax
------

```js
dateObj.getUTCDay();
```

### Return value

지정된 날짜의 요일에 해당하는 표준시에 따른 정수입니다 (일요일은 0, 월요일은 1, 화요일은 2 등).

Examples
--------

### Using `getUTCDay()`

다음 예제에서는 현재 날짜의 평일 부분을 weekday 변수에 할당합니다.

```js
var today = new Date();
var weekday = today.getUTCDay();
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.getutcday |

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

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

See also
--------

* `Date.prototype.getUTCDate()`
* `Date.prototype.getDay()`
* `Date.prototype.setUTCDate()`


Date.prototype.getTime() - JavaScript

Date.prototype.getTime()
========================

**getTime()** 메서드는 표준시에 따라 지정된 날짜의 시간에 해당하는 숫자 값을 반환합니다.

이 메서드를 사용하면 다른 `Date` 객체에 날짜와 시간을 지정할 수 있습니다. 이 메소드는 기능적으로 `valueOf()` 메소드와 동일합니다.

Syntax
------

```js
dateObj.getTime();
```

### Return value

1970 년 1 월 1 일 00:00:00 UTC와 주어진 날짜 사이의 경과 시간 (밀리 초)을 나타내는 숫자입니다.

Examples
--------

### 날짜 복사에 getTime () 사용

동일한 시간 값으로 날짜 객체를 생성합니다.

```js
// 월은 0부터 시작하여 생일은 1995 년 1 월 10 일이됩니다.
var birthday = new Date(1994, 12, 10);
var copy = new Date();
copy.setTime(birthday.getTime());
```

### 측정 실행 시간

새로 생성 된 `Date` 객체에서 두 개의 연속 getTime () 호출을 뺀 후에이 두 호출 사이의 시간 범위를 지정하십시오. 일부 작업의 실행 시간을 계산하는 데 사용할 수 있습니다. 불필요한 `Date` 객체를 인스턴스화하지 않으려면 `Date.now()`를 참조하십시오.

```js
var end, start;

start = new Date();
for (var i = 0; i < 1000; i++) {
  Math.sqrt(i);
}
end = new Date();

console.log("Operation took " + (end.getTime() - start.getTime()) + " msec");
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.gettime |

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

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

See also
--------

* `Date.prototype.setTime()`
* `Date.prototype.valueOf()`
* `Date.now()`


Date.prototype.setFullYear() - JavaScript

Date.prototype.setFullYear()
============================

**setFullYear()** 메서드는 현지 시간에 따라 지정된 날짜의 전체 연도를 설정합니다. 새로운 타임 스탬프를 반환합니다.

Syntax
------

```js
    dateObj.setFullYear(yearValue[, monthValue[, dayValue]])
```

### Parameters

`yearValue`

연도의 숫자 값을 지정하는 정수입니다 (예 : 1995).

`monthValue`

선택 과목. 1 월에서 12 월까지의 월을 나타내는 0에서 11 사이의 정수입니다.

`dayValue`

선택 과목. 한 달의 날짜를 나타내는 1 - 31 사이의 정수입니다. dayValue 매개 변수를 지정하는 경우 monthValue도 지정해야합니다.

### Return value

1970 년 1 월 1 일 00:00:00 UTC와 업데이트 된 날짜 사이의 밀리 초 숫자입니다.

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

monthValue 및 dayValue 매개 변수를 지정하지 않으면 `getMonth()` 및 `getDate()` 메소드가 사용됩니다.

지정한 매개 변수가 예상 범위를 벗어나면 setFullYear ()가 다른 매개 변수와 `Date` 객체의 날짜 정보를 그에 따라 업데이트하려고 시도합니다. 예를 들어, monthValue에 15를 지정하면 연도가 1 (yearValue + 1)만큼 증가하고 3은 해당 월에 사용됩니다.

Examples
--------

### Using `setFullYear()`

```js
var theBigDay = new Date();
theBigDay.setFullYear(1997);
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-date.prototype.setfullyear |

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

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

See also
--------

* `Date.prototype.getUTCFullYear()`
* `Date.prototype.setUTCFullYear()`
* `Date.prototype.setYear()` (en-US)