ECMAScriptjavascript面向对象和原型————呱呱二如泣如诉

面向对象

1、工厂模式

function createObject(name,age){
  let obj = new Object();
  this.name = name;
  this.age = age;
  return obj;            
}
let objA = createObject('Tom',24);
let objB = createObject('Jane',23);
typeof ObjA;    //Object
typeof ObjB;    //Object
ObjA instanceof Object;
ObjA instanceof Object;
//方法缺点:不能区分对象实例,所有对象实例都由Object实例化

2、构造函数模式

function Box(name,age){
  this.name = name;
  this.age = age;     
  this.run = function (){
    return this.name + this.age;
  }  
}
function Desk(name,age){
  this.name = name;
  this.age = age;   
  this.run = function (){
    return this.name + this.age;
  }       
}
let box = new Box('Tom',24);
let desk = new Desk('Jane',23);
box instanceof Box;  //true
box instanceof Desk;  //false
desk instanceof Desk;  //true
//
//知识延伸,对象冒充
let o = new Object();
Box.call(o,'Ha',25);
o.name;

构造函数方式与原型方式变量存储的章程

ECMAScript 1

ECMAScript 2

 3、原型

  我们创建的每一个函数都来一个prototype(原型属性),这个特性是一个靶,它的用处是包含可以由特定项目的有着实例共享的特性和章程。逻辑上可这样明白:prototype通过调用构造函数而创办的好目标的原型对象。使用原型的补可以让拥有目标实例共享它所蕴藏的特性和方式。也就是说,不必在构造函数中定义对象信息,而是可以直接拿这些信息上加至原型中。(我要好的亮,通过构造函数创建的目标会活动创建一个原型对象prototype。)

function Box(){}

Box.prototype.name = ‘Lee’;  //原型属性

Box.prototype.age = 100;

Box.prototype.run = function () {  //原型方法

  return this.name + this.age + ‘运行中’;

}

说明:原型对象内之性质和方法还被实例对象同用

let box1 = new Box();

let box2 = new Box();

Object.is(box1.run,box2.run);  //true  Object.is(),判断两独变量是否相等
(等于box1.run === box2.run);

证box1和box2受的run方法都对准同一个援地址。

ECMAScript 3

当原型模式声明中,多矣点滴单特性,这简单单属性都是创建对象时自动生成的。__proto__性是实例指向原型对象的一个指南针,它的作用就是依为构造函数的原型属性constructor。通过这半个属性,就足以拜到原型里之习性与办法了。

//判断一个实例对象是否针对了原型对象,只要实例化了,会自行对的

Box.prototype.isPrototypeOf(box1);  //true    接着上面的代码

let obj = new Object();  //

Box.prototype.isPrototypeOf(obj);

 

假设实例对象中出name属性,原型对象吃呢生name属性,通过 .
访问name会打印处实例对象中之name属性。

function Box () {}

Box.prototype.name = ‘guaguaerhao’;

let box1 = new Box();

box1.name = ‘呱呱二号’;

console.log(box1.name);  //呱呱二哀号

原型模式的实行流程:

1、先找实例对象被是不是有属性,如果在,则赶回

2、如果实例对象被从未拖欠属性,则在原型对象中查找,如果在,则归

 判断实例中是不是留存属性

box1.hasOwnProperty(‘name’);  //true

(name in
box1)  //不管是原型中有name属性还是实例中来name属性,都见面回去true

认清只有原型中是否是属性

function hasPrototypeProperty(object,property){

  return !object.hasOwnProperty(property) && (property in object);

}

4、字面量原型模式

function Box () {}

Box.prototype = {

  constructor: Box,  //将原型对象的constructor强制指向回Box

  name: ‘guaguaerhao’,

  age: 24,

  run: function(){

    return this.name + this.age;

  }

}

 ps:原型中极度充分之弱点就是她的亮点,共享。原型模式开创的靶子,省略了构造函数传参,带来的败笔就是是初始化的价值都是均等的。

 5、构造函数加原型模式(构造函数和法分别,没有同种包装的感觉到,感觉特别零碎)

function Box(name,age){    //不共享的运用构造函数

  this.name = name;

  this.age = age;

  this.family = [‘爸爸’,’妈妈’,’哥哥’,’我’];

}

 Box.prototype = {    //共享的行使原型

  constructor: Box,

  run: function () {

    return this.name + this.age;

  }

}

6、动态原型模式

 function Box(name,age){

  this.name = name;

  this.age = age;

  //可是,实例化对象的当儿,每次都见面创造run()方法,浪费内存,因为他当列一个靶中还是均等的机能,没有必要,每次实例化都创造,实际上只有需要创造同糟。

  Box.prototype.run = function () {

    return this.name + this.age;

  }

}

所以

function Box(name,age){

  this.name = name;

  this.name = age;

  if(typeof this.run !== ‘function’){  //只会实例化一赖

    Box.prototype.run = function () {

      return this.name + this.age;

    }

  }

}

7、寄生构造函数(工厂模式+构造函数)

function Box(name,age){

  let obj = new Object();

  obj.name = name;

  obj.age = age;  

  obj.run = function (){

    return this.name + this.age;

  }

  return obj;

}

let obj = new Box(‘ha’,24);

obj.run();

7、寄生构造函数(工厂模式+构造函数)

function Box(name,age){

  let obj = new Object();

  obj.name = name;

  obj.age = age;  

  obj.run = function (){

    return this.name + this.age;

  }

  return obj;

}

let obj = Box(‘ha’,24);

obj.run();

 继承

1、继承是面向对象中较基本之概念,ECMAScript只支持继承:

ECMAScript 4

function Parent(){

  this.name = ‘p’;

}

function Child(){

  this.name = ‘c’;

}

//通过原型链继承,父类实例化后底靶子实例,赋值给子类型的原型属性

