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

**`propertyIsEnumerable()`** 메서드는 특정 속성이 열거가능한지 여부를 나타내는 불리언 값을 반환합니다.

시도해보기
-----

구문
--


```js
obj.propertyIsEnumerable(prop);
```

### 매개변수

`prop`

테스트 할 속성의 이름.

### 반환 값

특정 속성이 열거가능한지 여부를 나타내는 `Boolean`.

설명
--

모든 객체는 `propertyIsEnumerable` 메소드를 가지고 있습니다. 이 메소드는 프로토타입 체인을 통해 상속된 특성을 제외하고 개체에 지정된 속성을 `for...in` 루프로 열거할 수 있는지 여부를 확인할 수 있습니다. 개체에 지정된 속성이 없으면 이 메소드는 `false`를 반환합니다.

예제
--

### A basic use of `propertyIsEnumerable`

The following example shows the use of `propertyIsEnumerable` on objects and arrays:


```js
var o = {};
var a = [];
o.prop = "is enumerable";
a[0] = "is enumerable";

o.propertyIsEnumerable("prop"); // returns true
a.propertyIsEnumerable(0); // returns true
```

### User-defined versus built-in objects

The following example demonstrates the enumerability of user-defined versus built-in properties:


```js
var a = ["is enumerable"];

a.propertyIsEnumerable(0); // returns true
a.propertyIsEnumerable("length"); // returns false

Math.propertyIsEnumerable("random"); // returns false
this.propertyIsEnumerable("Math"); // returns false
```

### Direct versus inherited properties


```js
var a = [];
a.propertyIsEnumerable("constructor"); // returns false

function firstConstructor() {
  this.property = "is not enumerable";
}

firstConstructor.prototype.firstMethod = function () {};

function secondConstructor() {
  this.method = function method() {
    return "is enumerable";
  };
}

secondConstructor.prototype = new firstConstructor();
secondConstructor.prototype.constructor = secondConstructor;

var o = new secondConstructor();
o.arbitraryProperty = "is enumerable";

o.propertyIsEnumerable("arbitraryProperty"); // returns true
o.propertyIsEnumerable("method"); // returns true
o.propertyIsEnumerable("property"); // returns false

o.property = "is enumerable";

o.propertyIsEnumerable("property"); // returns true

// These return false as they are on the prototype which
// propertyIsEnumerable does not consider (even though the last two
// are iteratable with for-in)
o.propertyIsEnumerable("prototype"); // returns false (as of JS 1.8.1/FF3.6)
o.propertyIsEnumerable("constructor"); // returns false
o.propertyIsEnumerable("firstMethod"); // returns false
```

명세
--

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

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

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

같이 보기
-----

* Enumerability and ownership of properties (en-US)
* `for...in`
* `Object.keys()`
* `Object.defineProperty()`
Object.getPrototypeOf()
=======================

**`Object.getPrototypeOf()`** 메서드는 지정된 객체의 프로토타입(가령 내부 `[[Prototype]]` 속성값)을 반환합니다.

구문
--


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

### 매개변수

`obj`

자신의 프로토타입이 반환되는 객체.

예
-


```js
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
```

주의
--

ES5에서, `obj` 매개변수가 객체가 아닌 경우 `TypeError` 예외가 발생합니다. ES6에서, 매개변수는 `Object`로 강제됩니다.


```js
Object.getPrototypeOf("foo");
// TypeError: "foo"는 객체가 아닙니다 (ES5 코드)
Object.getPrototypeOf("foo");
// String.prototype (ES6 코드)
```

명세
--

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

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

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

Opera 전용 주의사항
-------------

이전 Opera 버전이 `Object.getPrototypeOf()`를 아직 지원하지 않지만, Opera는 Opera 10.50 이후로 비표준 `Object.prototype.__proto__` 속성을 지원합니다.

참조
--

* `Object.prototype.isPrototypeOf()`
* `Object.setPrototypeOf()` (en-US)
* `Object.prototype.__proto__`
* John Resig의 getPrototypeOf 포스트
* `Reflect.getPrototypeOf()`
Object.getOwnPropertyDescriptor()
=================================

