ການກໍ່ສ້າງບັນດາບັນດາຫລາຍຄວາມຂອງ ECMAScript
- ຫນ້າທີ່ຫຼັງ ຂອບເຂດວັດຖຸ
- ຫນ້າທີ່ໜ້າ ການດັດແກ້ວັດຖຸ
ການນໍາໃຊ້ບັນດາວັດຖຸກ່ອນການນຳໃຊ້ຂອງພາສາປະເພດອອກອານານິຄົມພຽງແຕ່ສ່ວນຫນື່ງຂອງພາສາປະເພດອອກອານານິຄົມ ແຕ່ວິທີທີ່ມີຄວາມອິດສະຫຼະທີ່ສົມບູນຂອງພວກເຂົາແມ່ນການສ້າງວິນຍານຫຼືວັດຖຸສໍາລັບຕົວເອງ.
ECMAScript ມີຫຼາຍວິທີການສ້າງບັນດາວັດຖຸຫຼືວິນຍານ.
ວິທີການສະຖານີ
ວິທີການຕົ້ນຕົ້ນ
ຍ້ອນວ່າລະບຽບຂອງບັນດາວັດຖຸສາມາດຖືກກຳນົດຫຼາຍຢ່າງຫຼັງຈາກການສ້າງວັດຖຸຫຼັງຈາກການນໍາໃຊ້ JavaScript ໃນຊ່ວງການນຳໃຊ້ຂອງພວກເຂົາຫຼາຍຈະເຮັດການຂຽນລະຫັດດັ່ງລຽງກ່າວນີ້:
var oCar = new Object;
oCar.color = "blue";
oCar.doors = 4;
oCar.mpg = 25;
oCar.showColor = function() {
alert(this.color);
};
在上面的代码中，创建对象 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();
ໃນບ່ອນນີ້, ທຸກຄຳລັກສະນະທີ່ມີໃນການກໍານົດຄືນທີ່ຄືນທີ່ກໍານົດຂື້ນກັບການປະຕິບັດ createCar() ແລະຍັງມີຄຳປະຕິບັດອື່ນໆອີກໜຶ່ງກັນ, ທີ່ຈະກັບຄືນອຸປະກອນ car ທີ່ຈະສ້າງຄືນໃໝ່ແລະໃຫ້ມີທຸກຄວາມຜິດປົກກະຕິການທີ່ຈະຖືກສັບສົນກັບອຸປະກອນ car ທີ່ພົບພາຍໃນການກໍານົດກ່ອນນີ້. ເນື່ອງຈາກນັ້ນ, ດ້ວຍວິທີນີ້ພວກເຮົາສາມາດສ້າງອຸປະກອນ car ສອງບັນດາບັນດາທີ່ຈະມີທຸກຄວາມຜິດປົກກະຕິການທີ່ຄືກັນຫຼາຍກວ່າຫຼາຍຄັ້ງອິດທິພົນ.
ການສົ່ງຄຳປະຕິບັດໃຫ້ການປະຕິບັດວິທີ.
ພວກເຮົາຍັງສາມາດປັບປຸງການປະຕິບັດ createCar() ໃຫ້ຈະສົ່ງຄຳປະຕິບັດຕ່າງໆໃຫ້ມີຄວາມຜິດປົກກະຕິການທີ່ຄືກັນ, ແຕ່ບໍ່ພຽງແຕ່ຈະສ້າງຄວາມຜິດປົກກະຕິການທີ່ຄືກັນ.
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(); //输出 "red"
oCar2.showColor(); //输出 "blue"
ການໃຫ້ຄຳປະຕິບັດ createCar() ຂອບຄຳປະຕິບັດໃຫ້ຜົນຄຳປະຕິບັດອຸປະກອນ car ທີ່ຈະມີຄວາມຜິດປົກກະຕິການທີ່ຄືກັນຫຼາຍກວ່າຫຼາຍຄັ້ງອິດທິພົນຫຼາຍກວ່າຫຼາຍຄັ້ງອິດທິພົນຫຼາຍກວ່າຫຼາຍຄັ້ງອິດທິພົນຫຼາຍກວ່າຫຼາຍຄັ້ງອິດທິພົນ.
ການປະກອບວິທີຂອງອຸປະກອນຢູ່ທາງນອກຈາກສະຫະພາບຫົວໜ້າ.
ເຖິງວ່າ ECMAScript ມີການພິມສະບາຍຫຼາຍກວ່າເກົ່າແຕ່ວິທີທີ່ຂະບວນສັນຍາສະບາຍບາງຄັ້ງຖືກປະຕິບັດຍັງບໍ່ມີຄວາມນິຍົມຕາມການວິຈານວ່າມັນບໍ່ຄືກັບການພິມສະບາຍທີ່ໃຊ້ຄວາມປະຕິບັດ new new operatorນິຍົມຫຼາຍກວ່າເກົ່າຫຼາຍກວ່າຫຼາຍຄັ້ງອິດທິພົນໃຫ້ຄວາມນິຍົມວິທີທີ່ມັນຕ້ອງຈະສ້າງອຸປະກອນພາຍໃນບົດການນັ້ນ. ຄຳໃຫ້ຄວາມນິຍົມສ່ວນໜຶ່ງແມ່ນສຳລັບຄຳວິຈານ (ມັນບໍ່ຄືກັບການພິມສະບາຍທີ່ໃຊ້ຄວາມປະຕິບັດ new new operatorນິຍົມຫຼາຍກວ່າເກົ່າ). ຄຳໃຫ້ຄວາມນິຍົມສ່ວນອື່ນໆແມ່ນສຳລັບຄວາມນິຍົມສຳລັບການສ້າງອຸປະກອນພາຍໃນບົດການນັ້ນ. ບົດການຄືນຄຽງທີ່ພົບພາຍໃນວິຊານັ້ນ, ໃນເວລາທີ່ຂໍ້ມູນກະທັກສາຍວິກາດ createCar(), ຂໍ້ມູນກະທັກສາຍວິກາດ showColor() ຈະຖືກສ້າງຄືນຫຼາຍກວ່າຄັ້ງ. ຄວາມຈິງ, ທຸກອຸປະກອນທີ່ຈະມີການໃຊ້ວິກາດ showColor() ພາຍໃນພາຍຂອງພາຍຫຼັງທີ່ມັນ.
有些开发者在工厂函数外定义对象的方法，然后通过属性指向该方法，从而避免这个问题：
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(); //输出 "red"
oCar2.showColor(); //输出 "blue"
在上面这段重写的代码中，在函数 createCar() 之前定义了函数 showColor()。在 createCar() 内部，赋予对象一个指向已经存在的 showColor() 函数的指针。从功能上讲，这样解决了重复创建函数对象的问题；但是从语义上讲，该函数不太像是对象的方法。
所有这些问题都引发了开发者定义的构造函数的出现。
构造函数方式
创建构造函数就像创建工厂函数一样容易。第一步选择类名，即构造函数的名字。根据惯例，这个名字的首字母大写，以使它与首字母通常是小写的变量名分开。除了这点不同，构造函数看起来很像工厂函数。请考虑下面的例子：
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);
下面为您解释上面的代码与工厂方式的差别。首先在构造函数内没有创建对象，而是使用 this 关键字。使用 new 运算符构造函数时，在执行第一行代码前先创建一个对象，只有用 this 才能访问该对象。然后可以直接赋予 this 属性，默认情况下是构造函数的返回值（不必明确使用 return 运算符）。
现在，用 new 运算符和类名 Car 创建对象，就更像 ECMAScript 中一般对象的创建方式了。
你也许会问，这种方式在管理函数方面是否存在于前一种方式相同的问题呢？是的。
就像工厂函数，构造函数会重复生成函数，为每个对象都创建独立的函数版本。不过，与工厂函数相似，也可以用外部函数重写构造函数，同样地，这么做语义上无任何意义。这正是下面要讲的原型方式的优势所在。
原型方式
该方式利用了对象的 prototype 属性，可以把它看成创建新对象所依赖的原型。
ບ່ອນນີ້, ກ່ອນມີຄຳຂຽນການຕັ້ງການຄຳຂຽນບໍ່ມີຄຳຂັດແຍ່ງ. ພາຍຫຼັງນັ້ນ, ຄຳຂຽນທີ່ຕໍ່ມາຈະຕິດຕັ້ງຄຳຂຽນຂອງ Car ເພື່ອການກະຈາຍຄຳຂຽນຂອງບັນດາອົງການ Car. ການເອົາ new Car() ຈະຈັດຕັ້ງຄຳຂຽນທີ່ຕິດຕັ້ງທັງໝົດຂອງພາສານາຊາຍອອກມາທີ່ຈະຈັດຕັ້ງຄຳຂຽນຂອງບັນດາອົງການ Car. ເນື່ອງຈາກນັ້ນ, ຄຳຂຽນທັງໝົດຈະຈັດຕັ້ງຄຳຂຽນຂອງບັນດາອົງການ Car, ເນື່ອງຈາກນັ້ນ, ຄຳຂຽນທັງໝົດຈະຈັດຕັ້ງຄຳຂຽນຂອງບັນດາອົງການ Car.
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();
ໃນຄຳຂຽນດັ່ງກ່າວ, ກ່ອນມີຄຳຂຽນການຕັ້ງການຄຳຂຽນບໍ່ມີຄຳຂັດແຍ່ງ. ພາຍຫຼັງນັ້ນ, ຄຳຂຽນທີ່ຕໍ່ມາຈະຕິດຕັ້ງຄຳຂຽນຂອງ Car ເພື່ອການກະຈາຍຄຳຂຽນຂອງບັນດາອົງການ Car. ການເອົາ new Car() ຈະຈະຈັດຕັ້ງຄຳຂຽນທີ່ຕິດຕັ້ງທັງໝົດຂອງພາສານາຊາຍອອກມາທີ່ຈະຈັດຕັ້ງຄຳຂຽນຂອງບັນດາອົງການ Car. ເນື່ອງຈາກນັ້ນ, ຄຳຂຽນທັງໝົດຈະຈັດຕັ້ງຄຳຂຽນຂອງບັນດາອົງການ Car, ເນື່ອງຈາກນັ້ນ, ຄຳຂຽນທັງໝົດຈະຈັດຕັ້ງຄຳຂຽນຂອງບັນດາອົງການ Car.
ນອກຈາກນັ້ນ, ການໃຊ້ວິທີການ 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.drivers.push("Bill");
alert(oCar1.drivers); //ອອກສະພາບ "Mike,John,Bill"
alert(oCar2.drivers); //输出 "Mike,John,Bill"
上面的代码中，属性 drivers 是指向 Array 对象的指针，该数组中包含两个名字 "Mike" 和 "John"。由于 drivers 是引用值，Car 的两个实例都指向同一个数组。这意味着给 oCar1.drivers 添加值 "Bill"，在 oCar2.drivers 中也能看到。输出这两个指针中的任何一个，结果都是显示字符串 "Mike,John,Bill"。
ຍ້ອນວ່າມີຫລາຍບັນຫາທີ່ກ່ຽວກັບການສ້າງອຸປະກອນ, ທ່ານຈະຕ້ອງການຈະຖາມວ່າມີວິທີການສ້າງອຸປະກອນທີ່ມີຄວາມມີປະສິດທິພາບຫນັງການສ້າງອຸປະກອນຫນັງການສ້າງອຸປະກອນຫນັງການສ້າງອຸປະກອນ. ຄຳຕອບຢູ່ວ່າມີ, ຕ້ອງການປະສົມປະສານພາສາຫຼັກສັບ/ການສ້າງສະເພາະ.
ການປະສົມປະສານພາສາຫຼັກສັບ/ການສ້າງສະເພາະ
ການປະສົມປະສານພາສາຫຼັກສັບ/ການສ້າງສະເພາະ, ພວກເຮົາສາມາດສ້າງອຸປະກອນເປັນການຄ້າຍຄືກັບພາສາຫຼັກສັບຄົນອື່ນໆ. ຄວາມຄິດນີ້ມີຄວາມງ່າຍ, ເພື່ອການຈັດວັດສະນະພາສາຫຼັກສັບທຸກພາສາທີ່ບໍ່ແມ່ນພາສາຫຼັກສັບສັບການ, ແລະໃຊ້ວິທີການສ້າງສະເພາະສຳລັບພາສາຫຼັກສັບສັບການ. ຜົນທີ່ມາແມ່ນວ່າພາສາຫຼັກສັບທຸກພາສາຫຼັກສັບສ້າງພຽງຫນຶ່ງຄັ້ງ, ແລະບັນດາອຸປະກອນສ້າງພາສາຫຼັກສັບທຸກພາສາຫຼັກສັບມີພາສາຫຼັກສັບຂອງພາສາຫຼັກສັບຂອງພາສາຫຼັກສັບຂອງພາສາຫຼັກສັບ.
ພວກເຮົາໄດ້ປັບປຸງຕົວຢ່າງກ່ອນ, ວິທີການງານດັ່ງຕໍ່ມາ:
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.drivers.push("Bill");
alert(oCar1.drivers); //ອອກສະພາບ "Mike,John,Bill"
alert(oCar2.drivers); //ອອກສະພາບ "Mike,John"
ປັດຈຸບັນແມ່ນກາຍເປັນການສ້າງບັນດາອຸປະກອນທົ່ວໄປ. ທຸກພາສາທີ່ບໍ່ແມ່ນພາສາຫຼັກສັບການສ້າງຂື້ນໃນພາສາຫຼັກສັບ, ໝາຍຄວາມວ່າພວກເຮົາສາມາດໃຊ້ປະສົມປະສານຂອງພາສາຫຼັກສັບສຳລັບການຈັດວັດສະນະພາສາຫຼັກສັບຂອງພາສາຫຼັກສັບ. ຍ້ອນວ່າພວກເຮົາຂື້ນການສ້າງພາສາຫຼັກສັບຂອງພາສາຫຼັກສັບ showColor() ພຽງຫນຶ່ງຄັ້ງ, ບໍ່ມີການສູນຫາຍຄວາມຫາຍໃນຄວາມຄິດ. ຍ້ອນວ່າການໃຫ້ຄຳວ່າ "Bill" ໃຫ້ສາຍຄົນຂອງລົດ oCar1, ຈະບໍ່ມີຜົນກະທົບຕໍ່ສາຍຄົນຂອງລົດ oCar2, ດັ່ງນັ້ນເມື່ອການອອກສະພາບສາຍຄົນສາຍຄົນຈະສະແດງ "Mike,John,Bill" ສຳລັບ oCar1.drivers, ແລະ "Mike,John" ສຳລັບ oCar2.drivers. ຍ້ອນວ່າພວກເຮົາໃຊ້ວິທີການສະແດງສະເພາະ, ພວກເຮົາຍັງສາມາດໃຊ້ວິທີການ instanceof ເພື່ອບັນທຶກຕົວລະຫວ່າງອຸປະກອນ.
ວິທີການນີ້ແມ່ນວິທີການທີ່ ECMAScript ມີຫຼາຍຢ່າງ, ທີ່ມີຄວາມຜົນງານຂອງວິທີການອື່ນໆ, ແຕ່ບໍ່ມີຜົນກະທົບທີ່ຫຼວງຫຼາຍ. ແຕ່ຍັງມີນັກພັດທະນາທີ່ຮູ້ສຶກວ່າວິທີການນີ້ບໍ່ສະຫລຸບຢ່າງສົມບູນ.
ວິທີການປະກອບຕົວຕົນດູດບົນ
ສິ່ງທີ່ນັກພັດທະນາພົບພາຍໃນພາສາອື່ນໆຈະຮູ້ສຶກວ່າວິທີການປະກອບຕົວຕົນ/ການພົບກັບສາຍວິທີປະກອບຕົວຕົນບໍ່ສະຫລຸບຢ່າງຫຼວງຫຼາຍ. ຕົວຢ່າງ, ເວລາທີ່ກໍານົດປະກອບຕົວຕົນ, ສິ່ງທີ່ສ່ວນຫຼາຍພາສາປະກອບຕົວຕົນປົກກະຕິຈະປະກອບຕົວຕົນວິທີການ ແລະ ວິທີການ. ຍັງມີຄວາມຄິດຂອງວິທີການປະກອບຕົວຕົນດູດບົນບາດບອກວ່າ, ພວກມັນຈະປະກອບຕົວຕົນບາດບອກວ່າຈະປະກອບຕົວຕົນ
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 ບັນດາວິທີການບາດບອກວ່າວ່າຈະປະກອບຕົວຕົນບາດບອກວ່າວ່າຈະປະກອບຕົວຕົນບາດບອກວ່າຈະປະກອບຕົວຕົນບາດບອກວ່າຈະປະກອບຕົວຕົນ
ຄວາມຄິດຂອງວິທີການປະກອບຕົວຕົນດູດບົນບາດບອກກັບວິທີການປະກອບຕົວຕົນ/ການພົບກັບສາຍວິທີປະກອບຕົວຕົນບາດບອກວ່າວ່າພວກມັນຈະຖືກປະກອບຕົວຕົນບາດບອກວ່າວ່າພວກມັນຈະຖືກປະກອບຕົວຕົນບາດບອກວ່າວ່າພວກມັນຈະຖືກປະກອບຕົວຕົນບາດບອກວ່າວ່າພວກມັນຈະຖືກປະກອບຕົວຕົນ
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;
}
}
直到检查 typeof Car._initialized 是否等于 "undefined" 之前，这个构造函数都未发生变化。这行代码是动态原型方法中最重要的部分。如果这个值未定义，构造函数将用原型方式继续定义对象的方法，然后把 Car._initialized 设置为 true。如果这个值定义了（它的值为 true 时，typeof 的值为 Boolean），那么就不再创建该方法。简而言之，该方法使用标志（_initialized）来判断是否已给原型赋予了任何方法。该方法只创建并赋值一次，传统的 OOP 开发者会高兴地发现，这段代码看起来更像其他语言中的类定义了。
ວິທີການກໍ່ສ້າງ/ຕົວຕົນປະສົມ
ວິທີທີ່ນີ້ຈະຖືກໃຊ້ຄືກັບວິທີທີ່ອາດບໍ່ສາມາດນຳໃຊ້ວິທີທີ່ອື່ນໆ. ວັດທີວິທີທີ່ນີ້ແມ່ນວິທີທີ່ກໍ່ສ້າງວິທີກໍ່ສ້າງພວກເຂົາດຽວ, ແລະບໍ່ພຽງພໍຫຼາຍທີ່ຈະຮັບຄືນວິທີກໍ່ສ້າງພວກເຂົາ.
ການຂຽນນີ້ຄືກັບວິທີການກໍ່ສ້າງ:
function Car() {
var oTempCar = new Object;
oTempCar.color = "blue";
oTempCar.doors = 4;
oTempCar.mpg = 25;
oTempCar.showColor = function() {
alert(this.color);
};
return oTempCar;
}
ທີ່ຕ່າງກັບວິທີທີ່ສະເພາະທີ່ພວກເຂົາເຮັດການໃຊ້ປະຕິບັດການ new, ພວກເຂົາຈະເບິ່ງຄືວິທີກໍ່ສ້າງ:
var car = new Car();
ຍ້ອນວ່າມີການເອິ້ນປະຕິບັດການ new ໃນບັນດາວັດສະດຸນ Car(), ພວກເຂົາຈະຫຼີກລຶກຄວາມສະເພາະປະຕິບັດການ new ອີກຄັ້ງ (ທີ່ຢູ່ບັນດາວັດສະດຸນພາຍໃນການກໍ່ສ້າງ), ແລະວັດສະດຸນທີ່ຖືກສ້າງໃນບັນດາວັດສະດຸນຈະຖືກສົ່ງຄືນຫາພາສາອີກທີ່ຢູ່ພາສາຂອງອີກພາສາອີກທີ່ຢູ່ບັນດາວັດສະດຸນ.
ວິທີທີ່ນີ້ມີບັນຫາທີ່ອັນຕະລາງກັບວິທີທີ່ສະເພາະທີ່ພວກເຂົາເຮັດການຈັດການພາຍໃນບັນດາວັດສະດຸນ. ບາງກັບການແນະນຳ: ຖ້າບໍ່ມີຫຼາຍການເພີ່ມເຕີມ, ຫຼາຍກັບການໃຊ້ວິທີທີ່ນີ້.
ການເລືອກວິທີທີ່ໃດ
ອີງຕາມທີ່ກ່າວກ່ອນ, ການນຳໃຊ້ທີ່ຫຼາຍທີ່ສຸດປະຈຸບັນແມ່ນວິທີການກໍ່ສ້າງ/ຕົວຕົນ. ບໍ່ພຽງພໍ, ການນຳໃຊ້ວິທີກໍ່ສ້າງ/ຕົວຕົນດຽວທີ່ສຸດສາມາດເຮັດໃຫ້ການບັນຫາເຂົ້າມາໃນການກະຈາຍການຂອງພວກເຂົາ.
ຄວາມລວມ
ບັນຫາທີ່ສຳຄັນຂອງບັນດາວັດສະດຸນແມ່ນວ່າບາງກັບວິທີທີ່ພວກເຂົາເຮັດຄວາມສຳຄັນຂອງພວກເຂົາ. ບັນຫາທີ່ປະຈຸບັນທີ່ປະຈຸບັນຫຼາຍທີ່ສຸດໃນ ECMAScript ແມ່ນການເພີ່ມຄຳຂອງຕາມ. ອັນຕະລາງກັບພາສາອື່ນໆ, ຄຳຂອງ ECMAScript ແມ່ນບໍ່ສາມາດປ່ຽນແປງ. ຄວາມຄິດຂອງພວກເຂົາກໍ່ຍັງຢູ່ຢູ່:
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();
ສາມາດທົດລອງຄວາມສະຫງົບຂອງ 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");
ການຂັດເຂີນຈາກການກ່ຽວກັບຄຳຂັດເຂີນ ການທົດລອງສອງຄັ້ງ: ຄັ້ງທຳອິດໃຊ້ຕາມລະຫວ່າງ, ຄັ້ງທີສອງໃຊ້ກັບປະເພດ StringBuffer. ການການປະສົມກັນທຸກຄຳຂັດເຂີນ 10000 ຄຳ. ວັດສະວັດວັນທີ d1 ແລະ d2 ຖືກນຳໃຊ້ເພື່ອກວດສອບເວລາທີ່ຈະສໍາຮອງການການປະສົມກັນ. ສະເພາະວ່າບໍ່ມີຂໍ້ມູນສຳລັບການສ້າງວັດສະວັດ, ວັດສະວັດຈະຖືກຈັດໃຫ້ເປັນວັດສະວັດວັນທີແລະເວລາປະຈຸບັນ. ເພື່ອການສໍາຮອງເວລາທີ່ຈະສໍາຮອງການປະສົມກັນ, ການຫຼຸດລົງຄວາມມືດຂອງວັດສະວັດວັນທີ (getTime() method) ຂອງວັດສະວັດຈະຖືກນຳໃຊ້. ນັ້ນແມ່ນວິທີທົດລອງຄວາມສະຫງົບຂອງ JavaScript. ຜົນຂອງການທົດລອງຈະຊ່ວຍທີ່ຈະປຽບທຽບຄວາມປະລິດຕິກຳລະດັບການນຳໃຊ້ StringBuffer ກັບການປະສົມກັນຄຳຂັດເຂີນທົບທີ່ມີຫຼາຍຫນັງ.
- ຫນ້າທີ່ຫຼັງ ຂອບເຂດວັດຖຸ
- ຫນ້າທີ່ໜ້າ ການດັດແກ້ວັດຖຸ
