자바스크립트 코드 재사용 패턴

// 생성자 함수 선언
> var P = function (name) { this.name = name || 'adam'; };

// P는 함수이므로 prototype이 있다.
> P.prototype.say = function () { return this.name; };

// new 생성자를 사용하면 객체가 생성된다.
// 생성자 함수의 프로퍼티는 자신의 것으로 복사하고
// prototype에 선언된 프로퍼티는 생성자의 것과 연결된다.
> var p = new P();

// 다른 생성자 함수 선언
> var C = function () {};

// 프로토타입에 p 객체를 할당한다. 
// name은 본인의 것이었고, say는 체이닝되었다는 것을 기억하라.
> var C.prototype = p;

// c 객체는 아무런 프로퍼티가 없다. 생성자가 비어있기 때문이다.
// c.hasOwnProperty('name'), c.hasOwnProperty('say') 모두 false다.
> var c = new C();

// 하지만 __proto__로 연결되어 있기 때문에 say() 함수를 쓸 수 있다. 
> c.say()
// adam

// 생성자 함수 선언
> var A = function (name) { this.tags = ['js', 'css'] };

// new는 a = {}라는 객체를 만든다.
// 그리고 A();를 실행하면 A함수의 this는 a{}가 된다.
// A(); 함수가 실행되면서 this.tags에 값을 할당하므로 
// a = { tags: ['js', 'css']};가 완성된다.
> var a = new A();

// 이 부분은 맨 처음에 설명했으므로 생략
> var B = function () {};
> B.prototype = a;
> var b = new B();

// 생성자 함수에 A함수 실행하는 것이 들어있다.
// 참조 객체는 this이다.
> var C = function () { A.call(this); };

// c {} 를 먼저 만든다.
// 생성자 함수에서 A를 실행시키는데 C함수 내의 this는 c {}가 되었다.
// c {} 안에 A(); 함수를 실행하는 것이 되기 때문에
// c { tags: ['js', 'css']} 가 완성된다.
> var c = new C();

// 다음은 true다. 
> c.hasOwnProperty('tags');

// 체이닝된 b.tags에 값을 추가하면 a.tags 인스턴스에도 영향을 미친다.
// b.prototype = a; 를 했기 때문이다.
> b.tags.push('html');

// c는 프로퍼티를 복사했으므로 자기것만 바꾼다.
> c.tags.push('php');

// 결과 
> console.log(a.tags.join(', '));
// js, css, html

// 부모 생성자 함수
var Parent = function (name) {
	this.name = name || 'adam';
};

// 부모의 프로토타입 함수
Parent.prototype.say = function () {
	return this.name;
};

// 상속받을 자식 생성자 함수
var Child = function (a, b, c, d) {
	
	// 아래는 this.name을 생성할 객체의 hasOwnProperty로 만든다.
	Parent.apply(this, arguments);
};

// 아래는 Parent.prototype.say 함수와 연결된다. 
Child.prototype = new Parent();

var inherit = function (C, P) {
	C.prototype = P.prototype;
};

var inherit = function (C, P) {
	// 임시 생성자 함수 정의
	var F = function () {};

	// 임시 생성자 함수의 프로토타입에 부모의 프로토타입을 공유하도록 한다.
	F.prototype = P.prototype;

	// 자식의 프로토타입에 임시 생성자 함수를 통한 객체를 할당하여 프로토타입 체인을 만든다.
	C.prototype = new F();

	// 부모의 프로토타입은 __super__ 프로퍼티를 통해 공유한다. 
	// 이렇게 하면 부모 클래스에 대한 접근 경로를 가지게 된다.
	C.__super__ = P.prototype;

	// new Child()로 생성한 객체의 constructor가 모두 Parent가 된다.
	// 따라서 생성자 함수를 다른 것으로 변경한다.
	// 아래와 같이 하면 Child가 된다. 
	C.prototype.constructor = C;
};

var inherit = (function () {
	var F = function () {};
	return function (C, P) {
		F.prototype = P.prototype;
		C.prototype = new F();
		C.__super__ = P.prototype;
		C.prototype.constructor = C;
	}
})();