recursal/MDN huggingface dataset:
Intl.NumberFormat
=================

\*\*`Intl.NumberFormat`\*\*은 언어에 맞는 숫자 서식을 지원하는 객체의 생성자입니다.

시도해보기
-----

생성자
---

`Intl.NumberFormat()` (en-US)

Creates a new `NumberFormat` object.

정적 메서드
------

`Intl.NumberFormat.supportedLocalesOf()` (en-US)

주어진 로케일 목록 중, 런타임이 지원하는 항목을 배열로 반환합니다.

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

`Intl.NumberFormat.prototype.format()` (en-US)

Getter function that formats a number according to the locale and formatting options of this `Intl.NumberFormat` object.

`Intl.NumberFormat.prototype.formatToParts()` (en-US)

Returns an `Array` of objects representing the number string in parts that can be used for custom locale-aware formatting.

`Intl.NumberFormat.prototype.formatRange()` (en-US)

Getter function that formats a range of numbers according to the locale and formatting options of the `Intl.NumberFormat` object from which the method is called.

`Intl.NumberFormat.prototype.formatRangeToParts()` (en-US)

Returns an `Array` of objects representing the range of number strings in parts that can be used for custom locale-aware formatting.

`Intl.NumberFormat.prototype.resolvedOptions()` (en-US)

Returns a new object with properties reflecting the locale and collation options computed during initialization of the object.

예제
--

### 기본적인 사용 방법

로케일을 지정하지 않고 사용하면 기본 로케일 및 기본 옵션 서식을 적용한 문자열을 반환합니다.


```js
var number = 3500;

console.log(new Intl.NumberFormat().format(number));
// → 한국 로케일의 경우 '3,500' 표시
```

### `locales` 사용하기

다음 예제는 지역화된 숫자 서식의 예시를 보입니다. 어플리케이션의 사용자 인터페이스 언어에 맞는 서식을 적용하려면 `locales` 매개변수로 적절한 언어(와, 필요한 경우 대체 언어)를 제공하는걸 잊지 마세요.


```js
var number = 123456.789;

// 독일은 소수점 구분자로 쉼표를 사용하고 천 단위 구분자로 마침표를 사용
console.log(new Intl.NumberFormat("de-DE").format(number));
// → 123.456,789

// 대부분의 아랍어 사용 국가에서는 실제 아라비아 숫자를 사용
console.log(new Intl.NumberFormat("ar-EG").format(number));
// → ١٢٣٤٥٦٫٧٨٩

// 인도는 천, 라크(십만), 크로르(천만) 단위에 구분자 사용
console.log(new Intl.NumberFormat("en-IN").format(number));
// → 1,23,456.789

// nu 확장 키로 기수법 지정 (아래 예시는 중국식 숫자 표기)
console.log(new Intl.NumberFormat("zh-Hans-CN-u-nu-hanidec").format(number));
// → 一二三,四五六.七八九

// 발리어와 같이 지원되지 않을 수도 있는 언어를 지정할 때는
// 다음과 같이 대체 언어를 지정할 수 있음. 아래의 경우 대체 언어는 인도어
console.log(new Intl.NumberFormat(["ban", "id"]).format(number));
// → 123.456,789
```

### `options` 사용

`options` 매개변수를 지정해 결과를 원하는 형태로 바꿀 수 있습니다.


```js
var number = 123456.789;

// 통화 서식
console.log(
  new Intl.NumberFormat("de-DE", { style: "currency", currency: "EUR" }).format(
    number,
  ),
);
// → 123.456,79 €

// 한국 원화는 보조 통화 단위를 사용하지 않음
console.log(
  new Intl.NumberFormat("ko-KR", { style: "currency", currency: "KRW" }).format(
    number,
  ),
);
// → ₩123,457

// 유효숫자를 세 개로 제한
console.log(
  new Intl.NumberFormat("en-IN", { maximumSignificantDigits: 3 }).format(
    number,
  ),
);
// → 1,23,000
```

명세
--

| Specification |
| --- |
| ECMAScript Internationalization API Specification # numberformat-objects |

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

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

같이 보기
-----

* `Intl` (en-US)
* A polyfill of `Intl.NumberFormat` in FormatJS
Intl.supportedValuesOf()
========================

