recursal/MDN huggingface dataset:
Reflect.defineProperty()
========================

**`Reflect.defineProperty()`** 정적 메서드는 `Object.defineProperty()`와 같은 동작을 하지만 `Boolean`을 반환합니다.

시도해보기
-----

구문
--


```js
Reflect.defineProperty(target, propertyKey, attributes);
```

### 매개변수

`target`

속성을 정의할 대상 객체.

`propertyKey`

정의하거나 수정할 속성의 이름.

`attributes`

정의하거나 수정하는 속성을 기술하는 객체.

### 반환 값

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

### 예외

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

설명
--

`Reflect.defineProperty` 메서드는 객체에 속성을 정교하게 추가하거나 수정할 수 있습니다. 자세한 내용은 유사한 메서드인 `Object.defineProperty`를 참고하세요. `Object.defineProperty`는 성공 시 대상 객체를 반환하고 실패하면 `TypeError`를 던지지만, `Reflect.defineProperty`는 성공 여부를 나타내는 `Boolean`을 반환합니다.

예제
--

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


```js
var obj = {};
Reflect.defineProperty(obj, "x", { value: 7 }); // true
obj.x; // 7
```

### 속성 정의의 성공 여부 알아내기

`Object.defineProperty`는 성공 시 객체를 반환하고, 실패 시 `TypeError`를 던지므로 속성 정의 과정에 발생할 수 있는 오류를 `try...catch` (en-US) 블록으로 잡아야 합니다. 반면 `Reflect.defineProperty`는 성공 여부를 나타내는 `Boolean`을 반환하므로, 간단하게 `if...else` 블록만 사용하면 됩니다.


```js
if (Reflect.defineProperty(target, property, attributes)) {
  // 성공
} else {
  // 실패
}
```

명세
--

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

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

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

같이 보기
-----

* `Reflect`
* `Object.defineProperty()`
URIError() constructor
======================

**`URIError()`** 생성자는 전역 URI 핸들링 함수가 잘못 사용될 때 오류를 생성합니다.

구문
--


```js
new URIError();
new URIError(message);
new URIError(message, fileName);
new URIError(message, fileName, lineNumber);
```

### 매개변수

`message` Optional

사람이 읽을 수 있는 에러에 대한 설명.

`fileName` Optional

예외를 일으킨 코드가 들어있는 파일 이름.

`lineNumber` Optional

예외를 일으킨 코드의 줄 수.

예제
--

### URIError 잡기


```js
try {
  decodeURIComponent("%");
} catch (e) {
  console.log(e instanceof URIError); // true
  console.log(e.message); // "malformed URI sequence"
  console.log(e.name); // "URIError"
  console.log(e.fileName); // "Scratchpad/1"
  console.log(e.lineNumber); // 2
  console.log(e.columnNumber); // 2
  console.log(e.stack); // "@Scratchpad/2:2:3\n"
}
```

### URIError 생성하기


```js
try {
  throw new URIError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof URIError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "URIError"
  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-nativeerror-constructors |

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

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

같이 보기
-----

* `Error`
* `decodeURI()`
* `decodeURIComponent()`
* `encodeURI()`
* `encodeURIComponent()`
RegExp.prototype.global
=======================

**`global`** 접근자 속성은 `g` 플래그가 정규표현식에 사용되었는지 여부를 나타냅니다.

시도해보기
-----

설명
--

`g` 플래그가 사용된 경우 `RegExp.prototype.global`의 값은 `true`이고, 그렇지 않으면 `false`입니다.
 `g` 플래그는 정규식이 문자열에서 가능한 모든 일치 항목에 대해 테스트되어야 함을 나타냅니다.
 `exec()` (en-US)를 호출할 때마다
 `lastIndex` (en-US) 속성이
 업데이트되므로 다음 `exec()` 호출은 다음 문자에서 시작됩니다.

`String.prototype.matchAll()` (en-US) 및 `String.prototype.replaceAll()`과 같은 일부 메서드는 매개변수가 정규식인 경우 전역(global)인지 여부를 확인합니다.
 정규식의 `@@match` (en-US) 및 `@@replace` (en-US) 메서드(`String.prototype.match()` 및 `String.prototype.replace()` (en-US)에 의해 호출됨)도 정규식이 전역일 때 다른 동작을 갖습니다.

`global`의 set 접근자는 `undefined`, 즉 정의되지 않았습니다. 이 속성은 직접 변경할 수 없습니다.

예제
--

### global 사용하기


```js
const regex = /foo/g;
console.log(regex.global); // true

