var a = {};
a.constructor; // Object
var a = [];
a.constructor; // Array
var a = new Array;
a.constructor; // Array
var n = new Number(3);
n.constructor; // Number

var obj = {};
obj.constructor === Object; // true
// 이렇게 직접 가진 속성인듯이 이용할 수 있지만 사실은 __proto__를 통해 건너서 접근하는 것입니다.

obj.__proto__ === Object.prototype; // true
obj.__proto__.constructor === Object.prototype.constructor; // true

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

var theTree = new Tree('Redwood');   // Tree의 인스턴스인 theTree
console.log('theTree.constructor is ' + theTree.constructor);

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

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; // 각각의 constructor에 연결된 함수를 Type 함수로 재할당합니다.
    types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()];
}

console.log(types.join('\n')); 

function Parent() {}
Parent.prototype.parentMethod = function parentMethod() {};

function Child() {}
Child.prototype = Object.create(Parent.prototype); // Child 프로토타입을 Parent 프로토타입으로 재정의
// (역자 주) Child.prototype의 값은 이제 오브젝트 {__proto__: Parent.prototype}로 대체됩니다.

Child.prototype.constructor = Child; // original constructor를 Child 로 돌려줌
// (역자 주) {__proto__: Parent.prototype} 에 constructor 속성을 추가해 Child함수를 할당합니다.

function Parent() {};
function CreatedConstructor() {};

CreatedConstructor.prototype = Object.create(Parent.prototype);
// (역자 주) Parent.prototype을 원형으로 새 오브젝트를 만들어, CreatedConstructor.prototype에 할당


CreatedConstructor.prototype.create = function create() {
    return new this.constructor(); // (역자 주) this의 생성자를 가져와 새 인스턴스를 만들어 리턴
}
// (역자 주) CreatedConstructor의 인스턴스는 이 create메서드를 상속받습니다.

new CreatedConstructor().create().create(); // TypeError
// (역자 주) new CreatedConstructor()는 오브젝트이며,
// 첫번째 create()는 this.constructor를 가져오는데
// __proto__를 거쳐서 constructor 속성을 가져옵니다.
// (프로토타입 체인 상에 가장 먼저 발견되는 constructor인 Parent함수를 가져옵니다.)
// {__proto__: {
//     create(), 
//     __proto__: Parent.prototype{
//         constructor: Parent,  <- 이걸 가져옵니다.
//         __proto__: Object
//         }
//     }
// }
// 즉, new CreatedConstructor().create()는 Parent생성자의 인스턴스를 만듭니다.
// 그런데 Parent의 인스턴스는 위에 정의했던 create메서드를 갖고있지 않기 때문에
// undefined.create();가 되며 Type Error가 납니다.

function Parent() {}; 
function CreatedConstructor() {} 

CreatedConstructor.prototype = Object.create(Parent.prototype); 
CreatedConstructor.prototype.constructor = CreatedConstructor; // set right constructor for further using
// (역자 주) 앞 예제와 달리, CreatedConstructor.prototype에 constructor 속성을 갖습니다.
// 이제는 constructor를 찾기 위해 __proto__ 한번만 보면 됩니다.
// (한단계 더 타고가면 Parent를 값으로 갖는 constructor속성이 여전히 있지만, 그 전에 탐색이 끝납니다.)

CreatedConstructor.prototype.create = function create() { 
    return new this.constructor();
} 

new CreatedConstructor().create().create(); // it's pretty fine
// (역자 주) 앞 예제와 달리 new CreatedConstructor()로 만든 인스턴스가 아래와 같습니다.
// {__proto__: {
//     constructor: CreatedConstructor,  <- create의 this.constructor가 이걸 참조합니다.
//     create(), 
//     __proto__: Parent.prototype{
//         constructor: Parent,
//         __proto__: Object
//         }
//     }
// }
// 이제는 .create()를 몇 번을 붙이든 항상 CreatedConstructor의 인스턴스를 만듭니다.
// 따라서 에러 없이 create메서드를 계속해서 불러올 수 있습니다.

function ParentWithStatic() {}

ParentWithStatic.startPosition = { x: 0,  y: 0 };
ParentWithStatic.getStartPosition = function getStartPosition() {
    return this.startPosition;
}

function Child(x, y) {
    this.position = {
        x: x,
        y: y
    };
}

Child.prototype = Object.create(ParentWithStatic.prototype);
Child.prototype.constructor = Child;

Child.prototype.getOffsetByInitialPosition = function getOffsetByInitialPosition() {
    var position = this.position;
    var startPosition = this.constructor.getStartPosition(); // error undefined is not a function, constructor가 Child이기 때문입니다.
    // (역자 주) constructor가 Child라서 ParentWithStatic의 getStartPosition 메서드를 불러올 수 없습니다.

    return {
        offsetX: startPosition.x - position.x,
        offsetY: startPosition.y - position.y
    }
};