//new Parent()会以构造函数里的信与原型的音都交由Child

Child.prototype = new Parent();

2、对象冒充模式

为缓解引用共享以及超类型无法传参的题材,采用相同种植让借用构造函数的技能,或者成为目标冒充

function Parent(name,age){

  this.name = name;

  this.age = age;

}

//Parent.prototype.family = ‘家庭’;  //child实例无法访问

function Child(name,age){

  Parent.call(this,name,age);  //对象冒充,给父类传递参数,对象冒充只能连续构造函数中的性能,原型中的无法访问

}

let child = new Child(‘haha’,24);

child.name;

child.family;  //undefined

3、原型链加借用构造函数,组合模式

function Parent(age){

  this.age = age;

}

Parent.prototype.run = function () {  //解决了智共享

  return this.age;

}

function Child(age){

  Parent.call(this,age);

}

Child.prototype = new Parent();

(4-6勿全面,日后再次上,邪恶脸)

4、原型式继承:这种持续借助原型并根据已部分对象创建新目标,同事不必为此创造于定义类型。

//临时被转函数

function obj(o){  //o代表将要传递进入的一个目标

  function
F(){}  //F构造是一个临时新建的目标,用来囤积传递过来的靶子

  F.prototype = o;  //将o对象实例赋值给F构造的原型对象

  return new F();  //最后回来这个得传递过来的对象的目标实例

}

 

//其实F.prototype = o;就一定给 Child.prototype = new Parent();

 

//这是配面量的扬言方式,相当给var box = new Box();

var box = {

  name: ‘lee’,

  age: 100,

  family: [‘haha’,’hehe’]

}

//box1就等于new F();

var box1 = obj(box);

alert(box1.name);

box1.family.push(‘xixi’);

alert(box1.family);    //[‘haha’,’hehe’,’xixi’]

 

var box2 = obj(box);

alert(box2.family);    //[‘haha’,’hehe’,’xixi’]  //对象的援性,共享了

 

5、寄生式继承(原型式加工厂模式):

function obj(o){  //o代表将传递进入的一个靶

  function
F(){}  //F构造是一个临时新建的目标,用来储存传递过来的靶子

  F.prototype = o;  //将o对象实例赋值给F构造的原型对象

  return new F();  //最后回来这个获得传递过来的对象的目标实例

}

//寄生函数

function create(o){

  var f = obj(o);

  f.run = function () {

    return this.name;

  }

  return f;

}

var box = {

  name: ‘lee’,

  age: 100,

  family: [‘haha’,’hehe’]

}

var box1 = create(box);

alert(box1.name);

6、寄生组合继承

//临时被转函数

function obj(o){  //o代表将传递进入的一个靶

  function
F(){}  //F构造是一个现新建的目标,用来囤传递过来的靶子

  F.prototype = o;  //将o对象实例赋值给F构造的原型对象

  return new F();  //最后回到这个得传递过来的对象的目标实例

}

//寄生函数

function create(box,desk){

  var f = obj(box.prototype);

  desk.prototype = f;

  return f;

}

function Box(name,age){

  this.name = name;

  this.age = age;

}

Box.prototype.run = function(){

  return this.name + this.age + ‘运行中…’

}

function Desk(name,age){

  Box.call(this.name);

  this.age = age;

}

//通过寄生组合继承来落实连续

create(Box,Desk);  //这句话用来替代Desk.prototype = new Box()

 

let desk = new Desk(‘lee’,100);

alert(desk.run());

(1、原型链继承,2、借用构造函数继承(对象冒充继承)3、组合继承(结合前片种)4、原型式继承)

 

 

 

G

M

T

 

Detect language Afrikaans Albanian Arabic Armenian Azerbaijani Basque Belarusian Bengali Bosnian Bulgarian Catalan Cebuano Chichewa Chinese (Simplified) Chinese (Traditional) Croatian Czech Danish Dutch English Esperanto Estonian Filipino Finnish French Galician Georgian German Greek Gujarati Haitian Creole Hausa Hebrew Hindi Hmong Hungarian Icelandic Igbo Indonesian Irish Italian Japanese Javanese Kannada Kazakh Khmer Korean Lao Latin Latvian Lithuanian Macedonian Malagasy Malay Malayalam Maltese Maori Marathi Mongolian Myanmar (Burmese) Nepali Norwegian Persian Polish Portuguese Punjabi Romanian Russian Serbian Sesotho Sinhala Slovak Slovenian Somali Spanish Sundanese Swahili Swedish Tajik Tamil Telugu Thai Turkish Ukrainian Urdu Uzbek Vietnamese Welsh Yiddish Yoruba Zulu   Afrikaans Albanian Arabic Armenian Azerbaijani Basque Belarusian Bengali Bosnian Bulgarian Catalan Cebuano Chichewa Chinese (Simplified) Chinese (Traditional) Croatian Czech Danish Dutch English Esperanto Estonian Filipino Finnish French Galician Georgian German Greek Gujarati Haitian Creole Hausa Hebrew Hindi Hmong Hungarian Icelandic Igbo Indonesian Irish Italian Japanese Javanese Kannada Kazakh Khmer Korean Lao Latin Latvian Lithuanian Macedonian Malagasy Malay Malayalam Maltese Maori Marathi Mongolian Myanmar (Burmese) Nepali Norwegian Persian Polish Portuguese Punjabi Romanian Russian Serbian Sesotho Sinhala Slovak Slovenian Somali Spanish Sundanese Swahili Swedish Tajik Tamil Telugu Thai Turkish Ukrainian Urdu Uzbek Vietnamese Welsh Yiddish Yoruba Zulu          

 

 

 

Text-to-speech function is limited to 200 characters

 

  Options : History : Feedback : Donate Close