const str = "fooexamplefoo";
const str1 = str.replace(regex, "");
console.log(str1); // example

const regex1 = /foo/;
const str2 = str.replace(regex1, "");
console.log(str2); // examplefoo
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.global |

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

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

같이 보기
-----

* `RegExp.prototype.lastIndex` (en-US)
* `RegExp.prototype.dotAll`
* `RegExp.prototype.hasIndices` (en-US)
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source` (en-US)
* `RegExp.prototype.sticky` (en-US)
* `RegExp.prototype.unicode` (en-US)
RegExp.prototype.dotAll
=======================

**`dotAll`** 속성은 `s` 플래그가 정규식과 함께 사용되는지 여부를 나타냅니다. `dotAll`은 개별 정규식 인스턴스의 읽기 전용 속성입니다.

시도해보기
-----

설명
--

`dotAll`의 값은 `Boolean`으로 `s` 플래그가 사용된 경우 `true`, 그렇지 않으면 `false`입니다.
 `s` 플래그는 점 특수 문자(`.`)가 문자열의 다음 줄 종결자("newline") 문자와 추가로 일치해야 함을 나타냅니다.
 그렇지 않으면 일치하지 않습니다.

* U+000A LINE FEED (LF) (`\n`)
* U+000D CARRIAGE RETURN (CR) (`\r`)
* U+2028 LINE SEPARATOR
* U+2029 PARAGRAPH SEPARATOR

이것은 사실상 점이 유니코드 BMP(Basic Multilingual Plane)의 모든 문자와 일치한다는 것을 의미합니다. 별 기호와 일치하도록 하려면 `u`(유니코드) 플래그를 사용해야 합니다. 두 플래그를 함께 사용하면 예외 없이 점이 모든 유니코드 문자와 일치하도록 만들 수 있습니다.

`dotAll`의 set 접근자는 `undefined`, 즉 정의되지 않았습니다. 이 속성은 직접 변경할 수 없습니다.

예제
--

### `dotAll` 사용하기


```js
const str1 = "bar\nexample foo example";

const regex1 = /bar.example/s;

console.log(regex1.dotAll); // true

console.log(str1.replace(regex1, "")); // foo example

const str2 = "bar\nexample foo example";

const regex2 = /bar.example/;

console.log(regex2.dotAll); // false

console.log(str2.replace(regex2, ""));
// bar
// example foo example
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.dotAll |

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

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

같이보기
----

* Polyfill of `dotAll` `RegExp` flag in `core-js`
* `RegExp.lastIndex` (en-US)
* `RegExp.prototype.global`
* `RegExp.prototype.hasIndices` (en-US)
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline`
* `RegExp.prototype.source` (en-US)
* `RegExp.prototype.sticky` (en-US)
* `RegExp.prototype.unicode` (en-US)
RegExp() constructor
====================

**`RegExp`** 생성자는 패턴을 사용해 텍스트를 판별할 때 사용하는 정규 표현식 객체를 생성합니다.

정규 표현식에 대한 소개는 JavaScript 안내서의 정규 표현식 장을 참고하세요.

시도해보기
-----

구문
--

리터럴, 생성자, 팩토리 표기법이 가능합니다.
```

