alert("Hello!");

}

f.defer(1000);//shows"Hello!"after 1 sec

f.defer(1000);//1초 후"Hello!"출력

Add to the prototype of all functions the method`defer(ms)`, that runs the function after`ms` milliseconds.

모든 함수의 프로토타입에`ms`밀리초 후에 함수를 실행하는`defer(ms)`함수를 추가하세요.

functionf() {

alert("Hello!");

}

f.defer(1000);//shows"Hello!"after 1 second

f.defer(1000);//1초 후"Hello!"출력

인수들은 기존 함수에 전달되는 것을 알아두세요.

}

};

functionf(a,b) {

alert( a+ b );

}

f.defer(1000)(1,2);//shows 3 after 1 sec

f.defer(1000)(1,2);//1초 후 3 출력

Please note: we use`this` in`f.apply` to make our decoration work for object methods.

객체 메서드에 대한 데코레이션 동작을 만들기 위해서`this`를`f.apply`안에서 사용하는 것을 알아두세요.

So if the wrapper function is called as an object method, then`this` is passed to the original method`f`.

그래서 래퍼 함수가 객체 메서드로써 호출된다면`this`는 기존 메서드`f`에 전달됩니다.

```js run

Function.prototype.defer=function(ms) {

Add to the prototype of all functions the method`defer(ms)`, that returns a wrapper, delaying the call by`ms` milliseconds.

모든 함수의 프로토타입에`ms` 밀리세컨초 지연 호출 래퍼를 반환하는`defer(ms)` 메서드를 추가하세요.

functionf(a,b) {

alert( a+ b );

}

f.defer(1000)(1,2);//shows 3 after 1 second

f.defer(1000)(1,2);//1초 후 3을 출력

Please note that the arguments should be passed to the original function.

인수들은 기존 함수에 전달되는 것을 알아두세요.

The`"prototype"` property is widely used by the core of JavaScript itself. All built-in constructor functions use it.

`prototype` 프로퍼티는 자바스크립트 내에서 널리 이용됩니다. 모든 내장 생성자 함수에서 사용됩니다.

First we'll see at the details, and then how to use it for adding new capabilities to built-in objects.

첫 번째로 자세히 살펴본 다음 어떻게 내장 객체에 새 기능을 추가하여 프로토타입 프로퍼티를 사용하는지 알아보겠습니다.

```js run

let obj= {};

alert( obj );// "[object Object]" ?

Where's the code that generates the string`"[object Object]"`? That's a built-in`toString`method, but where is it? The`obj` is empty!

`"[object Object]"` 문자열을 생성하는 코드는 어디에 있나요? 이는 내장`toString`메서드 입니다. 하지만 어디에 있을까요?`obj`는 비어 있습니다!

...But the short notation`obj = {}` is the same as`obj = new Object()`, where`Object` is a built-in object constructor function, with its own`prototype` referencing a huge object with`toString` and other methods.

`obj = {}`의 줄임법은`obj = new Object()`와 같습니다. 여기서`Object`는 큰 객체에`toString`메서드와 다른 메서드으로 큰 객체를 참조하는 자체 프로토타입을 가진 내장 객체 생성자 함수입니다.

So then when`obj.toString()` is called the method is taken from`Object.prototype`.

따라서`obj.toString()`이 호출될 때 메서드는`Object.prototype`으로부터 가져옵니다.

```js run

let obj= {};

```js run

alert(Object.prototype.__proto__);// null

Other built-in objects such as`Array`,`Date`,`Function` and others also keep methods in prototypes.

`Array`,`Date`,`Function`을 포함한 다른 내장 객체들 또한 메서드를 프로토타입 안에 유지합니다.

For instance, when we create an array`[1, 2, 3]`, the default`new Array()`constructor is used internally. So`Array.prototype` becomes its prototype and provides methods. That's very memory-efficient.

예를 들면 배열`[1, 2, 3]` 을 생성할 때 기본`new Array()`생성자는 내부적으로 사용됩니다. 그래서`Array.prototype`이 프로토타입이 되고 메서드를 제공하게 됩니다. 이는 상당히 메모리 효율적입니다.