**`Intl.supportedValuesOf()`** 메서드는 지원되는 역법(calendar), 콜레이터, 통화, 수 체계 또는 구현시 지원되는 단위 값을 포함하는 배열을 반환합니다.

중복 값들은 제거되며, 배열은 알파벳 오름차순으로 정렬(정확하게는 `Array.prototype.sort()`)에 `undefined` 비교 함수를 사용하여 정렬)됩니다.

 이 메서드는 특정 기능 구현시에 값이 지원되는지 여부를 테스트하고, 필요한 경우에만 폴리필을 다운로드받는데 사용할 수 있습니다.
 또한 사용자가 선호하는 지역화된 값을 선택할 수 있게 하는 UI(예를 들어 UI가 WebGL 또는 서버사이드로 구현되었을 때)를 만드는 데에도 사용됩니다.

시도해보기
-----

구문
--


```js
Intl.supportedValuesOf(key)
```

### 매개변수

`key`

 반환할 값의 범주를 나타내는 키 문자열로,
 `"calendar"`, `"collation"`, `"currency"`,`"numberingSystem"`, `"timeZone"`, `"unit"` 중의 하나입니다.


### 반환 값

지정된 Key에 대해 구현시 지원하는 값을 나타내는 고유한 문자열 값의 정렬된 배열입니다.

### 예외

`RangeError`

지원되지 않는 Key가 인자로 전달되었을 때

예제
--

### 기능 테스트

메서드가 지원되는지 여부를 `undefined`과 비교하여 확인할 수 있습니다.


```js
if (typeof Intl.supportedValuesOf !== "undefined") {
  // 메서드가 지원됩니다.
}
```

### Key의 모든 값 가져오기

 달력에 지원되는 값을 확인하기 위해서는 `"calendar"` 키로 메서드를 실행합니다.
 아래와 같이 반환된 배열을 반복 탐색합니다.


```js
Intl.supportedValuesOf("calendar").forEach((calendar) => {
  // "buddhist", "chinese", "coptic", "dangi", 등.
});
```


**참고:** calendar 값으로 반환된 배열은 항상 "gregory" (그레고리력)을 포함합니다.

다른 값도 동일한 방식으로 확인할 수 있습니다.


```js
Intl.supportedValuesOf("collation").forEach((collation) => {
  // "big5han", "compat", "dict", "emoji", 등.
});

Intl.supportedValuesOf("currency").forEach((currency) => {
  // "ADP", "AED", "AFA", "AFN", "ALK", "ALL", "AMD", 등.
});

Intl.supportedValuesOf("numberingSystem").forEach((numberingSystem) => {
  // "adlm", "ahom", "arab", "arabext", "bali", 등.
});

Intl.supportedValuesOf("timeZone").forEach((timeZone) => {
  // "Africa/Abidjan", "Africa/Accra", "Africa/Addis\_Ababa", "Africa/Algiers", 등.
});

Intl.supportedValuesOf("unit").forEach((unit) => {
  // "acre", "bit", "byte", "celsius", "centimeter", 등.
});
```

### 유효하지 않은 Key 사용시 RangeError 발생


```js
try {
  Intl.supportedValuesOf("유효하지 않은 키");
} catch (err) {
  //Error: RangeError: invalid key: "유효하지 않은 키"
}
```

명세서
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-intl.supportedvaluesof |

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

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

같이 보기
-----

* `Intl` (en-US)
* A polyfill of `Intl.supportedValuesOf` in FormatJS
Intl.Locale.prototype.language
==============================

**`Intl.Locale.prototype.language`** 속성은 locale과 관련된 언어를 반환하는 접근자 속성입니다.

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

언어는 locale의 핵심 기능 중 하나입니다. 유니 코드 사양은 locale의 언어 식별자를 언어와 지역으로 함께 취급합니다 (예를 들어 영국 영어와 미국 영어 등의 방언과 변형을 구별하기 위해). `Locale` (en-US)의 language 속성은 로캘의 언어 하위 태그를 엄격하게 반환합니다.

Examples
--------

### locale 식별자 문자열 인수에서 언어 설정

유효한 유니 코드 locale 식별자가 되려면 문자열이 언어 하위 태그로 시작해야합니다. `Locale` (en-US) 생성자에 대한 주요 인수는 유효한 유니 코드 locale 식별자여야하므로 생성자가 사용될 때마다 언어 하위 태그가있는 식별자를 전달해야합니다.