/pattern/flags
new RegExp(pattern[, flags])
RegExp(pattern[, flags])
```

### 매개변수

`pattern`

 정규 표현식을 나타내는 텍스트.
 ES5부터는, 생성자 표기법에 한정하여 다른 `RegExp` 객체 혹은 리터럴을 사용할 수 있습니다. 패턴은 특수 문자를 포함할 수 있어서 일반적인 문자열 리터럴보다 더 넓은 범위의 값을 판별할 수 있습니다.


`flags`

 정규 표현식에 추가할 플래그.
 정규 표현식 객체를 패턴으로 제공한 경우 `flags` 문자열은 제공한 객체의 플래그를 모두 대체하며 `lastIndex`를 `0`으로 초기화합니다. (ES2015 이후)
 `flags`를 지정하지 않았으면서 정규 표현식 객체를 제공한 경우, 해당 객체의 플래그와 `lastIndex`를 복제합니다.
 `flags`는 다음 문자를 조합하여 지정할 수 있습니다.


`g` (global, 전역 판별)

처음 일치에서 중단하지 않고, 문자열 전체를 판별합니다.

`i` (ignore case, 대소문자 무시)

`u` 플래그까지 활성화된 경우, Unicode 대소문자 폴딩을 사용합니다.

`m` (multiline, 여러 줄)

시작과 끝 문자(`^`과 `$`)가 여러 줄에 걸쳐 동작합니다. 즉, 전체 입력 문자열의 맨 처음과 맨 끝 뿐만 아니라 (`\n`이나 `\r`로 구분되는) 각각의 줄의 처음과 끝도 일치합니다.

`s` ("dotAll")

`.`이 줄 바꿈에도 일치합니다.

`u` (unicode)

`pattern`을 Unicode 코드 포인트 시퀀스로 처리합니다. (이진 문자열 참고)

`y` (sticky, 접착)

이 정규 표현식의 `lastIndex` 속성에 명시된 인덱스에서만 판별하고, 이전/이후 인덱스에서 판별을 시도하지 않습니다.


예제
--

### 리터럴 표기법과 생성자

`RegExp` 객체는 리터럴 표기법과 생성자로써 생성할 수 있습니다.

* **리터럴 표기법**의 매개변수는 두 빗금으로 감싸야 하며 따옴표를 사용하지 않습니다.
* **생성자 함수**의 매개변수는 빗금으로 감싸지 않으나 따옴표를 사용합니다.

다음의 세 표현식은 모두 같은 정규 표현식을 생성합니다.


```js
/ab+c/i;
new RegExp(/ab+c/, "i"); // 리터럴
new RegExp("ab+c", "i"); // 생성자
```


리터럴 표기법은 표현식을 평가할 때 정규 표현식을 컴파일합니다. 정규 표현식이 변하지 않으면 리터럴 표기법을 사용하세요. 예를 들어, 반복문 안에서 사용할 정규 표현식을 리터럴 표기법으로 생성하면 정규 표현식을 매번 다시 컴파일하지 않습니다.

정규 표현식 객체의 생성자(`new RegExp('ab+c')`)를 사용하면 정규 표현식이 런타임에 컴파일됩니다. 패턴이 변할 가능성이 있거나, 사용자 입력과 같이 알 수 없는 외부 소스에서 가져오는 정규 표현식의 경우 생성자 함수를 사용하세요.

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp-constructor |

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

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

같이 보기
-----

* JavaScript 안내서의 정규 표현식 장
* `String.prototype.match()`
* `String.prototype.replace()` (en-US)
RegExp.prototype.ignoreCase
===========================

**`ignoreCase`** 접근자 속성은 `i` 플래그가 정규 표현식에 사용되었는지 여부를 가리킵니다.

시도해보기
-----

설명
--

`RegExp.prototype.ignoreCase`는 `i` 플래그가 사용되었으먼 `true`값을 가집니다. 그렇지 않으면 `false` 값을 가집니다. `i` 플래그는 문자열 매칭에서 대소문자를 구분하지 않음을 가리킵니다.

정규식에 `unicode` (en-US) 플래그가 있는 경우 대/소문자 케이스 매핑은 `CaseFolding.txt`에 명시된 대로 수행됩니다. 그렇지 않으면 대/소문자 매핑은 Unicode Default Case Conversion을 사용합니다. 이 알고리즘은 `String.prototype.toUpperCase()` 및 `String.prototype.toLowerCase()`에서 사용되는 알고리즘과 동일합니다.

`ignoreCase`의 set 접근자는 `undefined`, 즉 정의되지 않았습니다. 이 속성을 직접 변경할 수 없습니다.

예제
--

### ignoreCase 사용하기


```js
const regex = /foo/i;

console.log(regex.ignoreCase); // true
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.ignorecase |

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

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

같이 보기
-----