**`Object.getOwnPropertyDescriptor()`** 메서드는 주어진 객체 *자신의 속성*(즉, 객체에 직접 제공하는 속성, 객체의 프로토타입 체인을 따라 존재하는 덕택에 제공하는 게 아닌)에 대한 속성 설명자(descriptor)를 반환합니다.

구문
--


```js
Object.getOwnPropertyDescriptor(obj, prop);
```

### 매개변수

`obj`

속성을 찾을 대상 객체.

`prop`

설명이 검색될 속성명.

### 반환값

객체에 존재하는 경우 주어진 속성의 속성 설명자, 없으면 `undefined`.

설명
--

이 메서드는 정확한 속성 설명의 검사를 허용합니다. JavaScript에서 *속성*은 문자열 값인 이름과 속성 설명자로 구성됩니다. 속성 설명자 유형과 attribute에 관한 자세한 정보는 `Object.defineProperty()`에서 찾을 수 있습니다.

*속성 설명자*는 다음 attribute 중 일부의 기록입니다:

`value`

속성과 관련된 값 (데이터 설명자만).

**`writable`**

속성과 관련된 값이 변경될 수 있는 경우에만 `true` (데이터 설명자만).

`get`

속성에 대해 getter로서 제공하는 함수 또는 getter가 없는 경우 `undefined` (접근자 설명자만).

`set`

속성에 대해 setter로서 제공하는 함수 또는 setter가 없는 경우 `undefined` (접근자 설명자만).

`configurable`

이 속성 설명자의 유형이 바뀔 수 있는 경우에만 그리고 속성이 해당 객체에서 삭제될 수 있는 경우 `true`.

`enumerable`

이 속성이 해당 객체의 속성 열거 중에 나타나는 경우에만 `true`.

예
-


```js
var o, d;

o = {
  get foo() {
    return 17;
  },
};
d = Object.getOwnPropertyDescriptor(o, "foo");
// d는 { configurable: true, enumerable: true, get: /\* getter 함수 \*/, set: undefined }

o = { bar: 42 };
d = Object.getOwnPropertyDescriptor(o, "bar");
// d는 { configurable: true, enumerable: true, value: 42, writable: true }

o = {};
Object.defineProperty(o, "baz", {
  value: 8675309,
  writable: false,
  enumerable: false,
});
d = Object.getOwnPropertyDescriptor(o, "baz");
// d는 { value: 8675309, writable: false, enumerable: false, configurable: false }
```

주의
--

ES5에서, 이 메서드의 첫 번째 인수가 비객체(원시형)인 경우, 그러면 `TypeError`가 발생합니다. ES6에서, 비객체 첫 번째 인수는 먼저 객체로 강제됩니다.


```js
Object.getOwnPropertyDescriptor("foo", 0);
// TypeError: "foo"는 객체가 아닙니다 // ES5 코드

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

명세서
---

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

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

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

참조
--

* `Object.defineProperty()`
* `Reflect.getOwnPropertyDescriptor()`
Object.seal()
=============

**`Object.seal()`** 메서드는 객체를 밀봉합니다. 객체를 밀봉하면 그 객체에는 새로운 속성을 추가할 수 없고, 현재 존재하는 모든 속성을 설정 불가능 상태로 만들어줍니다. 하지만 쓰기 가능한 속성의 값은 밀봉 후에도 변경할 수 있습니다(역자 주 : 바로 이 점이 `Object.freeze()`와의 차이라고 할 수 있습니다).

시도해보기
-----

구문
--


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

### 매개변수

`obj`

봉인할 객체.

### 반환 값

봉인한 객체.

설명
--

객체는 기본적으로 확장이 가능(extensible)합니다. 즉, 새로운 속성을 추가할 수 있습니다. 하지만 객체를 밀봉하면 그 객체에 새로운 속성을 추가할 수 없게되고, 그 객체 내에 존재하는 모든 속성이 설정 불가능(non-configurable)해 집니다. 객체를 밀봉하면 객체의 속성을 고정된 불변의 상태로 만듭니다. 모든 속성을 설정 불가능한 상태로 만드는 것은 데이터 속성(data properties)을 접근자 속성(accessor properties)으로, 또는 접근자 속성을 데이터 속성으로 변경할 수 없게 만듭니다. 하지만 객체를 완전히 얼려서 데이터 속성의 값도 변경할 수 없게 만드는 `Object.freeze()`와 달리, `Object.seal()`은 객체를 밀봉한 후에도 그 객체의 데이터 속성의 값은 여전히 변경할 수 있게 해줍니다. 다만, 밀봉한 후에는 객체를 얼리는 것과 마찬가지로 속성의 추가/삭제나 데이터 속성과 접근자 속성 사이의 전환은 암묵적이든, 아니면 strict mode 에서와 같이 명시적으로 `TypeError` 예외를 발생시키든 모두 실패로 끝납니다.

프로토타입 체인은 밀봉 전이나 후나 달라지지 않습니다. 하지만 `Object.prototype.__proto__` 
지원이 중단되었습니다
 속성은 함께 밀봉됩니다.

예제
--


```js
var obj = {
  prop: function () {},
  foo: "bar",
};