By specification, all of the built-in prototypes have`Object.prototype` on the top. That's why some people say that "everything inherits from objects".

구체적으로 모든 내장 프로토타입은`Object.prototype`을 가장 위에 가집니다. 이 때문에 몇몇 사람들은 "모든 것은 객체로부터 온다"라고 말합니다.

```js run

let arr= [1,2,3];

alert(arr.__proto__===Array.prototype );// true

alert(arr.__proto__.__proto__===Object.prototype );// true

alert(arr.__proto__.__proto__.__proto__ );// null

```js run

let arr= [1,2,3]

alert(arr);// 1,2,3 <--the result ofArray.prototype.toString

alert(arr);// 1,2,3 <-- Array.prototype.toString 의 결과

As we've seen before,`Object.prototype`has`toString` as well, but`Array.prototype` is closer in the chain, so the array variant is used.

전에 보았던 대로,`Object.prototype`또한`toString`을 가지고 있습니다. 그러나`Array.prototype`이 체인에 더 가깝기 때문에 Array의 toString이 사용되었습니다.

In-browser tools like Chrome developer console also show inheritance(`console.dir` may need to be used for built-in objects):

Chrome 개발자 콘솔과 같은 브라우저 툴 내에서는 상속을 보여줍니다.(`console.dir`는 아마 내장 객체를 사용하기 위해 필요합니다.)

Other built-in objects also work the same way. Even functions -- they are objects of a built-in`Function` constructor, and their methods(`call`/`apply`and others) are taken from`Function.prototype`. Functions have their own`toString` too.

다른 내장 객체들 또한 같은 방법으로 동작합니다. 심지어 내장`Function`의 객체 함수 생성자와 메서드(`call`/`apply`등등)들도`Fuction.prototype`으로 부터 가져옵니다. 함수 또한 자기 자신의`toString`를 가지고 있습니다.

```js run

functionf() {}

alert(f.__proto__.__proto__==Object.prototype);// true, inherit from objects

The most intricate thing happens with strings, numbers and booleans.

가장 복잡한 것은 문자열, 숫자 그리고 불값과 함께 생깁니다.

As we remember, they are not objects. But if we try to access their properties, then temporary wrapper objects are created using built-in constructors`String`,`Number`,`Boolean`, they provide the methods and disappear.

기억하다시피 이것들은 객체가 아닙니다. 그러나 그들의 프로퍼티에 접근하려고 시도한다면 내장 생성자`String`,`Number`,`Boolean`을 사용하는 임시 래퍼 객체가 생성되며 메서드를 제공하고 사라집니다.

These objects are created invisibly to us and most engines optimize them out, but the specification describes it exactly this way. Methods of these objects also reside in prototypes, available as`String.prototype`,`Number.prototype` and`Boolean.prototype`.

이러한 객체들은 눈에 보이지 않게 생성되고 대부분의 엔진은 이를 최적화합니다. 명세서에도 이처럼 묘사됩니다. 객체들의 메서드는`String.prototype`,`Number.prototype`,`Boolean.prototype`처럼 사용할 수 있는 프로토타입 안에 존재합니다.

```warn header="Values`null` and`undefined` have no object wrappers"

Special values`null` and`undefined` stand apart. They have no object wrappers, so methods and properties are not available for them. And there are no corresponding prototypes too.

```warn header="`null`과`undefined`의 값은 객체 래퍼를 가지지 않습니다."

특수한 값인`null`과`undefined`는 다른 것과는 거리가 있습니다. 객체 래퍼가 없기 때문에 메서드와 프로퍼티를 이용할 수 없습니다. 그리고 해당하는 프로퍼티도 존재하지 않습니다.

During the process of development, we may have ideas for new built-in methods we'd like to have, and we may be tempted to add them to native prototypes. But that is generally a bad idea.

개발과정 도중 사용자의 편의에 따른 새로운 내장 메서드를 생성할 수 있습니다. 또한 새로운 내장 메서드를 네이티브 프로토타입에 추가할 수도 있습니다. 그러나 일반적으로 좋지 않은 아이디어입니다.

**In modern programming, there is only one case where modifying native prototypes is approved. That's polyfilling.**

**모던 프로그래밍에서는 오직 한 경우에만 네이티브 프로토타입 변경을 허용하고 있는데 바로 폴리필링입니다.**

Polyfilling is a term for making a substitute for a method that exists in JavaScript specification, but is not yet supported by current JavaScript engine.

폴리필링은 자바스크립트 명세서에 존재하는 메서드에 대한 대체재를 만드는 데 사용하는데 현재의 자바스크립트 엔진에서는 아직 지원하지 않습니다.

Then we may implement it manually and populate the built-in prototype with it.

따라서 폴리필링을 수동으로 실행하며 내장 프로토타입과 함께 값을 가져옵니다.

For instance:

예시:

```js run