```js
let langStr = new Intl.Locale("en-Latn-US");

console.log(langStr.language); // Prints "en"
```

### configuration 객체로 언어 오버라이딩 하기

언어 하위 태그를 지정해야하지만 `Locale` (en-US) 생성자는 언어 하위 태그를 재정의 할 수있는 구성 개체를 사용합니다.


```js
let langObj = new Intl.Locale("en-Latn-US", { language: "es" });

console.log(langObj.language); // Prints "es"
```

명세서
---

| Specification |
| --- |
| ECMAScript Internationalization API Specification # sec-Intl.Locale.prototype.language |

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

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

See also
--------

* `Locale` (en-US)
* Unicode language subtag specification
Reflect.isExtensible()
======================

**`Reflect.isExtensible()`** 정적 메서드는 객체의 확장 가능 여부, 즉 속성을 추가할 수 있는지 판별합니다. `Object.isExtensible()`과 유사하지만 차이점도 있습니다.

시도해보기
-----

구문
--


```js
Reflect.isExtensible(target);
```

### 매개변수

`target`

확장 가능 여부를 판별할 대상 객체.

### 반환 값

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

### 예외

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.isExtensible()` 메서드는 `Object.isExtensible()`와 유사하게, 객체에 새로운 속성을 추가할 수 있는지 판별합니다.

예제
--

### `Reflect.isExtensible()` 사용하기

`Object.isExtensible()`도 참고하세요.


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

// ...하지만 바꿀 수 있음
Reflect.preventExtensions(empty);
Reflect.isExtensible(empty); // === false

// 봉인한 객체는 확장 불가능함
var sealed = Object.seal({});
Reflect.isExtensible(sealed); // === false

// 동결한 객체도 확장 불가능함
var frozen = Object.freeze({});
Reflect.isExtensible(frozen); // === false
```

### `Object.isExtensible()`과의 차이점

`Reflect.isExtensible()`은 첫 번째 매개변수가 원시값이면 `TypeError`를 던집니다. 반면 `Object.isExtensible()`은 우선 객체로 변환을 시도합니다.


```js
Reflect.isExtensible(1);
// TypeError: 1 is not an object

Object.isExtensible(1);
// false
```

명세
--

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

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

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

같이 보기
-----

* `Reflect`
* `Object.isExtensible()`
Reflect.preventExtensions()
===========================

**`Reflect.preventExtensions()`** 정적 메서드는 새로운 속성을 객체에 추가하지 못하도록 완전히 막습니다. 즉, 미래의 객체 확장을 막습니다. `Object.preventExtensions()`와 유사하지만 차이점도 있습니다.

시도해보기
-----

구문
--


```js
Reflect.preventExtensions(target);
```

### 매개변수

`target`

확장을 방지할 대상 객체.

### 반환 값

대상의 확장을 성공적으로 방지했는지 나타내는 `Boolean`.

### 예외

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.preventExtensions()` 메서드는 새로운 속성을 객체에 추가하지 못하도록 완전히 막습니다. 즉, 미래의 객체 확장을 막습니다. `Object.preventExtensions()`와 유사합니다.

예제
--

### `Reflect.preventExtensions()` 사용하기

`Object.preventExtensions()`도 참고하세요.


```js
// 객체는 기본적으로 확장 가능
var empty = {};
Reflect.isExtensible(empty); // === true

// ...하지만 바꿀 수 있음
Reflect.preventExtensions(empty);
Reflect.isExtensible(empty); // === false
```

### `Object.preventExtensions()`와의 차이점

`Reflect.preventExtensions()`는 첫 번째 매개변수가 원시값이면 `TypeError`를 던집니다. 반면 `Object.preventExtensions()`는 우선 객체로 변환을 시도합니다.


```js
Reflect.preventExtensions(1);
// TypeError: 1 is not an object

Object.preventExtensions(1);
// 1
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.preventextensions |

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

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

같이 보기
-----

* `Reflect`
* `Object.isExtensible()`
Reflect.setPrototypeOf()
========================

**`Reflect.setPrototypeOf()`** 정적 메서드는 주어진 객체의 프로토타입(내부 `[[Prototype]]` 속성)을 다른 객체나 `null`로 바꿉니다. 반환 값을 제외하면 `Object.setPrototypeOf()` (en-US) 메서드와 같습니다.