* `RegExp.prototype.lastIndex` (en-US)
* `RegExp.prototype.dotAll`
* `RegExp.prototype.global`
* `RegExp.prototype.hasIndices` (en-US)
* `RegExp.prototype.multiline`
* `RegExp.prototype.source` (en-US)
* `RegExp.prototype.sticky` (en-US)
* `RegExp.prototype.unicode` (en-US)
RegExp.prototype.test()
=======================

**`test()`** 메서드는 주어진 문자열이 정규 표현식을 만족하는지 판별하고, 그 여부를 `true` 또는 `false`로 반환합니다.

시도해보기
-----

구문
--


```js
regexObj.test(str);
```

### 매개변수

`str`

정규 표현식 일치를 수행할 문자열.

### 반환 값

주어진 문자열 `str` 중 정규 표현식이 일치하는 부분이 있으면 `true`, 아니면, `false`.

설명
--

패턴이 문자열 내에 존재하는지에 대한 여부를 알아보고자 할 때 `test()`를 사용하세요. 일치의 위치 인덱스, 또는 일치하지 않으면 `-1`을 반환하는 `String.prototype.search()` (en-US)와 달리 `test()`는 불리언을 반환합니다.

더 느리지만 더 많은 정보가 필요하면 `exec()` (en-US) 메서드를 사용하세요. (`String.prototype.match()` 메서드와 비슷합니다.)

`exec()`처럼, `test()`도 전역 탐색 플래그를 제공한 정규 표현식에서 여러 번 호출하면 이전 일치 이후부터 탐색합니다. `exec()`와 `test()`를 혼용해 사용하는 경우에도 해당됩니다.

예제
--

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

문자열의 맨 처음에 `"hello"`가 포함됐는지 알아보는 간단한 예제 코드입니다.


```js
const str = "hello world!";
const result = /^hello/.test(str);

console.log(result); // true
```


다음은 일치 여부에 따라 다른 메시지를 기록하는 예제입니다.


```js
function testInput(re, str) {
  let midstring;
  if (re.test(str)) {
    midstring = "contains";
  } else {
    midstring = "does not contain";
  }
  console.log(`${str} ${midstring} ${re.source}`);
}
```

### 전역 플래그와 `test()`

정규 표현식에 전역 플래그를 설정한 경우, `test()` 메서드는 정규 표현식의 `lastIndex` (en-US)를 업데이트합니다. (`RegExp.prototype.exec()` (en-US)도 `lastIndex` 속성을 업데이트합니다.)

`test(str)`을 또 호출하면 `str` 검색을 `lastIndex`부터 계속 진행합니다. `lastIndex` 속성은 매 번 `test()`가 `true`를 반환할 때마다 증가하게 됩니다.

**참고:** `test()`가 `true`를 반환하기만 하면 `lastIndex`는 초기화되지 않습니다. 심지어 이전과 다른 문자열을 매개변수로 제공해도 그렇습니다!

`test()`가 `false`를 반환할 땐 `lastIndex` 속성이 `0`으로 초기화됩니다.

이 행동에 대한 예제가 다음 코드입니다.


```js
const regex = /foo/g; // the "global" flag is set

// regex.lastIndex is at 0
regex.test("foo"); // true

// regex.lastIndex is now at 3
regex.test("foo"); // false

// regex.lastIndex is at 0
regex.test("barfoo"); // true

// regex.lastIndex is at 6
regex.test("foobar"); //false

// regex.lastIndex is at 0
// (...and so on)
```

명세
--

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.test |

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

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

같이 보기
-----

* JavaScript 안내서의 정규 표현식 장
* `RegExp`
* `RegExp.prototype` (en-US)
RegExp.prototype.multiline
==========================

**`multiline`** 접근자 속성은 `m` 플래그가 정규표현식에 사용되었는지 여부를 나타냅니다.

시도해보기
-----

설명
--

`m` 플래그가 사용된 경우 `RegExp.prototype.multiline`은 `true` 값을 가지며,
 그렇지 않으면 `false` 값을 갖습니다. `m` 플래그는 여러 줄 입력 문자열을 여러 줄로 처리해야 함을 나타냅니다.
 예를 들어, `m`이 사용되면 `^`와 `$`는 전체 문자열의 시작 또는 끝에서만 일치하는 것에서
 문자열 내의 모든 줄의 시작 또는 끝에서 일치하는 것으로 변경됩니다.