// 새 속성이 추가되고, 기존 속성은 변경되거나 제거될 수 있음
obj.foo = "baz";
obj.lumpy = "woof";
delete obj.prop;

var o = Object.seal(obj);

assert(o === obj);
assert(Object.isSealed(obj) === true);

// 밀봉한 객체의 속성값은 밀봉 전과 마찬가지로 변경할 수 있음
obj.foo = "quux";
obj.foo; // 'quux' 가 출력됨

// 데이터 속성과 접근자 속성 사이의 전환은 불가
Object.defineProperty(obj, "foo", {
  get: function () {
    return "g";
  },
}); // TypeError 발생

// 속성값의 변경을 제외한 어떤 변경도 적용되지 않음
obj.quaxxor = "the friendly duck"; // 에러가 나지는 않지만 속성은 추가되지 않음
delete obj.foo; // 에러가 나지는 않지만 속성이 삭제되지 않음

// strict mode 에서는 속성값의 변경을 제외한 모든 변경은 TypeError 발생
function fail() {
  "use strict";
  delete obj.foo; // TypeError 발생
  obj.sparky = "arf"; // TypeEror 발생
}
fail();

// Object.defineProperty() 메서드를 이용한 속성의 추가도 TypeError 발생
Object.defineProperty(obj, "ohai", { value: 17 }); // TypeErorr 발생
Object.defineProperty(obj, "foo", { value: "eit" }); // 속성값의 변경은 가능함
```

참고
--

ES5에서는 **`Object.seal()`** 메서드의 인자가 객체가 아닐 때(즉, 원시형일 때)는 `TypeError`가 발생합니다. ES6에서는 원시형 인자도 밀봉된 객체라고 취급해서 `TypeError`를 발생시키지 않고 원시형 인자를 그대로 반환합니다.


```js
> Object.seal(1)
TypeError: 1 is not an object // ES5 code

> Object.seal(1)
1                             // ES6 code
```

명세
--

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

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

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

같이 보기
-----

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

**`Object.isSealed()`** 메서드는 객체가 봉인됐는지 판별합니다.

시도해보기
-----

구문
--


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

### 매개변수

`obj`

판별할 객체.

### 반환 값

객체의 봉인 여부를 나타내는 `Boolean`.

설명
--

객체가 봉인된 경우 `true`를 반환하고, 그렇지 않으면 `false`. 객체는 확장 불가이고 모든 속성이 설정 불가이며 따라서 삭제할 수 없(지만 반드시 쓰기 불가일 필요는 없)는 경우 봉인됩니다.

예제
--


```js
// 객체는 기본으로 봉인되지 않습니다.
var empty = {};
Object.isSealed(empty); // === false

// 빈 객체를 확장 불가하게 한 경우, 빈 채로 봉인됩니다.
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// 비어 있지 않은 객체는 다릅니다, 그 속성이 모두 설정 불가가 아닌 한.
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// 그러나 모두 설정 불가하게 하면 객체는 봉인됩니다.
Object.defineProperty(hasProp, "fee", { configurable: false });
Object.isSealed(hasProp); // === true

// 객체를 봉인하는 가장 쉬운 방법은 물론 Object.seal 입니다.
var sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // === true

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

// 봉인된 객체는 동결될 수 있지만 꼭 그럴 필요는 없습니다.
Object.isFrozen(sealed); // === true (모든 속성도 쓰기 불가)

