prototype

var obj = {};

// var obj = new Object() 이다.

// Object 도 기본적으로 함수이다. function Object()

// var o = new obj();

// 이렇게는 사용할 수 없다. obj is not constructor.

// constructor 가 있어야만 new 를 통해서 객체를 만들수 있다.

// 따라서 함수만 new 키워드를 사용 할 수 있다.

var a = {a: 1};

// a ---> Object.prototype ---> null

// Error literal object 에는 prototype 을 재정의 할 수 없음.

//a.prototype.getA = function() {

//    return this.a;

//}

// b 의 prototype 이 a 가 된다.

var b = Object.create(a);

// b ---> a ---> Object.prototype ---> null

//console.log(b.a); // 1 (상속됨)

// Error literal object 에는 prototype 을 재정의 할 수 없음.

//b.prototype.getA = function() {

//    return "A";

//}

// 일반 객체에는 prototype 을 정의할 수 없다.

// 그냥 prototype 이라는 속성으로 인식함.

try {

    var p = {

        a: 10,

        b: 20

    }

    // 일반객체에 prototype 을 정의할 수 없음.

    // "prototype" 이라는 속성이 추가 되는 것임.

    // __proto__ 변수에 매핑 되는 것이 아님.

    p.prototype = {

        getA: function () {

            return this.a;

        }

    }

    console.log("p = ", p);

    console.log("p.a = ", p.a);

    console.log("p.__proto__ = ", p.__proto__);

    console.log("p.prototype = ", p.prototype);

    //console.log("p.getA() = ", p.getA()); // p 객체에는 getA 함수가 없음. 프로토타입 체인으로도 찾을 수 없음.

    //console.log("p.prototype.getA() = ", p.prototype.getA()); // p.prototype.getA 함수에서 this 지시자를 사용 할 수 없음.

    // Object.create(p) 이용하여 p1 이라는 새로운 객체 생성.

    // p1.__proto__ = p 이라는 의미가 됨.

    console.log();

    console.log("=================================================");

    console.log("p1 = Object.create(p)");

    var p1 = Object.create(p);

    console.log("p1 = ", p1);

    console.log("p1.__proto__ = ", p1.__proto__);

    console.log("p1.prototype = ", p1.prototype); // "prototype" 이라는 속성.

    console.log("p1.__proto__.__proto__ = ", p1.__proto__.__proto__);

    console.log("p1.a = ", p1.a); // p1.__proto__.a

    //console.log("p1.getA() = ", p1.getA()); // p1, p1__proto__ 객체에 getA 라는 함수는 없다.

    //console.log("p1.prototype.getA() = ", p1.prototype.getA()); // p1__proto__.prototype.getA 함수에서 this 지시자를 사용 할 수 없음.

} catch(err) {

    console.log(err);

}

// prototype 설명 : https://medium.com/@bluesh55/javascript-prototype-%EC%9D%B4%ED%95%B4%ED%95%98%EA%B8%B0-f8e67c286b67.

// 함수를 정의하는 순간 Prototype Object 도 생성됨.

// Prototype Object 는 일반적인 객체와 같으며 기본적인 속성으로 constructor 와 __proto__ 를 가지고 있음.

// constructor는 Prototype Object와 같이 생성되었던 함수.

// __proto__는 Prototype Link.

// __proto__는 객체가 생성될 때 조상이었던 함수의 Prototype Object를 가리킴.

// Foo 는 function 객체.

// Foo.__proto__ == Function.prototype. 따라서, F.call() 호출 가능하다.

// Foo.constructor 는 Function. Foo.__proto__ 의 생성자.

function Foo() {

    this.a = 1;

}

// new 키워드로 객체 생성. 생성자 함수 호출. 생성자를 바탕으로 객체를 생성한다.

// foo.__proto__ 은 Foo.prototype 이다.

// foo.__proto__.constructor 는 function Foo() 이다.

// foo.hasOwnProperty("constructor") === false

var foo = new Foo();

console.log("foo.a", foo.a);

// var foo = new Object();

// foo.__proto__ = Foo.prototype;

// Foo.call(foo);

// prototype과 constructor는 부모자식 관계

if(foo.__proto__ === Foo.prototype) {

    console.log("foo.__proto__ === Foo.prototype");

}

if(foo.__proto__.constructor === Foo) {

    console.log("foo.__proto__.constructor === Foo");

}

function Person() {

    this.name = "anonymous";

    this.job = "none";

    this.sayHello = function () {

        console.log("Hello, my name is " + this.name);

    };

}

function Unikys() {

    this.name = "Unikys";

    this.job = "Programmer";

}

// #1.

Unikys.prototype = new Person();

var unikys1 = new Unikys();

unikys1.sayHello();

//unikys1 instanceof Unikys === true, unikys1 의 prototype 과 Unikys 의 prototype 이 같기 때문.