`multiline`의 set 접근자는 `undefined`, 즉 정의되지 않았습니다. 이 속성은 직접 변경할 수 없습니다.

예제
--

### multiline 사용하기


```js
const regex = /foo/m;

console.log(regex.multiline); // true
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.multiline |

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

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

같이 보기
-----

* `RegExp.prototype.lastIndex` (en-US)
* `RegExp.prototype.dotAll`
* `RegExp.prototype.global`
* `RegExp.prototype.hasIndices` (en-US)
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.source` (en-US)
* `RegExp.prototype.sticky` (en-US)
* `RegExp.prototype.unicode` (en-US)
RegExp.prototype.flags
======================

**`flags`** 접근자 속성은 현재 정규식 객체의 플래그를 나타냅니다.

시도해보기
-----

설명
--

`RegExp.prototype.flags`는 문자열입니다. `flags` 속성의 플래그는 왼쪽에서 오른쪽으로 알파벳 순으로 정렬됩니다(예를 들어 `"dgimsuy"`). 실제로 다른 플래그 접근자(`hasIndices` (en-US), `global`, 등등)를 하나씩 호출하고 결과를 연결합니다.

내장된 모든 함수는 개별 플래그 접근자를 읽는 대신 `flags` 속성을 읽습니다.

`flags`의 set 접근자는 정의되지 않았습니다. 이 속성을 직접 변경할 수 없습니다.

예제
--

### flags 사용하기


```js
/foo/ig.flags; // "gi"
/bar/myu.flags; // "muy"
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.flags |

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

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

같이 보기
-----

* Polyfill of `RegExp.prototype.flags` in `core-js`
* `RegExp.prototype.source` (en-US)
Object.values()
===============

**`Object.values()`** 메소드는 전달된 파라미터 객체가 가지는 (열거 가능한) 속성의 값들로 이루어진 배열을 리턴합니다. 이 배열은 `for...in` 구문과 동일한 순서를 가집니다. (for in 반복문은 프로토타입 체인 또한 열거한다는 점에서 차이가 있습니다.)

시도해보기
-----

Syntax
------


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

### Parameters

`obj`

배열로 변환할 열거 가능한 속성을 가지는 객체

### Return value

전달된 객체의 속성 값들을 포함하는 배열

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

`Object.values()` 는 파라미터로 전달된 객체가 가지는 열거 가능한 속성의 값들로 구성된 배열을 반환합니다. 배열의 값들이 순서는 오브젝트의 속성을 for in 구문등으로 반복한 결과와 동일합니다. (참고로 for in 구문은 순서를 보장하지 않습니다)

Examples
--------


```js
var obj = { foo: "bar", baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]

// 유사 배열 (숫자를 속성으로 사용하는 객체)
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(obj)); // ['a', 'b', 'c']

// 유사 배열의 경의 속성으로 사용한 숫자의 크기 순으로 정렬되어 반환됩니다.
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']

// getFoo는 열거 가능한 속성이 아니라서 배열에 포함되지 않습니다.
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = "bar";
console.log(Object.values(my_obj)); // ['bar']

// 객체가 아닌 경우에는 객체로 강제로 변환되어 적용됩니다.
console.log(Object.values("foo")); // ['f', 'o', 'o']
```

Polyfill
--------

`Object.values` 메소드는 구형 브라우저에서 지원하지 않습니다. 구형 브라우저와의 호환성을 고려하기 위해 폴리필을 찾아 볼 수 있습니다. tc39/proposal-object-values-entries 혹은 es-shims/Object.values 를 참조해보세요.

명세서
---

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

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

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

See also
--------

* Enumerability and ownership of properties (en-US)
* `Object.keys()`
* `Object.entries()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
Object.getOwnPropertySymbols()
==============================

**`Object.getOwnPropertySymbols()`** 메서드는 주어진 객체에서 직접 찾은 모든 심볼 속성들의 배열을 반환합니다.

시도해보기
-----

구문
--


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

### 매개변수

`obj`

반환받고자 하는 심볼 속성들이 있는 객체

### 반환 값

주어진 객체에서 직접 찾은 모든 심볼 속성들의 배열

설명
--