시도해보기
-----

구문
--


```js
Reflect.setPrototypeOf(target, prototype);
```

### 매개변수

`target`

프로토타입을 지정할 대상 객체.

`prototype`

대상 객체의 새로운 프로토타입. (객체 또는 `null`

### 반환 값

프로토타입 설정 성공 여부를 나타내는 `Boolean`.

### 예외

`target`이 `Object`가 아니거나, `prototype`이 객체도 `null`도 아니면 `TypeError`.

설명
--

`Reflect.setPrototypeOf()` 메서드는 주어진 객체의 프로토타입(즉, 내부 `[[Prototype]]` 속성)을 변경합니다.

예제
--

### `Reflect.setPrototypeOf()` 사용하기


```js
Reflect.setPrototypeOf({}, Object.prototype); // true

// It can change an object's [[Prototype]] to null.
Reflect.setPrototypeOf({}, null); // true

// Returns false if target is not extensible.
Reflect.setPrototypeOf(Object.freeze({}), null); // false

// Returns false if it cause a prototype chain cycle.
const target = {};
const proto = Object.create(target);
Reflect.setPrototypeOf(target, proto); // false
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.setprototypeof |

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

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

같이 보기
-----

* `Reflect`
* `Object.setPrototypeOf()` (en-US)
Reflect.getOwnPropertyDescriptor()
==================================

**`Reflect.getOwnPropertyDescriptor()`** 정적 메서드는 객체에 주어진 속성이 존재하면, 해당 속성의 서술자를 반환합니다. `Object.getOwnPropertyDescriptor()`와 유사합니다.

시도해보기
-----

구문
--


```js
Reflect.getOwnPropertyDescriptor(target, propertyKey);
```

### 매개변수

`target`

속성을 탐색할 객체.

`propertyKey`

자체 속성 서술자를 가져올 속성의 이름.

### 반환 값

대상 속성이 객체에 존재하면, 그 속성의 서술자. 존재하지 않으면 `undefined`.

### 예제

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.getOwnPropertyDescriptor` 메서드는 객체 속성의 서술자를 반환합니다. 만약 존재하지 않는 속성이라면 `undefined`를 대신 반환합니다. `Object.getOwnPropertyDescriptor()`와의 유일한 차이는 객체가 아닌 대상의 처리 방법입니다.

예제
--

### `Reflect.getOwnPropertyDescriptor()` 사용하기


```js
Reflect.getOwnPropertyDescriptor({ x: "hello" }, "x");
// {value: "hello", writable: true, enumerable: true, configurable: true}

Reflect.getOwnPropertyDescriptor({ x: "hello" }, "y");
// undefined

Reflect.getOwnPropertyDescriptor([], "length");
// {value: 0, writable: true, enumerable: false, configurable: false}
```

### `Object.getOwnPropertyDescriptor()`와의 차이점

`Reflect.getOwnPropertyDescriptor()`의 첫 번째 매개변수가 객체가 아니고 원시값이라면 `TypeError`가 발생합니다. 반면 `Object.getOwnPropertyDescriptor()`는 같은 상황에서 값을 우선 객체로 변환합니다.


```js
Reflect.getOwnPropertyDescriptor("foo", 0);
// TypeError: "foo" is not non-null object

Object.getOwnPropertyDescriptor("foo", 0);
// { value: "f", writable: false, enumerable: true, configurable: false }
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.getownpropertydescriptor |

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

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

같이 보기
-----

* `Reflect`
* `Object.getOwnPropertyDescriptor()`
Reflect.construct()
===================

**`Reflect.construct()`** 정적 메서드는 `new` 연산자처럼 동작하는 함수입니다. `new target(...args)`를 호출하는 것과 같습니다. 추가 기능으로 다른 프로토타입을 지정할 수도 있습니다.

시도해보기
-----

구문
--


```js
Reflect.construct(target, argumentsList[, newTarget])
```

### 매개변수

`target`

호출할 대상 함수.

`argumentsList`

`target`의 매개변수로 전달할 배열형 객체.

`newTarget` Optional

프로토타입으로 사용할 생성자. `new.target` 연산자도 확인하세요. `newTarget`이 주어지지 않았을 땐 `target`을 사용합니다.

### 반환 값

`target`을 생성자로 하고 주어진 매개변수를 전달해 생성한 `target`(또는, 지정했다면 `newTarget`)의 새로운 인스턴스.

### 예외

`target` 또는 `newTarget`이 생성자가 아니면 `TypeError`.

설명
--

`Reflect.construct()`는 생성자를 가변 길이의 매개변수로 호출할 수 있습니다. (`new` 연산자와 전개 구문을 사용해도 가능합니다)


```js
var obj = new Foo(...args);
var obj = Reflect.construct(Foo, args);
```

### `Reflect.construct()` vs `Object.create()`

`Reflect`의 도입 이전에는 임의의 생성자와 프로토타입에 `Object.create()`를 사용해 객체를 생성할 수 있었습니다.


```js
function OneClass() {
  this.name = "one";
}

function OtherClass() {
  this.name = "other";
}

// Calling this:
var obj1 = Reflect.construct(OneClass, args, OtherClass);

// ...has the same result as this:
var obj2 = Object.create(OtherClass.prototype);
OneClass.apply(obj2, args);

console.log(obj1.name); // 'one'
console.log(obj2.name); // 'one'

console.log(obj1 instanceof OneClass); // false
console.log(obj2 instanceof OneClass); // false

console.log(obj1 instanceof OtherClass); // true
console.log(obj2 instanceof OtherClass); // true
```


그러나, 결과는 동일하더라도 과정에는 중요한 차이가 하나 존재합니다. `Object.create()`와 `Function.prototype.apply()`를 사용할 땐, 객체 생성에 `new` 키워드가 관여하지 않으므로 `new.target` 연산자가 `undefined`를 가리킵니다.

반면 `Reflect.construct()`를 호출하면, `newTarget`이 존재하면 `new.target` 연산자가 `newTarget`을, 아니면 `target`을 가리킵니다.


```js
function OneClass() {
  console.log("OneClass");
  console.log(new.target);
}
function OtherClass() {
  console.log("OtherClass");
  console.log(new.target);
}

var obj1 = Reflect.construct(OneClass, args);
// Output:
// OneClass
// function OneClass { ... }

var obj2 = Reflect.construct(OneClass, args, OtherClass);
// Output:
// OneClass
// function OtherClass { ... }

var obj3 = Object.create(OtherClass.prototype);
OneClass.apply(obj3, args);
// Output:
// OneClass
// undefined
```

예제
--

### `Reflect.construct()` 사용하기


```js
var d = Reflect.construct(Date, [1776, 6, 4]);
d instanceof Date; // true
d.getFullYear(); // 1776
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.construct |

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

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

같이 보기
-----

* `Reflect`
* `new`
* `new.target`
Reflect.ownKeys()
=================

**`Reflect.ownKeys()`** 정적 메서드는 대상 객체의 자체 속성 키를 배열로 반환합니다.

시도해보기
-----

구문
--


```js
Reflect.ownKeys(target);
```

### 매개변수

`target`

자체 키를 가져올 대상 객체.

### 반환 값

주어진 객체의 자체 속성 키를 담은 `Array`.

### 예외

`target`이 `Object`가 아니면 `TypeError`.

설명
--

The `Reflect.ownKeys()` 메서드는 대상 객체의 자체 속성 키를 배열로 반환합니다. 반환 값은 `Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))`와 동일합니다.

예제
--

### `Reflect.ownKeys()` 사용하기


```js
Reflect.ownKeys({ z: 3, y: 2, x: 1 }); // [ "z", "y", "x" ]
Reflect.ownKeys([]); // ["length"]

var sym = Symbol.for("comet");
var sym2 = Symbol.for("meteor");
var obj = {
  [sym]: 0,
  str: 0,
  773: 0,
  0: 0,
  [sym2]: 0,
  "-1": 0,
  8: 0,
  "second str": 0,
};
Reflect.ownKeys(obj);
// [ "0", "8", "773", "str", "-1", "second str", Symbol(comet), Symbol(meteor) ]
// Indexes in numeric order,
// strings in insertion order,
// symbols in insertion order
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.ownkeys |

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

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

같이 보기
-----

* `Reflect`
* `Object.getOwnPropertyNames()`
Reflect.has()
=============

**`Reflect.has()`** 정적 메서드는 `in` 연산자의 함수판입니다.

시도해보기
-----

구문
--


```js
Reflect.has(target, propertyKey);
```

### 매개변수

`target`

속성을 탐색할 객체.

`propertyKey`

탐색할 속성의 이름.

### 반환 값

객체가 속성을 가지고 있는지 나타내는 `Boolean`.

### 예외

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.has()` 메서드는 객체에 속성이 존재하는지 판별할 수 있습니다. `in` 연산자처럼 동작합니다.

예제
--

### `Reflect.has()` 사용하기


```js
Reflect.has({ x: 0 }, "x"); // true
Reflect.has({ x: 0 }, "y"); // false

// 프로토타입 체인에 존재하는 속성도 true 반환
Reflect.has({ x: 0 }, "toString");

// .has() 처리기 메서드를 가진 Proxy
obj = new Proxy(
  {},
  {
    has(t, k) {
      return k.startsWith("door");
    },
  },
);
Reflect.has(obj, "doorbell"); // true
Reflect.has(obj, "dormitory"); // false
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.has |

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

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

같이 보기
-----

* `Reflect`
* `in` 연산자
Reflect.get()
=============

**`Reflect.get()`** 정적 메서드는 객체의 속성을 가져오는 함수입니다. `target[propertyKey]`와 비슷합니다.

시도해보기
-----

구문
--


```js
Reflect.get(target, propertyKey[, receiver])
```

### 매개변수

`target`

속성을 가져올 대상 객체.

`propertyKey`

가져올 속성의 이름.

`receiver` Optional

대상 속성이 접근자라면 `this`의 값으로 사용할 값. `Proxy`와 함께 사용하면, 대상을 상속하는 객체를 사용할 수 있습니다.

### 반환 값

속성의 값.

### 예외

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.get` 메서드는 객체 속성의 값을 가져올 수 있습니다. 속성 접근자의 함수판이라고 할 수 있습니다.

예제
--

### `Reflect.get()` 사용하기


```js
// Object
var obj = { x: 1, y: 2 };
Reflect.get(obj, "x"); // 1

// Array
Reflect.get(["zero", "one"], 1); // "one"

// handler 매개변수와 Proxy
var x = { p: 1 };
var obj = new Proxy(x, {
  get(t, k, r) {
    return k + "bar";
  },
});
Reflect.get(obj, "foo"); // "foobar"
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.get |

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

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

같이 보기
-----

* `Reflect`
* 속성 접근자
Reflect.getPrototypeOf()
========================

**`Reflect.getPrototypeOf()`** 정적 메서드는 주어진 객체의 프로토타입을 반환합니다. `Object.getPrototypeOf()`와 거의 동일합니다.

시도해보기
-----

구문
--


```js
Reflect.getPrototypeOf(target);
```

### 매개변수

`target`

프로토타입을 가져올 대상 객체.

### 반환 값

주어진 객체의 프로토타입. 상속한 속성이 없으면 `null`을 반환합니다.

### 예외

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.getPrototypeOf()` 메서드는 주어진 객체의 프로토타입(`[[Prototype]]` 내부 객체의 값 등)을 반환합니다.

예제
--

### `Reflect.getPrototypeOf()` 사용하기


```js
Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // null
```

### `Object.getPrototypeOf()`와 비교


```js
// 객체에는 동일한 결과
Object.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf({}); // Object.prototype

// ES5에서는 비객체 대상에서 모두 오류
Object.getPrototypeOf("foo"); // Throws TypeError
Reflect.getPrototypeOf("foo"); // Throws TypeError

// ES2015에서는 Reflect만 오류, Object는 객체로 변환
Object.getPrototypeOf("foo"); // String.prototype
Reflect.getPrototypeOf("foo"); // Throws TypeError

// ES2015 Object 동작을 따라하려면 객체 변환과정 필요
Reflect.getPrototypeOf(Object("foo")); // String.prototype
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.getprototypeof |

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

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

같이 보기
-----

* `Reflect`
* `Object.getPrototypeOf()`
Reflect.deleteProperty()
========================

**`Reflect.deleteProperty()`** 정적 메서드는 속성을 제거할 수 있습니다. `delete` 연산자 (en-US)의 함수판이라고 할 수 있습니다.

시도해보기
-----

구문
--


```js
Reflect.deleteProperty(target, propertyKey);
```

### 매개변수

`target`

속성을 제거할 대상 객체.

`propertyKey`

제거할 속성의 이름.

### 반환 값

속성이 성공적으로 제거됐는지 나타내는 `Boolean`.

### Exceptions

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.deleteProperty` 메서드는 객체의 속성을 제거할 수 있습니다. 반환값은 속성의 제거 성공 여부를 나타내는 `Boolean`입니다. 비엄격 모드의 `delete` 연산자 (en-US)와 거의 동일합니다.

예제
--

### `Reflect.deleteProperty()` 사용하기


```js
var obj = { x: 1, y: 2 };
Reflect.deleteProperty(obj, "x"); // true
obj; // { y: 2 }

var arr = [1, 2, 3, 4, 5];
Reflect.deleteProperty(arr, "3"); // true
arr; // [1, 2, 3, , 5]

// 주어진 속성이 존재하지 않으면 true 반환
Reflect.deleteProperty({}, "foo"); // true

// 주어진 속성이 설정 불가능하면 false 반환
Reflect.deleteProperty(Object.freeze({ foo: 1 }), "foo"); // false
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.deleteproperty |

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

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

같이 보기
-----

* `Reflect`
* `delete` 연산자 (en-US)
Reflect.apply()
===============

**`Reflect.apply()`** 정적 메서드는 대상 함수를 주어진 매개변수로 호출합니다.

시도해보기
-----

구문
--


```js
Reflect.apply(target, thisArgument, argumentsList);
```

### 매개변수

`target`

호출할 대상 함수.

`thisArgument`

호출에서 `target`의 `this`로 사용할 값.

`argumentsList`

`target`을 호출할 때 매개변수로 전달할 배열형 객체.

### 반환 값

주어진 `this` 값과 매개변수로 대상 함수를 호출한 결과.

### 예외

`target`이 호출 가능한 객체가 아니면 `TypeError`.

설명
--

ES5에서는 `Function.prototype.apply()` 메서드를 사용해, 함수를 호출할 때 `this` 값을 지정하거나 매개변수를 배열(또는 배열형 객체)에서 넘겨줄 수 있었습니다.


```js
Function.prototype.apply.call(Math.floor, undefined, [1.75]);
```


`Reflect.apply()` 메서드를 사용해 같은 작업을 더 쉽고 유려하게 수행할 수 있습니다.

예제
--

### `Reflect.apply()` 사용하기


```js
Reflect.apply(Math.floor, undefined, [1.75]);
// 1;

Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
// "hello"

Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
// 4

Reflect.apply("".charAt, "ponies", [3]);
// "i"
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.apply |

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

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

같이 보기
-----

* `Reflect`
* `Function.prototype.apply()`
Reflect.set()
=============

**`Reflect.set()`** 정적 메서드는 객체 속성의 값을 설정합니다.

시도해보기
-----

구문
--


```js
Reflect.set(target, propertyKey, value[, receiver])
```

### 매개변수

`target`

속성의 값을 설정할 대상 객체.

`propertyKey`

값을 설정할 속성의 이름.

`value`

설정할 값.

`receiver` Optional

속성이 설정자일 경우, `this`로 사용할 값.

### 반환 값

값 설정의 성공 여부를 나타내는 `Boolean`.

### 예외

`target`이 `Object`가 아니면 `TypeError`.

설명
--

`Reflect.set()` 메서드는 객체 속성의 값을 설정할 수 있습니다. 속성 추가도 할 수 있으며, 함수라는 점을 제외하면 동작 방식은 속성 접근자와 같습니다.

예제
--

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


```js
// Object
var obj = {};
Reflect.set(obj, "prop", "value"); // true
obj.prop; // "value"

// Array
var arr = ["duck", "duck", "duck"];
Reflect.set(arr, 2, "goose"); // true
arr[2]; // "goose"

// 배열 자르기
Reflect.set(arr, "length", 1); // true
arr; // ["duck"];

// 매개변수를 하나만 제공하면 속성 키 이름은 문자열 "undefined", 값은 undefined
var obj = {};
Reflect.set(obj); // true
Reflect.getOwnPropertyDescriptor(obj, "undefined");
// { value: undefined, writable: true, enumerable: true, configurable: true }
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-reflect.set |

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

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

같이 보기
-----

* `Reflect`
* 속성 접근자