var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // === false ('p'는 여전히 쓰기 가능)

var s3 = Object.seal({
  get p() {
    return 0;
  },
});
Object.isFrozen(s3); // === true (설정 가능성만이 접근자 속성에게 중요함)
```

주의
--

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


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

Object.isSealed(1);
// true (ES6 코드)
```

명세
--

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

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

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

같이 보기
-----

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

\*\*`Object.isFrozen()`\*\*은 객체가 동결됐는지 판별합니다.

시도해보기
-----

구문
--


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

### 매개변수

`obj`

판별할 객체.

### 반환 값

객체의 동결 여부를 나타내는 `Boolean`.

설명
--

객체는 확장 불가이며 모든 속성이 설정 불가 및 모든 데이터 속성(즉, getter 또는 setter 요소가 있는 접근자 속성이 아닌 속성)이 쓰기 불가인 경우에만 동결됩니다.

예제
--


```js
// 새로운 객체는 확장 가능해서 동결되지 않습니다.
Object.isFrozen({}); // === false

// 확장 불가인 빈 객체는 빈 채로 동결됩니다.
var vacuouslyFrozen = Object.preventExtensions({});
Object.isFrozen(vacuouslyFrozen); // === true

// 속성이 하나 있는 새 객체도 확장 가능하므로 동결되지 않습니다.
var oneProp = { p: 42 };
Object.isFrozen(oneProp); // === false

// 객체 확장을 막아도 여전히 동결되지 않습니다,
// 속성이 여전히 설정 가능(및 쓰기 가능)하기에.
Object.preventExtensions(oneProp);
Object.isFrozen(oneProp); // === false

// ...그렇지만 그 속성 삭제는 객체를 빈 채로 동결되게 합니다.
delete oneProp.p;
Object.isFrozen(oneProp); // === true

// 쓰기 불가지만 여전히 설정 가능한 속성이 있는 확장 불가 객체는 동결되지 않습니다.
var nonWritable = { e: "plep" };
Object.preventExtensions(nonWritable);
Object.defineProperty(nonWritable, "e", { writable: false }); // 쓰기 불가로 함
Object.isFrozen(nonWritable); // === false

// 그 속성을 설정 불가로 바꾸면 객체를 동결되게 합니다.
Object.defineProperty(nonWritable, "e", { configurable: false }); // 설정 불가로 함
Object.isFrozen(nonWritable); // === true

// 설정 불가지만 여전히 쓰기 가능 속성이 있는 확장 불가 객체도 동결되지 않습니다.
var nonConfigurable = { release: "the kraken!" };
Object.preventExtensions(nonConfigurable);
Object.defineProperty(nonConfigurable, "release", { configurable: false });
Object.isFrozen(nonConfigurable); // === false

// 그 속성을 쓰기 불가로 바꾸면 객체를 동결되게 합니다.
Object.defineProperty(nonConfigurable, "release", { writable: false });
Object.isFrozen(nonConfigurable); // === true

// 설정 가능 접근자 속성이 있는 확장 불가 객체는 동결되지 않습니다.
var accessor = {
  get food() {
    return "yum";
  },
};
Object.preventExtensions(accessor);
Object.isFrozen(accessor); // === false

// ...하지만 그 속성을 설정 불가로 하면 동결됩니다.
Object.defineProperty(accessor, "food", { configurable: false });
Object.isFrozen(accessor); // === true

// 하지만 동결되는 객체를 위한 가장 쉬운 방법은 객체에 Object.freeze가 호출된 경우입니다.
var frozen = { 1: 81 };
Object.isFrozen(frozen); // === false
Object.freeze(frozen);
Object.isFrozen(frozen); // === true

// 정의에 의해, 동결된 객체는 확장 불가입니다.
Object.isExtensible(frozen); // === false

// 또한 정의에 의해, 동결된 객체는 봉인됩니다.
Object.isSealed(frozen); // === true
```

주의
--

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


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

