6/ OOP (ES5 기준)

function Person(arg) {
  // 클래스이자, 생성자의 역할을 함.
  this.name = arg;
  this.getName = function () {
    return this.name;
  };
  this.setName = function (value): void {
    this.name = value;
  };
}
const me = new Person('Kim');
console.log(me.getName()); // Kim
me.setName('Joy');
console.log(me.getName()); // Joy

const you = new Person('Gray');
const him = new Person('Lee');

function Person(arg) {
  this.name = arg;
}
 
Person.prototype.getName = function () {
  return this.name;
};
 
Person.prototype.setName = function (value) {
  this.name = value;
};
 
const you = new Person('Gray');
const him = new Person('Lee');
console.log(you.getName()); // this는 자신을 호출한 객체에 바인딩된다.
console.log(him.getName()); // 프로토타입 체인으로 접근할 수 있다.

Function.prototype.method = function(name, function) {
  if(!this.prototpye[name]) {
    this.prototype[name] = function;
  }// 프로토타입에 같은 이름의 메서드가 없다면
}
 
function Person(arg) {
  this.name = arg;
}
Person.method('setName', function(value){
  this.name = value;
})
Person.method('getName', function() {
  return this.name;
})
 
const me = new Person("me");
const you = new Person("you");
console.log(me.getName());
console.log(you.getName());

function create_object(o) {
  function F() {}
  F.prototype = o;
  return new F();
} // Object.create() 함수로 제공된다.

function create_object(o) {
  function F() {}
  F.prototype = o;
  return new F();
}
 
var person = {
  name: "Joy"
  getName: function() { // ES6의 getter 개념
    return this.name;
  }
  setName: function(arg){ // ES6의 setter 개념
    this.name = arg;
  }
}
 
var me = create_object(person)
me.name // Joy
me.getName() // Joy
me.setName("Kim")
me.name // Kim
me.getName() // Kim

me.setAge = function(age) {...}
me.getAge = function() {...}

jQuery.extend = jQuery.fn.extend = function (obj: 자식, prop: 부모) {
  if (!prop) {
    prop = obj; // 부모가 없으면 자식이 부모
    obj = this; // this를 자식에게 할당
  }
  for (var i in prop) {
    // deep copy
    ob[i] = prop[i];
  }
  return obj;
};

// jQuery extend 함수 중 일부
...
for (; i < length; i++){
  if( (options = arguments[i]) != null) {
    /* 인자로 넘어온 객체의 프로퍼티를 options로 참조시키고,
      그 프로퍼티가 null이 아닌 경우 블록 안으로 진입한다. */
    for (name in options){ // options를 deep 카피한다.
      src = target[name]; // src는 반활될 복사본 target을 가리킴
      copy = options[name]; // copy는 복사할 원본 프로퍼티를 가리킴
 
      if (target === copy){ // 무한루프 방지
        continue; // continue는 루프의 실행을 완전히 종료하지 않고 for 루프에서는 업데이트 표현식으로 점프함.
      }
      if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy))) ){
        // deep 플래그:boolean: extend에서 인자로 받음 : 깊은 복사를 할 것인지 선택 할 수 있게 한다.
        // copy: 참조형식인 경우 (객체나 배열인 경우) 무조건 deep copy 시작
        )
        if ( copyIsArray ) {
          copyIsArray = false;
          clone = src && jQuery.isArray(src) ? src : [];
          // 배열 복사일 경우 빈 배열 생성
        } else {
          clone = src && jQuery.isPlainObject(src) ? src : {};
          // 객체 복사일 경우 빈 객체 생성
        }
        target[name] = jQuery.extend(deep, clone, copy); // 재귀..
      } else if (copy !== undefined) {
        target[name] = copy;
      }
    }
  }
  return target;
}

const person = {
  name: 'joy',
  getName: function(){ return this.name; },
  setName: function(arg){this.name = arg;}
}
 
function create_object(o) {
  function F() {};
  F.prototype = o;
  return new F();
}
 
function extend(obj, prop) {
  if(!prop) {prop = obj; obj = this;}
  /* 인자가 하나만 들어오는 경우,
    prop 인자에 obj를 할당하고,
    현재객체(this)에 객체의 프로퍼티를 복사한다.... */
  for (let i in prop) obj[i] = prop[i]; // 얕은 복사임.
  return obj;
}
 
const student = create_object(person);
const added = {
  setAge: function(age){ this.age = age; }
  getAge: function() {return this.age;}
}
 
extend(student, added); // 1
student.setAge(25);
console.log(student.getAge());

function Person(arg) { this.name = arg;}
Person.prototype.setName = function(value) { this.name = value; };
Person.prototype.getName = function() { return this.name; }
 
