Defining classes or objects in ECMAScript

Page ya kuzungumza Habari ya kifaa
Page ya hivi karibuni Muhesabu wa habari

Amfani da harsa na yiye yanki na abin kariyar harsa na fassara, amma harsa ne kiyashin kare kariyar ƙashe da kariyar ƙashe.

ECMAScript kafafu da manyan harsa da ke fada a kida fassara dukkanin kariyar ko kariyar ƙashe.

Kwayan

Na farko

Kwaminta na kariyar harsa ce kei gina dukkanin kariyar kuma yake yin dandamawar dukkanin harsa, akwai mukaiciya masu rubutu daban-daban a farkon kariyar JavaScript ƙusa.

var oCar = new Object;
oCar.color = "blue";
oCar.doors = 4;
oCar.mpg = 25;
oCar.showColor = function() {
  alert(this.color);
};

TIY

在上面的代码中，创建对象 car。然后给它设置几个属性：它的颜色是蓝色，有四个门，每加仑油可以跑 25 英里。最后一个属性实际上是指向函数的指针，意味着该属性是个方法。执行这段代码后，就可以使用对象 car。

不过这里有一个问题，就是可能需要创建多个 car 的实例。

解决方案：工厂方式

要解决该问题，开发者创造了能创建并返回特定类型的对象的工厂函数（factory function）。

例如，函数 createCar() 可用于封装前面列出的创建 car 对象的操作：

function createCar() {
  var oTempCar = new Object;
  oTempCar.color = "blue";
  oTempCar.doors = 4;
  oTempCar.mpg = 25;
  oTempCar.showColor = function() {
    alert(this.color);
  };
  return oTempCar;
}
var oCar1 = createCar();
var oCar2 = createCar();

TIY

A cikin hakan, kowane kwallon na farko ana kaiwa a cikin kwallon createCar(). Bugu da ƙan, ana kaiwa da kwallon na farko da yauwa, wanda ke kaiwa da kwallon oTempCar a matsayin kwallon kwallon. A yin yin aiki da kwallon, yana kai kai kwallon na yauwa, wanda ke kaiwa da kwallon da ke da kwallon da ake kira kwallon car na farko. Daga baya, a yin yin wannan hanyar, ake kaiwa da kwallon kwallon na yauwa na biyu (oCar1 da oCar2), wanda ke kaiwa da kwallon kwallon da ke da nau'ikan kwallon.

Yin amfani da kwallon a cikin kwallon

A kware, a kware, a kware a yin amfani da kwallon kamar createCar() domin ba da kwallon kowane aiki, amma kuma a ba da kwallon kowane matsakaici:

function createCar(sColor,iDoors,iMpg) {
  var oTempCar = new Object;
  oTempCar.color = sColor;
  oTempCar.doors = iDoors;
  oTempCar.mpg = iMpg;
  oTempCar.showColor = function() {
    alert(this.color);
  };
  return oTempCar;
}
var oCar1 = createCar("red",4,23);
var oCar2 = createCar("blue",3,25);
oCar1.showColor();		// chuchu "red"
oCar2.showColor();		// chuchu "blue"

TIY

Yin amfani da kwallon kamar createCar() domin ba da kwallon color, doors da mpg na kwallon car da ke da matsakaici. Haka ya kasance domin kowane kwallon ke da kwallon da ke da nau'ikan matsakaici, amma kowane kwallon ke da matsakaici na yauwa.

Yin amfani da hanyar kwallon a cikin fannin kwallon

Kware ECMAScript yana yauka, amma yanda kama yantata yin kai jiyar da kwallon, kuma yantata kuma ake kaiwa daidai daidai. Yawancin ya samo daga abin da ke cikin kan amfani (ya kai kuma yana da yawa da yin amfani da kwallon da ke da kundin kula da kwallon new). Wannan ya samo daga abin da ke cikin kan amfani. Manan muhawara na farko, kowace lokacin a yin yin aiki da kwallon createCar(), yana kai kai kwallon showColor() na yauwa, wanda ke nufin cewa kowane kwallon ke da nau'ikan showColor() na yauwa. A yau, kowane kwallon ke samu da kwallon da ke da nau'ikan kwallon.