Object.isFrozen(1);
// true (ES6 코드)
```

명세
--

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

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

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

같이 보기
-----

* `Object.freeze()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.seal()`
* `Object.isSealed()`
Object.prototype.toLocaleString()
=================================

**`toLocaleString()`** 메서드는 객체로 된 문자열을 반환합니다. 이 메서드는 지역별로 다른 객체로 재정의되어 표시됩니다.

시도해보기
-----

구문
--


```js
obj.toLocaleString();
```

### 반환 값

객체를 나타내는 문자열.

설명
--

`Object`의 `toLocaleString`은 `toString()`을 호출 한 결과를 반환합니다.

이 함수는 모든 객체가 사용할 수는 없지만 객체에 일반 `toLocaleString` 메소드를 제공하기 위해 제공됩니다. 아래 목록을 참조하십시오.

### `toLocaleString()`을 재정의하는 객체

* `Array`: `Array.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()` (en-US)
* `Date`: `Date.prototype.toLocaleString()`
명세
--

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

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

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

같이 보기
-----

* `Object.prototype.toString()`
Object.prototype.\_\_defineGetter\_\_()
=======================================

**경고:** 이 기능은 object initializer 문법 혹은 `Object.defineProperty()` API를 사용한 getter 정의가 표준화됨으로써 비표준화되었습니다.
 이 기능은 이제까지의 ECMAScript 사양에서만 사용되고 있습니다.
 보다 좋은 방법이 있으므로, 이 메소드는 사용하지 말아야합니다.


**`__defineGetter__`** 메소드는 오브젝트의 프로퍼티와 함수를 바인드합니다.
 프로퍼티의 값이 조회될 때 바인드된 함수가 호출됩니다.

문법
--


```js
obj.\_\_defineGetter\_\_(prop, func);
```

### 인자

`prop`

함수와 바인드된 프로퍼티의 이름을 나타내는 문자열

`func`

프로퍼티 값이 조회되었을 때 호출되는 함수

### 리턴 값

`undefined`.

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

`__defineGetter__` 를 사용하여 기존 오브젝트의 getter (en-US)를 사용할 수 있습니다.

Examples
--------


```js
// Non-standard and deprecated way

var o = {};
o.\_\_defineGetter\_\_("gimmeFive", function () {
  return 5;
});
console.log(o.gimmeFive); // 5

// Standard-compliant ways

// Using the get operator
var o = {
  get gimmeFive() {
    return 5;
  },
};
console.log(o.gimmeFive); // 5

// Using Object.defineProperty
var o = {};
Object.defineProperty(o, "gimmeFive", {
  get: function () {
    return 5;
  },
});
console.log(o.gimmeFive); // 5
```

명세서
---

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineGetter\_\_ |

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

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

See also
--------

* `Object.prototype.__defineSetter__()` (en-US)
* `get` (en-US) operator
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()` (en-US)
* `Object.prototype.__lookupSetter__()` (en-US)
* JS Guide: Defining Getters and Setters
* [Blog Post] Deprecation of \_\_defineGetter\_\_ and \_\_defineSetter\_\_
* Firefox bug 647423
Object() constructor
====================

**`Object`의 생성자**는 주어진 값를 객체 래퍼로 만들어 줍니다.

* 만약 값이 `null` 또는 `undefined` 라면, 빈 객체를 생성하여 반환합니다.
* 그렇지 않으면, 주어진 값의 타입 객체를 반환합니다.
* 만약 주어진 값이 객체라면, 해당 값을 그대로 반환합니다.

비 생성자 컨텍스트로 호출되면, `Object` 는 `new Object()` 와 동일하게 동작합니다.

구문
--


```js
new Object();
new Object(value);
```

### 매개변수

`value`

아무 값

예시
--

### 새로운 객체 생성


```js
let o = new Object();
o.foo = 42;

console.log(o);
// Object { foo: 42 }
```

### undefined와 null을 받는 객체 types

다음 예제는 빈 `객체`를 `o` 변수에 저장합니다 :


```js
let o = new Object();
```



```js
let o = new Object(undefined);
```



```js
let o = new Object(null);
```

명세
--

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

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

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

같이보기
----

* 객체 초기자
Object.prototype.valueOf()
==========================

**`valueOf()`** 메서드는 특정 객체의 원시 값을 반환합니다.

시도해보기
-----

구문
--


```js
object.valueOf();
```

### 반환 값

객체의 원시 값.

