function A(x){
  this.x = x;
  this.say = function() {
   console.log(this.x + ' say');
  }
}
function B(x,y) {
  this.m = A; // 把構(gòu)造函數(shù)A作為一個(gè)普通函數(shù)引給臨時(shí)方法m()
  this.m(x); // 把當(dāng)前參數(shù)作為值傳給構(gòu)造函數(shù)A,并且執(zhí)行
  delete this.m; // 清除臨時(shí)方法
  this.y = y;
  this.call = function(){
   console.log(this.y);
  }
}
// 測(cè)試類繼承
var a = new A(1);
var b = new B(2,3);
a.say(); // 1 say
b.say(); // 2 say
b.call(); // 3

function A(x){
 this.x = x;
 this.say = function() {
  console.log(this.x + ' say');
 }
}
function B(x,y){
 this.y = y;
 A.call(this,x); // 在構(gòu)造函數(shù)B內(nèi)調(diào)用超類A,實(shí)現(xiàn)綁定，用call來(lái)實(shí)現(xiàn)借用
}
B.prototype = new A(); // 設(shè)置原型鏈，建立繼承關(guān)系
B.prototype.constructor = B; // 恢復(fù)B的原型對(duì)象的構(gòu)造函數(shù)為B,如果不操作就會(huì)指向A
B.prototype.gety = function(){ // 給類B添加新的方法
 return this.y;
}
// 測(cè)試 類繼承
var a = new A('A');
var b = new B('Bx','By');
a.say(); // A say
b.say(); // Bx say
console.log(b.gety()); // By
console.log(B.prototype.__proto__ === A.prototype); // true;
console.log(b.constructor === B); // true 這里也可以把B中的 B.prototype.constructor = B; 去除，結(jié)果為false

// 定義一個(gè)繼承函數(shù)
function extend(Sub,Sup){ // 有兩個(gè)入口參數(shù)，Sub是子類，Sup是父類
 var F = function(){}; // 建立一個(gè)臨時(shí)的構(gòu)造函數(shù)
 F.prototype = Sup.prototype; // 把臨時(shí)構(gòu)造函數(shù)的原型指向父類的原型
 Sub.prototype = new F(); // 實(shí)例化臨時(shí)類，此處相當(dāng)于把子類的原型指向父類的實(shí)例
 Sub.prototype.constructor = Sub; // 恢復(fù)子類的構(gòu)造函數(shù)
 Sub.sup = Sup.prototype; // 在子類中定義一個(gè)本地屬性存儲(chǔ)超類原型，可避免子類和超類耦合
 if(Sup.prototype.constructor === Object.prototype.constructor) { // 檢測(cè)超類構(gòu)造器是否為Object構(gòu)造器
  Sup.prototype.constructor = Sup;
 }
}
// 下面定義兩個(gè)類用來(lái)測(cè)試上面的繼承函數(shù)
function A(x,y) {
 this.x = x;
 this.y = y;
}
A.prototype.add = function() {
 return (this.x-0) + (this.y-0); // 此處-0 的目的是確保字符串類型可轉(zhuǎn)成數(shù)值型
}
A.prototype.minus = function() {
 return this.x - this.y;
}
function B(x,y) {
 A.apply(this,[x,y]);
}
// 開(kāi)始實(shí)現(xiàn)類繼承中的原型成員繼承
extend(B,A);
// 為了不與A類中的代碼耦合可以單獨(dú)為B定義一個(gè)同名的add
B.prototype.add = function() {
 return B.sup.add.call(this); // 避免代碼耦合
}
// 測(cè)試?yán)^承
var b = new B(1,2);
console.log(b.minus()); // -1
console.log(b.add()); // 3

function A(){
 this.color = 'red';
}
function B(){}
function C(){}
B.prototype = new A();
C.prototype = new B();
// 測(cè)試原型繼承
var c = new C();
console.log(c.color); // red

function Arr() {
 var a = new Array();
 return a;
}
var arr = new Arr();
arr[0] = 1;
arr[1] = 2;
console.log(arr); // [1,2]
console.log(Array.isArray(arr)); // true
console.log(arr instanceof Array); // true
console.log(arr instanceof Arr); // false

function A(){
 this.color = 'red';
}
A.prototype.say = function() {
 console.log(this.color);
}
var a = new A();
var b = {};
// 開(kāi)始拷貝
for(var item in a) {
 b[item] = a[item];
}
// 開(kāi)始測(cè)試
console.log(b.color); // red
b.say(); // red.

Function.prototype.extend = function(obj){
 for(item in obj){
  this.constructor.prototype[item] = obj[item];
 }
}
function A(){
 this.color = 'green';
}
A.prototype.say = function(){
 console.log(this.color);
}
// 測(cè)試
var b = function(){};
b.extend(new A());
b.say(); // green

Function.prototype.clone = function(obj){
 function Temp(){};
 Temp.prototype = obj;
 return new Temp();
}
function A(){
 this.color = 'purple';
}
var o = Function.clone(new A());
console.log(o.color); // purple

function A(x,y){
 this.x = x;
 this.y = y;
}
A.prototype.add = function(){
 return (this.x-0) + (this.y-0);
}
function B(x,y){
 A.call(this,x,y);
}
B.prototype = new A();
// 測(cè)試
var b = new B(2,1);
console.log(b.x); // 2
console.log(b.add()); // 3

function A(x){
 this.x = x;
}
A.prototype.hi = function(){
 console.log('hi');
}
function B(y){
 this.y = y;
}
B.prototype.hello = function(){
 console.log('hello');
}
// 給Function增加extend方法
Function.prototype.extend = function(obj) {
 for(var item in obj) {
  this.constructor.prototype[item] = obj[item];
 }
}
// 在類C內(nèi)部實(shí)現(xiàn)繼承
function C(x,y){
 A.call(this,x);
 B.call(this,y);
};
C.extend(new A(1));
C.extend(new B(2));
// 通過(guò)復(fù)制繼承后，C變成了一個(gè)對(duì)象，不再是構(gòu)造函數(shù)了，可以直接調(diào)用
C.hi(); // hi
C.hello(); // hello
console.log(C.x); // 1
console.log(C.y); // 2

// 定義一個(gè)摻元類
function F(x,y){
 this.x = x;
 this.y = y;
}
F.prototype = {
 getx:function(){
  return this.x;
 },
 gety:function(){
  return this.y;
 }
}
// 原型拷貝函數(shù)
function extend(Sub,Sup){ // Sub 子類 ， Sup 摻元類
 for(var item in Sup.prototype){
  if(!Sub.prototype[item]){ // 如果子類沒(méi)有存在同名成員
   Sub.prototype[item] = Sup.prototype[item]; // 那么復(fù)制摻元類成員到子類原型對(duì)象中
  }
 }
}
// 定義兩個(gè)子類 A,B
function A(x,y){
 F.call(this,x,y);
}
function B(x,y){
 F.call(this,x,y);
}
// 調(diào)用extend函數(shù)實(shí)現(xiàn)原型屬性，方法的拷貝
extend(A,F);
extend(B,F);
console.log(A.prototype);
// 測(cè)試?yán)^承結(jié)果
var a = new A(2,3);
console.log(a.x); // 2
console.log(a.getx()); // 2
console.log(a.gety()); // 3
var b = new B(1,2);
console.log(b.x); // 1
console.log(b.getx()); // 1
console.log(b.gety()); // 2