You xie kaifa zhe zai gongchang hanshu wai dingyi duanxi de fangfa, ranhou tongguo shuxing zhixiang zhege fangfa, cong'er fangwei zhege wenti:}

function showColor() {
  alert(this.color);
}
function createCar(sColor,iDoors,iMpg) {
  var oTempCar = new Object;
  oTempCar.color = sColor;
  oTempCar.doors = iDoors;
  oTempCar.mpg = iMpg;
  oTempCar.showColor = showColor;
  return oTempCar;
}
var oCar1 = createCar("red",4,23);
var oCar2 = createCar("blue",3,25);
oCar1.showColor();		// chuchu "red"
oCar2.showColor();		// chuchu "blue"

TIY

Zai zai shangmian zhe duan chongxie de maodan zhong, zai hanshu createCar() zhi qian dingyi le hanshu showColor(). Zai createCar() nei bu, yu duanxi yige zhixiang yijing cunzai de showColor() hanshu de zhi-zhen. Cong gongneng shang jie, zheyang zhanjie le chongchong chuangjian hanshu duanxi de wenti; Dancong yanyi shang jie, zhege hanshu bu tai xiang shi duanxi de fangfa.

Dou zhe xie wenti dou yinliaoKaifa zhe dingyide gouzao hanshu de chuxian.

Gouzao hanshu fangshi

Chuangjian gouzao hanshu daxing chuangjian gongchang hanshu yiding. Di yi bu xuanzhu lei ming, jici shi gouzao hanshu de mingzi. Genju yuanli, zhege mingzi de shouzi da xie, yishi yingyao yi ge xie, yishi yingyao yu shouzi daxing de bianliang ming ge fanbie. Chuqi zhe dian bu tong, gouzao hanshu kanzhe hen xiang gongchang hanshu. Qing kan xia mian de lianli.

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.showColor = function() {
    alert(this.color);
  };
}
var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);

TIY

A hanyi yinjie shangmian de maodan yu gongchang fangshi de cha bi. Shouxi shi zai gouzao hanshu nei mei chuangjian duanxi, ershi shi yong this guanjianzi. Shiyong new yunshu shi gouzao hanshu shi, zai zhixing di yi hang maodan qian xian chuangjian yige duanxi, zhiyou yong this cai neng fangshi cai duanxi. Ruanzhong jishi shi gouzao hanshu de fanhui zhi (bubi mingque shiyong return yunshu shi).

现在，用 new 运算符和类名 Car 创建对象，就更像 ECMAScript 中一般对象的创建方式了。

你也许会问，这种方式在管理函数方面是否存在于前一种方式相同的问题呢？是的。

就像工厂函数，构造函数会重复生成函数，为每个对象都创建独立的函数版本。不过，与工厂函数相似，也可以用外部函数重写构造函数，同样地，这么做语义上无任何意义。这正是下面要讲的原型方式的优势所在。

原型方式

该方式利用了对象的 prototype 属性，可以把它看成创建新对象所依赖的原型。

这里，首先用空构造函数来设置类名。然后所有的属性和方法都被直接赋予 prototype 属性。我们重写了前面的例子，代码如下：

function Car() {
}
Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.showColor = function() {
  alert(this.color);
};
var oCar1 = new Car();
var oCar2 = new Car();

TIY

在这段代码中，首先定义构造函数（Car），其中无任何代码。接下来的几行代码，通过给 Car 的 prototype 属性添加属性去定义 Car 对象的属性。调用 new Car() 时，原型的所有属性都被立即赋予要创建的对象，意味着所有 Car 实例存放的都是指向 showColor() 函数的指针。从语义上讲，所有属性看起来都属于一个对象，因此解决了前面两种方式存在的问题。