`Object.getOwnPropertyNames()`와 유사하게, 주어진 객체의 모든 심볼 속성을 배열로 가져올 수 있습니다. 참고로 `Object.getOwnPropertyNames()` 자체에는 객체의 심볼 속성이 포함되어 있지 않고 오직 문자열 속성만 포함되어 있습니다.

모든 객체에는 처음에는 고유한 심볼 속성이 없으므로, `Object.getOwnPropertySymbols()`는 객체에 심볼 속성을 설정하지 않는 한 빈 배열을 반환합니다.

예제
--

### getOwnPropertySymbols 사용하기


```js
var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // 2
console.log(objectSymbols); // [Symbol(a), Symbol(b)]
console.log(objectSymbols[0]); // Symbol(a)
```

명세서
---

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

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

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

같이 보기
-----

* `Object.getOwnPropertySymbols`의 폴리필은 `core-js`에서 사용할 수 있습니다.
* `Object.getOwnPropertyNames()`
* `Symbol`
Object.preventExtensions()
==========================

**`Object.preventExtensions()`** 메서드는 새로운 속성이 이제까지 객체에 추가되는 것을 방지합니다 (즉 객체의 장래 확장을 막습니다).

시도해보기
-----

구문
--


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

### 매개변수

`obj`

확장 불가로 해야 할 객체.

설명
--

객체는 새로운 속성이 추가될 수 있는 경우 확장 가능입니다. `Object.preventExtensions()`는 객체를 이제 확장 불가로 표시하므로 표시된 그 시점에 있던 것 이외의 속성을 갖지 않습니다. 보통 확장 불가인 객체의 속성은 여전히 *삭제될* 수 있음을 주의하세요. 확장 불가인 객체에 새로운 속성을 추가하려는 시도는 실패합니다, 조용히든 `TypeError`가 발생해서든 (가장 흔하나 오로지 엄격 모드 (en-US)인 경우에서만은 아님).

`Object.preventExtensions()`는 자신의 속성 추가만을 방지합니다. 속성은 여전히 객체의 프로토타입에 추가될 수 있습니다. 그러나, 객체에 `Object.preventExtensions()`를 호출하면 그 `Object.prototype.__proto__` 
지원이 중단되었습니다
 속성의 확장 또한 막습니다.

ECMAScript 5에서 확장 가능 객체를 확장 불가로 바꾸는 법이 있더라도, 반대로 하는 법은 없습니다.

예제
--


```js
// Object.preventExtensions는 확장 불가된 객체를 반환합니다.
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2; // true

// 객체는 기본으로 확장 가능입니다.
var empty = {};
Object.isExtensible(empty); // === true

// ...하지만 바뀔 수 있습니다.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// Object.defineProperty는 확장 불가 객체에 새 속성을 추가할 때 오류가 발생합니다.
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", { value: 8675309 }); // TypeError 발생

// 엄격 모드에서, 확장 불가 객체에 새 속성을 추가하려는 시도는 TypeError가 발생합니다.
function fail() {
  "use strict";
  nonExtensible.newProperty = "FAIL"; // TypeError 발생
}
fail();

// 확장 (\_\_proto\_\_(는 사라집니다. 대신 Object.getPrototypeOf를 쓰세요)를
// 지원하는 엔진에서만 동작합니다):
// 확장 불가 객체의 프로토타입은 불변합니다.
var fixed = Object.preventExtensions({});
fixed.__proto__ = { oh: "hai" }; // TypeError 발생
```

참고
--

ES5에서, 이 메서드의 인수가 비객체(원시형)인 경우, 그러면 `TypeError`가 발생합니다. ES6에서, 비객체 인수는 마치 확장 불가인 보통 객체였던 것처럼 취급됩니다, 그저 자신을 반환하는.


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