function Student(arg) {}
 
const you = new Person('JoyKim'); Student.prototype = you;
 
const me = new Student('NaYoung'); me.setName('Kim'); console.log(me.getName());
 

function Person(arg) { this.name = arg;}
Function.prototype.method = function(name, func) { this.prototype[name] = func };
Person.method('setName', function(value) { this.name = value; };)
Person.method('getName', function() { return this.name; })
 
function Student(arg) {}
function F(){};
F.prototype = Person.prototype;
Student.prototype = new F();
Student.prototype.constructor = Student;
Student.super = Person.prototype;
 
const me = new Student('NaYoung');
const you = new Person('YoungRan');
me.setName('Kim');

const inherit = function (Parent, Child) {
  const F = function () {};
  return function (Paretn, Child) {
    F.prototype = Parent.prototype;
    Child.prototype = new F();
    Child.prototype.constructor = Child;
    Child.super = Parent.prototype;
  };
};

const Person = function (arg) {
  let name = arg ? arg : 'joy';
  this.getName = function () {
    return name;
  };
  this.setName = function (arg) {
    name = arg;
  };
};
 
const me = new Person();
console.log(me.getName());
me.setName('NaYoung');
console.log(me.getName());
console.log(me.name);

// 모듈패턴
const Person = function(arg){
  const name = arg? arg: 'joy';
  // name은 private 멤버
  return {
    getName: function() { return name;},
    setName: fucntion(arg){ name = arg;}
  }
}
const me = Person()
console.log(me.getName())

const SuperClass = subClass(obj); // 상속받을 클래스
const SubClass = SuperClass.subClass(obj); // SubClass는 SuperClass를 상속받는다.

function subClass(obj) {
  /*
    1. 자식 클래스 (함수객체) 생성
    2. 생성자 호출 (클래스 함수를 생성하기 위해서)
    3. 프로토타입 체인을 활용한 상속 구현
    4. obj를 통해 들어온 변수 및 메서드를 자식 클래스에 추가
    5. 자식 함수 객체 반환
  */
}

function subClass(obj) {
  ...
  const parent = this; // 부모클래스를 가리키는 parent는 this를 그대로 참조
  const F = function(){}; // 중간역할
  const child = function(){}; // 자식객체
  F.prototype = parent.prototype;
  child.prototype = new F(); // 부모의 프로토타입을 참조하는 프로토타입을 갖고있는 F로부터 만들어진 생성자 함수를 child 프로토타입이 참조하도록한다.ㅇ
  child.prototype.constructor = child;
  child.parent = parent.prototype;
  child.parent_constructor = parent;
  ...
  return child;
 
}

for (let i in obj) {
  if (obj.hasOwnProperty(i)) {
    child.prototype[i] = obj[i];
  }
}

o = new Object();
o.prop = 'exists';
o.hasOwnProperty('prop'); // true
o.hasOwnProperty('toString'); // false
o.hasOwnProperty('hasOwnProperty'); // false

const child = function () {
  if (parent.hasOwnProperty('_init')) {
    parent._init.apply(this, arguments);
  }
  if (child.prototype.hasOwnProperty('_init')) {
    child.prototype._init.apply(this, arguments);
  }
};

const SuperClass = subClass();
const SubClass = SuperClass.subClass();
const Sub_SubClass = SubClass.subClass();
 
const instance = new Sub_SubClass();

const child = function () {
  const _parent = child.parent_constructor;
  if (_parent && _parent !== Function) {
    _parent.apply(this, arguments);
  }
  if (child.prototype.hasOwnProperty('_init')) {
    child.prototype._init.apply(this, arguments);
  }
};

function subClass(obj){
  /*
    1. 자식 클래스 (함수객체) 생성
    2. 생성자 호출 (클래스 함수를 생성하기 위해서)
    3. 프로토타입 체인을 활용한 상속 구현
    4. obj를 통해 들어온 변수 및 메서드를 자식 클래스에 추가
    5. 자식 함수 객체 반환
  */
  const parent = this === window ? Function : this;
  const F = function(){}
  const child = function() {
    const _parent = child.parent;
    if(_parent && _parent !== Function){
      parent.apply(this, arguments);
    }
    if(child.prototype._init)){
        child.prototype._init.apply(this, arguments);
    }
  }
  F.prototype = parent.prototype;
  child.prototype = new F();
  child.prototype.constructor = child;
  child.parent = parent;
  child.subClass = arguments.callee;
 
  for (let i in obj){
    if (obj.hasOwnProperty(i)){
      child.prototype[i] = obj[i];
    }
  }
  return child
}