클래스 상속

var Grade = function () {
   //arguments 객체를 배열처럼 취급하여 slice 메서드를 호출한 후, 실제 배열로 변환
   var args = Array.prototype.slice.call(arguments);
   for (var i = 0; i < args.length; i++) {
      this[i] = args[i];
   }
   this.length = args.length;
};
// Grade 인스턴스들이 배열의 메서드들을 상속받을 수 있도록 하기 위하여 빈 배열 참조
Grade.prototype = [];
var g = new Grade(100, 80);
g.push(90);
console.log(g); // Grade { 0: 100, 1: 80, 2: 90, length: 3 }
delete g.length; // length 프로퍼티 삭제
g.push(70);
console.log(g); // Grade { 0: 70, 1: 80, 90, length: 1}
// push한 값이 0번째 인덱스에 들어가고, length가 1이 됨

var Rectangle = function (width, height) {
   this.width = width;
   this.height = height;
};
Rectangle.prototype.getArea = function () {
   return this.width * this.height;
};
var rect = new Rectangle(3, 4);
console.log(rect.getArea()); // 12
var Square = function (width) {
   Rectangle.call(this, width, width);
};
Square.prototype = new Rectangle();
var sq = new Square(5);
console.log(sq.getArea()); // 25

delete Square.prototype.width;
delete Square.prototype.height;
Object.freeze(Square.prototype);

var extendClass1 = function (SuperClass, SubClass, subMethods) {
   // SubClass는 SuperClass의 프로토타입 메서드와 프로퍼티를 상속받습니다.
   SubClass.prototype = new SuperClass();
   for (var prop in SubClass.prototype) {
      // SubClass.prototype에 있는 모든 프로퍼티에 대해 반복문을 실행합니다.
      // hasOwnProperty 메서드를 사용하여 프로토타입 체인에 있는 상속된 프로퍼티가 아닌,
      // SubClass.prototype 자체에 직접 정의된 프로퍼티인지 확인합니다.
      if (SubClass.prototype.hasOwnProperty(prop)) {
         // 직접 정의된 프로퍼티를 삭제합니다.
         이는 상속 과정에서 불필요한 인스턴스 프로퍼티를 제거합니다.
         delete SubClass.prototype[prop];
      }
   }
   // subMethods 객체가 제공된 경우, SubClass.prototype에 추가할 메서드가 있는지 확인합니다.
   if (subMethods) {
      // subMethods 객체에 있는 모든 메서드에 대해 반복문을 실행합니다.
      for (var method in subMethods) {
         // subMethods 객체에 있는 메서드를 SubClass.prototype에 추가합니다.
         // 이를 통해 SubClass는 SuperClass를 상속받으면서도 추가적인 메서드를 가질 수 있습니다.
         SubClass.prototype[method] = subMethods[method];
      }
   }
   Object.freeze(SubClass.protype);
   return SubClass;
};
 
var Square = extendClass1(Rectangle, function (width) {
   Rectangle.call(this, width, width);
});

var Rectangle = function (width, height) {
   this.width = width;
   this.height = height;
};
Rectangle.prototype.getArea = function () {
   return this.width * this.height;
};
var Square = function (width) {
   Rectangle.call(this, width, width);
};
var Bridge = function () {};
Bridge.prototype = Rectangle.prototype;
Square.prototype = new Bridge();
Object.freeze(Square.prototype);

var extendClass2 = (function () {
   var Bridge = function () {};
   //subMethods에는 subClass의 prototype에 담길 메서드들을 객체로 전달하게끔 함
   return function (SuperClass, SubClas, subMethods) {
      Bridge.prototype = SuperClass.prototype;
      Subclass.prototype = new Bridge();
      if (subMethods) {
         for (var method in subMethods) {
            SubClass.prototype[method] = subMethods[method];
         }
      }
      Object.freeze(SubClass.prototype);
      return SubClass;
   };
})();

// (...생략)
Square.prototype = Object.create(Rectangle.prototype);
Object.freeze(Square.prototype);
// (...생략)

var extendClass1 = function (SuperClass, SubClass, subMethods) {
   SubClass.prototype = new SuperClass();
   for (var prop in SubClass.prototype) {
      if (SubClass.prototype.hasOwnProperty(prop)) {
         delete SubClass.prototype[prop];
      }
   }
   SubClass.prototype.constructor = SubClass;
   if (subMethods) {
      for (var method in subMethods) {
         SubClass.prototype[method] = subMethods[method];
      }
   }
   Object.freeze(SubClass.prototype);
   return SubClass;
};

var extendClass2 = (function () {
   var Bridge = function () {};
   return function (SuperClass, SubClas, subMethods) {
      Bridge.prototype = SuperClass.prototype;
      Subclass.prototype = new Bridge();
      SubClass.prototype.constructor = SubClass;
      if (subMethods) {
         for (var method in subMethods) {
            SubClass.prototype[method] = subMethods[method];
         }
      }
      Object.freeze(SubClass.prototype);
      return SubClass;
   };
})();

var extendClass3 = function (SuperClass, SubClass, subMethods) {
   SubClass.prototype = Object.create(SuperClass.prototype);
   SubClass.prototype.constructor = SubClass;
   if (subMethods) {
      for (var method in subMethods) {
         SubClass.prototype[method] = subMethods[method];
      }
   }
   Object.freeze(SubClass.prototype);
   return SubClass;
};

var extendClass3 = function (SuperClass, SubClas, subMethods) {
   Subclass.prototype = Object.create(SuperClass.prototype);
   SubClass.prototype.constructor = SubClass;
   /* 추가된 코드 시작 */
   SubClass.prototype.super = function (propName) {
      var self = this;
 
      // 인자가 비어있을 경우 SuperClass 생성자 함수에 접근
      if (!propName)
         return function () {
            SuperClass.apply(self, arguments);
         };
      var prop = SuperClass.prototype[propName];
 
      // SuperClass의 prototype 내부의 propName에 해당하는 값이 함수가 아닌 경우에는 해당 값을 그대로 반환
      if (typeof prop !== 'function') return prop;
 
      // 힘수인 경우 : 클로저를 활용해 메서드 접근
      return function () {
         return prop.apply(self, arguments);
      };
   };
   /* 추가된 코드 끝 */
   if (subMethods) {
      for (var method in subMethods) {
         SubClass.prototype[method] = subMethods[method];
      }
   }
   Object.freeze(SubClass.prototype);
   return SubClass;
};
 
var Rectangle = function (width, height) {
   this.width = width;
   this.height = height;
};
Rectangle.prototype.getArea = function () {
   return this.width * this.height;
};
var Square = extendClass(
   Rectangle,
   function (width) {
      this.super()(width, width);
   },
   {
      getArea: function () {
         console.log('size is :', this.super('getArea')());
      },
   }
);
var sq = new Square(10);
sq.getArea(); // size is : 100
console.log(sq.super('getArea')()); // 100