**참고:** (단항) 더하기 기호 는 가끔 `valueOf` 의 단축 표현으로 사용됩니다. 예를 들면, 다음과 같은 표현을 보세요. `+new Number()`. 단항 더하기 사용하기.도 참조 하세요.

설명
--

JavaScript는 객체를 원시 값으로 변환할 때 `valueOf` 메서드를 호출합니다. 보통 원시 값을 필요로 할 때 알아서 사용하므로 직접 호출해야 하는 경우는 매우 드뭅니다.

기본적으로 `Object`의 모든 후손 객체는 `valueOf`를 상속받습니다. 내장된 핵심 객체는 모두 `valueOf`를 재정의해 적합한 값을 반환합니다. 어떤 객체가 원시 값을 가지고 있지 않다면, `valueOf`는 객체 스스로를 반환합니다.

여러분의 코드에서 `valueOf`를 호출해 내장 객체를 원시 값으로 변환할 수 있습니다. 사용자 정의 객체를 만들 땐 `valueOf`를 재정의해 `Object`의 메서드 대신 다른 행동을 부여할 수도 있습니다.

### 사용자 정의 객체의 valueOf 오버라이딩

기본 `valueOf` 메서드 대신 사용할 함수를 생성할 수 있습니다. 이 때 함수는 매개변수를 받지 않아야 합니다.

`MyNumberType`이라는 객체 형태가 존재하고, 이 객체의 `valueOf` 메서드를 만들고 싶다고 가정하겠습니다. 다음의 코드는 객체의 `valueOf` 메서드에 사용자 정의 함수를 할당합니다.


```js
MyNumberType.prototype.valueOf = function () {
  return customPrimitiveValue;
};
```


위의 코드가 활성화된 상태에서 어떤 `MyNumberType` 객체를 원시 값으로 표현해야 하면 JavaScript가 자동으로 저 함수를 실행합니다.

이 객체의 `valueOf` 메서드는 보통 JavaScript가 호출하겠지만 다음처럼 직접 호출할 수도 있습니다.


```js
myNumberType.valueOf();
```


**참고:** 문자열 문맥에서 객체-문자열 변환은 `toString()` 메서드를 사용하며, `String` 객체의 `valueOf`를 사용해 원시 문자열로 변환하는 것과는 다릅니다. 모든 객체는, 비록 결과가 "`[object type]`" 뿐이라도 문자열 변환 기능을 가지고 있습니다. 그러나 대다수의 객체는 숫자, 불리언, 함수 등으로 변환되지 않습니다.

예제
--

### 커스텀 타입에 valueOf 사용하기


```js
function MyNumberType(n) {
  this.number = n;
}

MyNumberType.prototype.valueOf = function () {
  return this.number;
};

var myObj = new MyNumberType(4);
myObj + 3; // 7
```

### 단항 더하기 사용하기


```js
+"5"; // 5 (string to number)
+""; // 0 (string to number)
+"1 + 2"; // NaN (doesn't evaluate)
+new Date(); // same as (new Date()).getTime()
+"foo"; // NaN (string to number)
+{}; // NaN
+[]; // 0 (toString() returns an empty string list)
+[1]; // 1
+[1, 2]; // NaN
+new Set([1]); // NaN
+BigInt(1); // Uncaught TypeError: Cannot convert a BigInt value to a number
+undefined; // NaN
+null; // 0
+true; // 1
+false; // 0
```

명세
--

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

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

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

함께 보기
-----

* `Object.prototype.toString()`
* `parseInt()`
* `Symbol.toPrimitive()`
Object.prototype.constructor
============================

인스턴스의 프로토타입을 만든 `Object` 함수의 참조를 반환합니다. 이 속성값은 함수 자체의 참조임을 주의하세요, 함수 이름을 포함하는 문자열이 아니라. 그 값은 `1`, `true` 및 `"test"`와 같은 원시(primitive) 값에 대해서만 읽기 전용입니다.

설명
--

모든 객체는 자신의 `prototype`으로부터 `constructor` 속성을 상속합니다:


```js
var o = {};
o.constructor === Object; // true

var o = new Object();
o.constructor === Object; // true

var a = [];
a.constructor === Array; // true

var a = new Array();
a.constructor === Array; // true

var n = new Number(3);
n.constructor === Number; // true
```