Object.preventExtensions(1);
// 1 (ES6 코드)
```

명세
--

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

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

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

같이 보기
-----

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

**`Object.is()`** 정적 메서드는 두 값이 같은 값인지 결정합니다.

시도해보기
-----

구문
--


```js
Object.is(value1, value2);
```

### 매개변수

`value1`

비교할 첫 번째 값.

`value2`

비교할 두 번째 값.

### 반환 값

두 인수가 같은 값인지 여부를 나타내는 불리언.

설명
--

`Object.is()`는 두 값이 같은 값인지 결정합니다. 다음 중 하나를 만족하면 두 값은 같습니다.

* 둘 다 `undefined`
* 둘 다 `null`
* 둘 다 `true` 또는 둘 다 `false`
* 둘 다 같은 순서로 같은 문자에 같은 길이인 문자열
* 둘 다 같은 객체 (두 값 모두 메모리에서 같은 객체를 참조하는 것을 의미)
* 둘 다 숫자이며
    + 둘 다 `+0`
    + 둘 다 `-0`
    + 둘 다 `NaN`
    + 둘 다 0이나 `NaN`이 아니고, 같은 값을 지님

`Object.is()`는 `==` 연산자와 같지 않습니다. `==` 연산자는 같음을 테스트하기 전에 양 쪽(이 같은 형이 아니라면)에 다양한 강제(coercion)를 적용하지만(`"" == false`가 `true`가 되는 것과 같은 행동을 초래), `Object.is`는 어느 값도 강제하지 않습니다.

`Object.is()`는 `===` (en-US) 연산자와도 같지 않습니다. `Object.is()`와 `===`의 유일한 차이는 부호 있는 0과 `NaN` 값들의 처리입니다. `===` 연산자(및 `==` 연산자)는 숫자값 `-0`과 `+0`을 같게 처리하지만, `NaN`은 서로 같지 않게 처리합니다.

예제
--

### Object.is() 사용


```js
// Case 1: 평가 결과는 ===을 사용한 것과 동일합니다
Object.is(25, 25); // true
Object.is("foo", "foo"); // true
Object.is("foo", "bar"); // false
Object.is(null, null); // true
Object.is(undefined, undefined); // true
Object.is(window, window); // true
Object.is([], []); // false
const foo = { a: 1 };
const bar = { a: 1 };
const sameFoo = foo;
Object.is(foo, foo); // true
Object.is(foo, bar); // false
Object.is(foo, sameFoo); // true

// Case 2: 부호 있는 0
Object.is(0, -0); // false
Object.is(+0, -0); // false
Object.is(-0, -0); // true