if (!String.prototype.repeat) {//if there's no such method

if (!String.prototype.repeat) {//해당 메서드가 존재하지 않는다면

String.prototype.repeat=function(n) {

returnnewArray(n+1).join(this);

};

}

In the chapter<info:call-apply-decorators#method-borrowing> we talked about method borrowing.

<info:call-apply-decorators#method-borrowing>에서는 메서드 빌리기에 관하여 얘기하였습니다.

That's when we take a method from one object and copy it into another.

이는 메서드를 하나의 객체로부터 가져온 다음 다른 객체에 복사하는 것입니다.

Some methods of native prototypes are often borrowed.

몇몇 네이티브 프로토타입의 메서드들은 자주 사용됩니다.

```js run

let obj= {

alert(obj.join(',') );// Hello,world!

It works, because the internal algorithm of the built-in`join` method only cares about the correct indexes and the`length`property, it doesn't check that the object is indeed the array. And many built-in methods are like that.

코드는 정상작동 합니다. 왜냐하면,내장`join`메서드의 내장 알고리즘은 단지 인덱스의 일치 여부만 케어하며`length`프로퍼티는 객체가 실제로 배열에 존재하는지 체크하지 않습니다. 그리고 수많은 내장 메서드들도 또한 이와 같습니다.

Another possibility is to inherit by setting`obj.__proto__` to`Array.prototype`, so all`Array` methods are automatically available in`obj`.

다른 가능성은`obj.__proto__`를`Array.prototype`에 상속시키는 것입니다. 그래서 모든`Array`메서드가 자동으로`obj`에서 사용 가능하게 하는 것입니다.

`obj`가 이미 다른 객체로부터 상속받았다면 위 방법은 불가능합니다. 오직 한 번에 하나의 객체로부터 상속 가능함을 기억해 두세요.

But that's impossible if`obj` already inherits from another object. Remember, we only can inherit from one object at a time.

메서드 빌리기는 유연하여 필요에 따라 함수적 기능을 섞는 것을 다른 객체로부터 가능하게 합니다.

- All built-in objects follow the same pattern:

- The methods are stored in the prototype (`Array.prototype`,`Object.prototype`,`Date.prototype` etc).

- The object itself stores only the data (array items, object properties, the date).

- Primitives also store methods in prototypes of wrapper objects:`Number.prototype`,`String.prototype`,`Boolean.prototype`. Only`undefined` and`null` do not have wrapper objects.

- Built-in prototypes can be modified or populated with new methods. But it's not recommended to change them. Probably the only allowable case is when we add-in a new standard, but not yet supported by the engine JavaScript method.

- 모든 내장 객체는 같은 패턴을 따릅니다.

- 메서드는 프로토타입에 저장됩니다(`Array.prototype`,`Object.prototype`,`Date.prototype` 등).

- 객체 스스로는 단지 데이터만 저장합니다(배열의 아이템, 객체의 프로퍼티, 날짜).

- 원시값 또한 객체 래퍼의 프로토타입 안에`Number.prototype`,`String.prototype`,`Boolean.prototype`과 같은 메서드를 저장합니다.`undefined` 와`null` 값만 객체 래퍼를 가지지 않습니다.

- 내장 프로토타입은 수정 가능하며 새로운 메서드와 함께 값을 가져올 수 있습니다. 그러나 내장 프로토타입을 변경하는 것을 추천하진 않습니다. 아마 새로운 표준을 추가하려고 할 때 만 가능합니다. 그러나 이는 자바스크립트 엔진 메서드에서는 아직 지원하지 않습니다.