예제
--

### 객체의 생성자 표시하기

다음 예는 프로토타입이 `Tree`인 그 형의 객체 `theTree`를 만듭니다. 그 다음 객체 `theTree`의 `constructor`를 표시합니다.


```js
function Tree(name) {
  this.name = name;
}

var theTree = new Tree("Redwood");
console.log("theTree.constructor is " + theTree.constructor);
```


이 예는 다음 출력을 표시합니다:


```js
theTree.constructor is function Tree(name) {
  this.name = name;
}
```

### 객체의 생성자 바꾸기

다음 예는 일반 객체의 constructor 값을 수정하는 법을 보입니다. `true`, `1` 및 `"test"`만이 원래 읽기 전용 생성자를 갖기에 영향을 받지 않습니다. 이 예는 객체의 `constructor` 속성에 의존하는 게 항상 안전하지는 않음을 보입니다.


```js
function Type() {}

var types = [
  new Array(),
  [],
  new Boolean(),
  true, // 바뀌지 않음
  new Date(),
  new Error(),
  new Function(),
  function () {},
  Math,
  new Number(),
  1, // 바뀌지 않음
  new Object(),
  {},
  new RegExp(),
  /(?:)/,
  new String(),
  "test", // 바뀌지 않음
];

for (var i = 0; i < types.length; i++) {
  types[i].constructor = Type;
  types[i] = [
    types[i].constructor,
    types[i] instanceof Type,
    types[i].toString(),
  ];
}

console.log(types.join("\n"));
```


이 예는 다음 출력을 표시합니다:


```js
function Type() {},false,
function Type() {},false,
function Type() {},false,false
function Boolean() {
    [native code]
},false,true
function Type() {},false,Mon Sep 01 2014 16:03:49 GMT+0600
function Type() {},false,Error
function Type() {},false,function anonymous() {

}
function Type() {},false,function () {}
function Type() {},false,[object Math]
function Type() {},false,0
function Number() {
    [native code]
},false,1
function Type() {},false,[object Object]
function Type() {},false,[object Object]
function Type() {},false,/(?:)/
function Type() {},false,/(?:)/
function Type() {},false,
function String() {
    [native code]
},false,test
```

명세
--

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

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Object.prototype.isPrototypeOf()
================================

**`isPrototypeOf()`** 메소드는 해당 객체가 다른 객체의 프로토타입 체인에 속한 객체인지 확인하기 위해 사용됩니다.

**참고:** `isPrototypeOf` 는 `instanceof` 연산자와 다릅니다. "`object instanceof AFunction`" 표현식에서는 `object` 의 프로토타입 체인을 AFunction 자체가 아니라 `AFunction.prototype` 에 대해 확인을 합니다.

구문
--


```js
prototypeObj.isPrototypeOf(obj);
```

### 매개변수

`object`

프로토타입 체인을 가지고 있는 객체가 검색될 것 입니다.

설명
--

`isPrototypeOf` 메소드는 또 다른 객체의 프로토타입 체인에 해당 객체가 존재하는지 여부를 확인할수 있습니다.

예를들어, 다음의 프로토타입체인을 고려해봅시다.


```js
function Fee() {
  // ...
}

function Fi() {
  // ...
}
Fi.prototype = new Fee();

function Fo() {
  // ...
}
Fo.prototype = new Fi();

function Fum() {
  // ...
}
Fum.prototype = new Fo();
```


실행되고 나면 **Fum** 인스턴스의 프로토타입체인이 **Fi**의 프로토타입과 연결되어있는지를 확인할 필요가 있습니다. 다음과 같은 방법으로 확인할 수 있습니다:


```js
var fum = new Fum();
// ...

if (Fi.prototype.isPrototypeOf(fum)) {
  // do something safe
}
```


이 메소드는 `instanceof` 연산자와 함께 특정 프로토타입으로부터 상속된 객체만 작동하게 하려는(예를 들어 특정 메소드나 속성이 객체에 있다는걸 보장하려는 때) 코드에서 특히 쓸모가 많다.

명세
--

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

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

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

같이 보기
-----

* `instanceof`
* `Object.getPrototypeOf()`
* `Object.setPrototypeOf()` (en-US)
* `Object.prototype.__proto__`