//unikys1 instanceof Person === true

// unikys1.constructor = function Persion()

// constructor 는 객체에 있는 것이 아니라 prototype 에 있는 것. prototype 의 생성자.(Person객체의 생성자 = function Persion()).

// constructor 가 있는 prototype 을 다른 새로운 객체로 덮어씌우게 되면 원래 자기 자신의 contstructor 는 상실하게 됨.

// 따라서 unikys1 이 new Unikys()로 생성했다고 하더라도 constructor 는 Unikys() 가 아니라 prototype 으로 덮어씌운 객체의 constructor 인 Person() 이 된다.

// #2.

var unikys2 = Object.create(Person.prototype);

unikys2.name = "Unikys";

// 부모 함수의 일부 메서드에 위임을하고 새 개체를 만들지 않으려면 Object.create 를 사용하는 것이 좋음.

// 부모 함수에 있는 속성은 사용할 수 없기 때문에 부모 속성을 사용하지 않는 경우에 사용.

// unikys2.sayHello(); // Error.

// unikys2 의 prototype 을 Person.prototype 으로 정의. unikys2.__proto__ === Person.prototype.

// 대신 Person 의 속성들은 사용할 수 없어서 추가로 정의해야 함.(name 등)

// unikys2 instanceof Person === true

// unikys2.constructor === Person. true.

// #3.

var unikys3 = Object.create(Person);

unikys3.name = "Unikys";

//unikys3.sayHello();

// unikys3 의 prototype 을 Person 으로 정의. unikys3.__proto__ === Person

// unikys3.constructor === Person. false.

// unikys3.constructor === Function. true.

// constructor 는 prototype 의 생성자를 가르킨다.

// unikys3 instanceof Person === false

// unikys3 instanceof Function === true

// Person.isPrototypeOf(unikys3) == true

// prototype은 모든 객체가 공유하고 있어서 한 번만 만들어지지만, this에 넣은 것은 객체 하나를 만들 때마다 메소드도 하나씩 만들어지기 때문에 불필요한 메모리 낭비.

Person.prototype.yell = function () {

    console.log("My name is " + this.name);

}

// #4.

// prototype chain 추가.

Unikys.prototype = Object.create(Person.prototype); // Unikys.prototype = Person.prototype; 으로 했을 경우에는 Unikys.prototype 에 속성을 추가하면 Person.prototype 에도 추가가 된다.

// Unikys.prototype.__proto__ === Person.prototype

// Unikys.prototype.constructor === Person

// Unikys.constructor === Function

console.log(Unikys.constructor);

Unikys.prototype.constructor = Unikys;

// Unikys 객체들의 constructor 를 Unikys 로 정의.

var unikys4 = new Unikys();

console.log(unikys4.name);

//unikys4.sayHello();

// unikys4.__proto === Unikys.prototype

// unikys4.constructor === Unikys

// unikys4.hasOwnProperty("constructor") === false

// unikys4.__proto__.hasOwnProperty("constructor") === false

// unikys4.__proto__.hasOwnProperty("yell") === false

// unikys4.__proto__.__proto__.hasOwnProperty("yell") === true

function Vehicle(name, speed) {

    this.name = name;

    this.speed = speed;

}

Vehicle.prototype.drive = function () {

    console.log(this.name + ' runs at ' + this.speed)

};

function Sedan(name, speed, maxSpeed) {

    // Vehicle 생성자에 this와 arguments를 적용하라.

    // Sedan은 매개변수로 name과 speed, maxSpeed. maxSpeed는 Vehicle이 갖고 있지 않기 때문에 무시. maxSpeed 속성을 따로 추가.

    Vehicle.apply(this, arguments)

    this.maxSpeed = maxSpeed;

}

// Sedan.prototype = new Vehicle(); // 이렇게 하면 new Sedan 할때 Vehicle 이 두번 호출 되는 결과가 발생한다. 그리고 Vehicle 의 속성까지도 가지게 된다.

Sedan.prototype = Object.create(Vehicle.prototype);

Sedan.prototype.constructor = Sedan;

Sedan.prototype.boost = function () {

    console.log(this.name + ' boosts its speed at ' + this.maxSpeed);

};

var sonata = new Sedan('sonata', 100, 200);

sonata.drive(); // 'sonata runs at 100'

sonata.boost(); // 'sonata boosts its speed at 200'

printOwnProperties(sonata);

function printOwnProperties(obj) {

    console.log('==============================================');

    console.log('============ Print Own Properties ============');

    console.log('==============================================');

    for (var key in obj) {

        console.log('property       = ' + key);

        console.log('typeof         = ' + (typeof key));

        console.log('hasOwnProperty = ' + (obj.hasOwnProperty(key)));

        console.log('value          = ' + obj[key]);

        console.log('');

    }

}

var c = function() {return a;}