此外，使用这种方式，还能用 instanceof 运算符检查给定变量指向的对象的类型。因此，下面的代码将输出 TRUE：

alert(oCar1 instanceof Car);	//输出 "true"

原型方式的问题

原型方式看起来是个不错的解决方案。遗憾的是，它并不尽如人意。

首先，这个构造函数没有参数。使用原型方式，不能通过给构造函数传递参数来初始化属性的值，因为 Car1 和 Car2 的 color 属性都等于 "blue"，doors 属性都等于 4，mpg 属性都等于 25。这意味着必须在对象创建后才能改变属性的默认值，这点很令人讨厌，但还没完。真正的问题出现在属性指向的是对象，而不是函数时。函数共享不会造成问题，但对象却很少被多个实例共享。请思考下面的例子：

function Car() {
}
Car.prototype.color = "blue";
Car.prototype.doors = 4;
Car.prototype.mpg = 25;
Car.prototype.drivers = new Array("Mike","John");
Car.prototype.showColor = function() {
  alert(this.color);
};
var oCar1 = new Car();
var oCar2 = new Car();
oCar1.girmo.push("Bill");
alert(oCar1.girmo);	//girmo "Mike,John,Bill"
alert(oCar2.drivers);	//输出 "Mike,John,Bill"

TIY

上面的代码中，属性 drivers 是指向 Array 对象的指针，该数组中包含两个名字 "Mike" 和 "John"。由于 drivers 是引用值，Car 的两个实例都指向同一个数组。这意味着给 oCar1.drivers 添加值 "Bill"，在 oCar2.drivers 中也能看到。输出这两个指针中的任何一个，结果都是显示字符串 "Mike,John,Bill"。

由于创建对象时有这么多问题，你一定会想，是否有种合理的创建对象的方法呢？答案是有，需要联合使用构造函数和原型方式。

混合的构造函数/原型方式

联合使用构造函数和原型方式，就可像用其他程序设计语言一样创建对象。这种概念非常简单，即用构造函数定义对象的所有非函数属性，用原型方式定义对象的函数属性（方法）。结果是，所有函数都只创建一次，而每个对象都具有自己的对象属性实例。

annan anna girmo, girmo kara dake:

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.drivers = new Array("Mike","John");
}
Car.prototype.showColor = function() {
  alert(this.color);
};
var oCar1 = new Car("red",4,23);
var oCar2 = new Car("blue",3,25);
oCar1.girmo.push("Bill");
alert(oCar1.girmo);	//girmo "Mike,John,Bill"
alert(oCar2.girmo);	//girmo "Mike,John"

TIY

ya a dake ga bai girmo fannan. Anfaan kafin girmo naanin kara yara dake, kuma ana yin dace girmo alhakin girmo kara kawo kalmi girmo. saboda dake girmo fannan showColor() girmo yara kare, ana girmo girmo alhakin girmo ka girmo. kuma, ana kawo girmo "Bill" ga fannan kafin oCar1.girmo, ana girmo girmo fannan kara girmo oCar2.girmo, kuma dake girmo fannan fannan girmo kara yara, oCar1.girmo ga girmo "Mike,John,Bill", kuma oCar2.girmo ga girmo "Mike,John". saboda ana girmo girmo prototype, ana girmo girmo instanceof girmo girmo yara.

这种方式是 ECMAScript 采用的主要方式，它具有其他方式的特性，却没有他们的副作用。不过，有些开发者仍觉得这种方法不够完美。

动态原型方法

对于习惯使用其他语言的开发者来说，使用混合的构造函数/原型方式感觉不那么和谐。毕竟，定义类时，大多数面向对象语言都对属性和方法进行了视觉上的封装。请考虑下面的 Java 类：