// Case 3: NaN
Object.is(NaN, 0 / 0); // true
Object.is(NaN, Number.NaN); // true
```

명세
--

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

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

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

같이 보기
-----

* `core-js`의 `Object.is` 폴리필
* 동치 비교 및 동일성 — 동일성 내장 기능 3가지 모두 비교
Object.getOwnPropertyDescriptors()
==================================

**`Object.getOwnPropertyDescriptors()`** 메서드는 주어진 객체의 모든 속성들의 설명자(descriptor)들을 반환합니다.

시도해보기
-----

구문
--


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

### 매개변수

`obj`

가지고 있는 모든 속성들의 설명자를 반환받고 싶은 객체

### 반환 값

객체의 모든 속성의 설명자를 가지는 객체를 반환합니다. 매개변수 객체에 속성이 없다면, 빈 객체가 반환됩니다.

설명
--

 이 메서드를 사용하면, 객체의 모든 속성들에 대한 설명자를 정확하게 확인할 수 있습니다.
 JavaScript의 *속성*은 문자열로된 이름 또는 심볼, 그리고 속성 설명자로 이루어져 있습니다.
 속성 설명자 종류와 특성에 대한 자세한 정보는 `Object.defineProperty()`에 있습니다..

*속성 설명자* 는 다음과 같은 특징들을 가진 레코드입니다.

`value`

속성과 관련된 값입니다. (데이터 설명자만 해당됨)

`writable`

`참(true)`인 경우, 속성과 관련된 값이 변경될 수 있는 상태입니다. (데이터 설명자만 해당됨)

`get`

 속성에 대한 getter 역할을 하는 함수거나, getter가 정의되지 않은 경우에는 `undefined` 입니다.
 (접근자 설명자만 해당됨)


`set`

 속성에 대한 setter 역할을 하는 함수거나, setter 정의되지 않은 경우에는 `undefined` 입니다.
 (접근자 설명자만 해당됨)


`configurable`

`참(true)`인 경우, 객체로 부터 속성 설명자가 변경 및 삭제될 수 있는 상태입니다.

`enumerable`

`true`인 경우, 열거 가능한 상태의 속성입니다.

예시
--

### 얕은 복사하기

`Object.assign()` 메서드는 원본 객체에서 목표 객체로 열거 가능한 속성과 객체의 속성들만 복사하는 반면,
 이 메서드와 `Object.create()` 를 사용하면 어느 두 객체를 얕은 복사에 사용할 수 있습니다.


```js
Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj),
);
```

### 서브클래스 만들기

 서브클래스를 만드는 일반적인 방법은 서브클래스를 정의하고, 프로토타입을 슈퍼 클래스의 인스턴스로 설정한 다음, 그 인스턴스에 속성을 정의하는 것입니다.
 이 방법은 게터와 세터의 경우 굉장히 불편합니다. 대신, 다음 코드를 사용하여 프로토타입을 설정할 수 있습니다.


```js
function superclass() {}
superclass.prototype = {
  // 여기에 슈퍼 클래스의 생성자, 매서드, 속성을 정의합니다.
};
function subclass() {}
subclass.prototype = Object.create(superclass.prototype, {
  // 여기에 서브클래스의 생성자, 매서드, 속성을 정의합니다.
});
```

명세
--

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

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

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

같이 보기
-----

* `Object.getOwnPropertyDescriptors`의 폴리필은 다음에서 확인 할 수 있습니다. `core-js`
* `Object.getOwnPropertyDescriptor()`
* `Object.defineProperty()`
* Polyfill
Object.keys()
=============

**`Object.keys()`** 메서드는 주어진 객체의 속성 이름들을 일반적인 반복문과
 동일한 순서로 순회되는 열거할 수 있는 배열로 반환합니다.

시도해보기
-----

구문
--


```js
Object.keys(obj)
```

### 매개변수

`obj`

객체

### 반환 값

주어진 객체 자체의 열거 가능한 문자열로된 속성 키를 나타내는 문자열 배열.

설명
--

`Object.keys()`는 `object` 에서 직접 찾은 열거 가능한 문자열 키 속성 이름에 해당하는 문자열을 요소로 하는
 배열을 반환합니다. 이는 `for...in` 루프가 프로토타입 체인의 속성도 열거한다는 점을 제외하면
 `for...in` 루프를 사용하여 반복하는 것과 동일합니다.
 `Object.keys()`가 반환하는 배열의 순서는 `for...in`
 루프에서 제공하는 것과 동일합니다.

 속성 값이 필요한 경우 `Object.values()`를 대신 사용하시기 바랍니다.
 속성 키와 값이 모두 필요한 경우 `Object.entries()`를 대신 사용하시기 바랍니다.

예제
--

### Object.keys() 사용하기


```js
// 단순 배열
const arr = ["a", "b", "c"];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

// 배열형 객체
const obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.keys(obj)); // console: ['0', '1', '2']

// 키와 순서가 무작위인 유사 배열 객체
const anObj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.keys(anObj)); // console: ['2', '7', '100']

// getFoo 는 열거할 수 없는 속성입니다.
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
    },
  },
);
myObj.foo = 1;
console.log(Object.keys(myObj)); // ['foo']
```


 만약 열거할 수 없는 속성도 포함한 문자열이 키인 객체 자체 속성을 원한다면,
 `Object.getOwnPropertyNames()`을 참고하시기 바랍니다.

### 원시형애서 Object.keys() 사용하기

 객체가 아닌 인수는 강제로 객체로 변환됩니다.
 문자열만 자체 열거 가능한 속성을 가질 수 있으며, 다른 모든 원시형은 빈 배열을 반환합니다.


```js
// 문자열은 열거가능한 자체 속성처럼 인덱스를 가지고 있습니다.
console.log(Object.keys("foo")); // ['0', '1', '2']

// 다른 원시형은 자체 속성이 없숩니다.
console.log(Object.keys(100)); // []
```


**참고:** ES5에서는 비객체를 `Object.keys()`에 전달하면 `TypeError`가 발생합니다.

명세서
---

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

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

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

같이 보기
-----

* `Object.keys` 의 폴리필 코드는 아래에서 확인할 수 있습니다. `core-js`
* Enumerability and ownership of properties (en-US)
* `Object.entries()`
* `Object.values()`
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
* `Map.prototype.keys()`