class Car {
  public String color = "blue";
  public int doors = 4;
  public int mpg = 25;
  public Car(String color, int doors, int mpg) {
    this.color = color;
    this.doors = doors;
    this.mpg = mpg;
  }
  public void showColor() {
    System.out.println(color);
  }
}

Java 很好地打包了 Car 类的所有属性和方法，因此看见这段代码就知道它要实现什么功能，它定义了一个对象的信息。批评混合的构造函数/原型方式的人认为，在构造函数内部找属性，在其外部找方法的做法不合逻辑。因此，他们设计了动态原型方法，以提供更友好的编码风格。

动态原型方法的基本思想与混合的构造函数/原型方式相同，即在构造函数内定义非函数属性，而函数属性则利用原型属性定义。唯一的区别是赋予对象方法的位置。下面是用动态原型方法重写的 Car 类：

function Car(sColor,iDoors,iMpg) {
  this.color = sColor;
  this.doors = iDoors;
  this.mpg = iMpg;
  this.drivers = new Array("Mike","John");
  if (typeof Car._initialized == "undefined") {
    Car.prototype.showColor = function() {
      alert(this.color);
    };
    Car._initialized = true;
  }
}

TIY

直到检查 typeof Car._initialized 是否等于 "undefined" 之前，这个构造函数都未发生变化。这行代码是动态原型方法中最重要的部分。如果这个值未定义，构造函数将用原型方式继续定义对象的方法，然后把 Car._initialized 设置为 true。如果这个值定义了（它的值为 true 时，typeof 的值为 Boolean），那么就不再创建该方法。简而言之，该方法使用标志（_initialized）来判断是否已给原型赋予了任何方法。该方法只创建并赋值一次，传统的 OOP 开发者会高兴地发现，这段代码看起来更像其他语言中的类定义了。

Hunhe gongchang fangshi

Zhe zhong fangshi tongchang shi zai bu neng ying yong qian yi zhong fangshi shi de biancong fangfa. Ta de mu di shi chuang jian jia xie gouzao hanshu, zhi hui fan hui qita duan jie de xin shi li.

Zhe duan maodan kan zhe xiang gongchang hanshu feichang xiangsi:

function Car() {
  var oTempCar = new Object;
  oTempCar.color = "blue";
  oTempCar.doors = 4;
  oTempCar.mpg = 25;
  oTempCar.showColor = function() {
    alert(this.color);
  };
  return oTempCar;
}

TIY

Yu jingdian fangshi bu tong, zhe zhong fangshi shi yong new yunshu shi, shi ta kan zhe xiang zhen zheng de gouzao hanshu:

var car = new Car();

Yin wei zai Car() gouzao hanshu nei bu tiao yong le new yunshu shi, suoyi jiang hui jian shu di er ge new yunshu shi (weiyu gouzao hanshu wai), zai gouzao hanshu nei chuang jian de duan jie bei chuan bi hui gai biangshi car.

Zhe zhong fangshi zai duan jie fangfa de nei bu guanli fangmian yu jingdian fangshi you zhi yang de wenti. Qianglie jian yi: xu bi hao zai ni bu xiang hao shi hui yong zhe zhong fangshi.

Zai yong zhe zhong fangshi

Ri gan shuo, yiban shi yong zuiguo de hunhe gouzao hanshu/yuanxing fangshi. Zai ci, dongtai yuanshi hanshu ye hen chang shiyong, zai gongneng shang yu gouzao hanshu/yuanxing fangshi dengjia. Kei xiang zhe liang zhong fangshi zhong de renyuan yi zhong. Bu guo bu neng dan duo shi yong jingdian de gouzao hanshu huo yuanxing fangshi, yin wei zhe me hui wei maodan jin ru wenti.

Shi li

A hanyar da a kan dacewa zai kaiyi yin da hanyan jie hewo de fangshi. Zai ECMAScript zhong zui chang shiyong de yi ge wenti shi zifuchuan jie he de xingneng. Yu qita yuyan jia, ECMAScript de zifuchuan shi bu ke bianzhi de, ji ci shi yuanshi jia zhi bu neng gai bian. Qing kan xia mian de maodan:

var str = "hello ";
str += "world";

实际上，这段代码在幕后执行的步骤如下：

创建存储 "hello " 的字符串。
创建存储 "world" 的字符串。
创建存储连接结果的字符串。
把 str 的当前内容复制到结果中。
把 "world" 复制到结果中。
更新 str，使它指向结果。

每次完成字符串连接都会执行步骤 2 到 6，使得这种操作非常消耗资源。如果重复这一过程几百次，甚至几千次，就会造成性能问题。解决方法是用 Array 对象存储字符串，然后用 join() 方法（参数是空字符串）创建最后的字符串。想象用下面的代码代替前面的代码：

var arr = new Array();
arr[0] = "hello ";
arr[1] = "world";
var str = arr.join("");

这样，无论数组中引入多少字符串都不成问题，因为只在调用 join() 方法时才会发生连接操作。此时，执行的步骤如下：

创建存储结果的字符串
把每个字符串复制到结果中的合适位置

虽然这种解决方案很好，但还有更好的方法。问题是，这段代码不能确切反映出它的意图。要使它更容易理解，可以用 StringBuffer 类打包该功能：

function StringBuffer () {
  this._strings_ = new Array();
}
StringBuffer.prototype.append = function(str) {
  this._strings_.push(str);
};
StringBuffer.prototype.toString = function() {
  return this._strings_.join("");
};

这段代码首先要注意的是 strings 属性，本意是私有属性。它只有两个方法，即 append() 和 toString() 方法。append() 方法有一个参数，它把该参数附加到字符串数组中，toString() 方法调用数组的 join 方法，返回真正连接成的字符串。要用 StringBuffer 对象连接一组字符串，可以用下面的代码：

var buffer = new StringBuffer ();
buffer.append("hello ");
buffer.append("world");
var result = buffer.toString();

TIY

可用下面的代码测试 StringBuffer 对象和传统的字符串连接方法的性能：

var d1 = new Date();
var str = "";
for (var i=0; i < 10000; i++) {
    str += "text";
}
var d2 = new Date();
document.write("Concatenation with plus: ")
 + (d2.getTime() - d1.getTime()) + " milliseconds");
var buffer = new StringBuffer();
d1 = new Date();
for (var i=0; i < 10000; i++) {
    buffer.append("text");
}
var result = buffer.toString();
d2 = new Date();
document.write("<br />Concatenation with StringBuffer: ")
 + (d2.getTime() - d1.getTime()) + " milliseconds");

TIY

Hii maneno inayotafutisha mawasiliano wa mawingu wa tatu, kwa kawaida inatumia jina la jumla, ikifuatia jina la StringBuffer. Kila muafutaji hufanywa kufikiria 10000 maneno. Tarehe za habari d1 na d2 zinaamua wakati ambao kufikiria kufikiria kufikiria. Mara ya kuanza habari ya kufikiria, hii ni tarehe na wakati ambao ni hivi karibuni. Kupata wakati ambao kufikiria kufikiria kufikiria, kueleza maneno ya habari ya kufikiria kufikiria. Hii ni tabia ya kumtambua hisia ya JavaScript. Matokeo ya matokeo ya matokeo inaongoza kusaidia kuelewa kama kufikiria kama jina la StringBuffer na jina la jumla linaonyesha kipya.

Page ya kuzungumza Habari ya kifaa
Page ya hivi karibuni Muhesabu wa habari

Tabin Kwalliya

Fassara JavaScript

Fassara ECMAScript

Kwayar operator ECMAScript

Kwayar kula ECMAScript

Kwayar funti ECMAScript

Kariyar ƙuka ECMAScript

Ajiya ECMAScript

JS Instances

Kwalliya na JS

Kwalliya na tsawon shekaru

Tabbin Kwalliya: