ECMAScript क्लास या ऑब्जैक्ट वर्णन

पूर्व-परिभाषित वस्तु का उपयोग केवल आधारभूत आधारभूत भाषा की क्षमता का एक हिस्सा है, इसकी वास्तविक शक्ति अपने अनुवर्ती वर्गों और वस्तुओं को बनाने की क्षमता में निहित है।

ECMAScript के पास वस्तु बनाने या वर्गों के लिए कई तरीके हैं。

फैक्टरी तरीका

मूल तरीका

क्योंकि वस्तु की विशेषताएं वस्तु बनाने के बाद गतिशील रूप से परिभाषित की जा सकती हैं, इसलिए कई डेवलपरों ने JavaScript के प्रारंभिक शुरूआती समय में नीचे दिए गए कोड की तरह कोड लिखा है:

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

在这里，第一个例子中的所有代码都包含在 createCar() 函数中。此外，还有一行额外的代码，返回 car 对象（oTempCar）作为函数值。调用此函数，将创建新对象，并赋予它所有必要的属性，复制出一个我们在前面说明过的 car 对象。因此，通过这种方法，我们可以很容易地创建 car 对象的两个版本（oCar1 和 oCar2），它们的属性完全一样。

为函数传递参数

我们还可以修改 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"

TIY

createCar() फ़ंक्शन को पैरामीटर देकर, कार वस्तु के color, doors और mpg गुणों को आवंटित कर सकते हैं। इससे दो वस्तुओं को एक साथ गुण दिए जा सकते हैं, लेकिन उनके गुणों के मान अलग-अलग हो सकते हैं。

फैक्टरी फ़ंक्शन के बाहर वस्तु के तरीकों को परिभाषित करें

हालांकि ECMAScript ज्यादा औपचारिक हो रहा है, लेकिन वस्तु का निर्माण करने के तरीके को अनदेखा कर दिया गया है और इसका नियमन अभी भी विरोध के साथ जुड़ा हुआ है। एक हिस्सा अर्थात्मक कारणों के कारण (यह नया कार्यक्रम के साथ बनाया गया नहीं है), एक हिस्सा तकनीकी कारणों के कारण। तकनीकी कारण इस तरीके से वस्तु का निर्माण करने के लिए हैं। पहले उदाहरण में, हर बार के बाद जब 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"

TIY

इस तरह के पुनर्लिखित कोड में, 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);

TIY

इसमें आपको उपरोक्त कोड और फैक्टरी तरीके के बीच का अंतर स्पष्ट किया जाएगा। पहले सबसे पहले कन्स्ट्रक्टर में कोई ऑब्जेक्ट नहीं बनाया गया है, बल्कि this की चिह्न का उपयोग किया गया है। new ऑपरेटर के साथ कन्स्ट्रक्टर को बनाने के समय, पहले से आगे के कोड को चलाने से पहले एक ऑब्जेक्ट बनाया जाता है, तभी this के द्वारा उस ऑब्जेक्ट की पहुंच होती है। फिर this की गुणों को सीधे आवंटित किया जा सकता है, मूलभूत रूप से यह कन्स्ट्रक्टर का वापसी है (return ऑपरेटर का उपयोग नहीं करना पड़ता है)।

अब, new ऑपरेटर और Car कार्यक्रम के नाम के साथ वस्तु को बनाना ECMAScript में सामान्य वस्तु के निर्माण के तरीके के समान है।

आपको इसका प्रश्न हो सकता है कि इस तरीके में फ़ंक्शन के प्रबंधन की समस्या पहले के तरीके के समान क्या है? हाँ।

इसके समान फैक्टरी फ़ंक्शन, बनाने का कार्यक्रम फ़ंक्शन को बार-बार बनाता है, प्रत्येक वस्तु के लिए स्वतंत्र फ़ंक्शन संस्करण को बनाता है। लेकिन, फैक्टरी फ़ंक्शन के समान, बाहरी फ़ंक्शन को बनाने का कार्यक्रम को भी बदला जा सकता है, लेकिन इसका अर्थवान कोई नहीं है। यही जो अगले में बताने वाले प्रारूप तरीका का लाभ है。

प्रारूप तरीका

यह तरीका वस्तु के 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 के प्रारूप गुण को जोड़कर 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.drivers.push("Bill");
alert(oCar1.drivers);	//आउटपुट "Mike,John,Bill"
alert(oCar2.drivers);	//आउटपुट "Mike,John,Bill"

TIY

ऊपरी कोड में, अटिविटी 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"

TIY

अब यह सामान्य ऑब्जेक्ट के निर्माण के लिए ज्यादा लगता है। सभी गैर-फ़ंक्शन अटिविटी को कंस्ट्रक्टर में बनाया जाता है, जिसका अर्थ है कि फिर से कंस्ट्रक्टर के पैरामीटर के द्वारा अटिविटी के डिफ़ॉल्ट मान दिए जा सकते हैं। क्योंकि केवल showColor() फ़ंक्शन के एक इंस्टेंस को बनाया जाता है, इसलिए कोई स्मृति व्यर्थाव नहीं होता है। इसके अलावा, oCar1 के drivers एक्सएक्सक्सीव्सी में "Bill" मूल्य जोड़ने से oCar2 के एक्सएक्सक्सीव्सी पर कोई असर नहीं पड़ता, इसलिए इन एक्सएक्सक्सीव्सी के मानों को आउटपुट करने पर, oCar1.drivers "Mike,John,Bill" दिखाता है, जबकि oCar2.drivers "Mike,John" दिखाता है। क्योंकि अभिप्राय तरीके का उपयोग किया गया है, इसलिए 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);
  }
}

जेवा कार के सभी गुणों और विधियों को बेहतरीन तरीके से पैक करता है, इसलिए इस कोड को देखकर जाना जाता है कि यह क्या काम करता है, यह एक ऑब्जेक्ट के बारे में जानकारी देता है। मिश्रित कन्स्ट्रक्टर/प्रोटाटाईप विधि के विरुद्ध करने वाले लोगों का मानना है कि कन्स्ट्रक्टर के अंदर गुणों को खोजना और बाहरी विधियों को खोजना अव्यावहारिक है। इसलिए, उन्होंने डायनेमिक प्रोटाटाईप विधि को डिजाइन किया, ताकि अधिक सूख्द लिखाई शैली की आपूर्ति की जा सके。

डायनेमिक प्रोटाटाईप विधि का मूलसिद्धांत क्रॉसकन्स्ट्रक्टर/प्रोटाटाईप विधि के समान है, अर्थात कन्स्ट्रक्टर में गैर-फ़ंक्शन प्रकृति के रूप में प्रक्रिया की विशेषता को परिभाषित करें, फ़ंक्शन प्रकृति को प्रोटाटाईप विशेषता के रूप में परिभाषित करें। एकमात्र अंतर वस्तु के विधि को देने के स्थान को है। नीचे डायनेमिक प्रोटाटाईप विधि से पुनर्लिखित 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 होता है), तो इस विधि को नहीं बनाया जाता। सारांश में, यह विधि (flag _initialized) का इस्तेमाल करती है कि क्या प्रोटोटाइप को कोई विधि प्रदान किया गया है। यह विधि केवल एक बार बनाया और मान को देती है, ताकि रिकॉर्सिव ओब्जैक्ट विकासकर्ता यह देखकर खुश हों कि इसका कोड दूसरे भाषाओं में क्लास के प्रदर्शन की तरह दिखता है。

हिम्मती फैक्टरी तरीका

इस तरीका अगर पहले का तरीका नहीं लागू किया जा सकता तो एक विकल्प तरीका है। इसका उद्देश्य एक नकली कंस्ट्रक्टर बनाना है जो केवल दूसरे ऑब्जैक्ट का नया इनस्टेंस बचा देता है。

यह कोड फैक्टरी फ़ंक्शन से बहुत मिलता-जुलता दिखता है:

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

TIY

शास्त्रीय तरीके से भिन्न, इस तरीका new ऑपरेटर का इस्तेमाल करता है, इसे वास्तविक कंस्ट्रक्टर की तरह दिखाया जाता है:

var car = new Car();

Car() कंस्ट्रक्टर के भीतर new ऑपरेटर को बुलाया जाने के कारण, दूसरे new ऑपरेटर (कंस्ट्रक्टर के बाहर) को नज़रअंदाज़ कर दिया जाएगा, कंस्ट्रक्टर के भीतर बनाया गया ऑब्जैक्ट को वेरियेबल car में पाठित किया जाएगा。

इस तरीका के भीतरी ऑब्जैक्ट के विधि प्रबंधन में शास्त्रीय तरीके के समान समस्या है। अत्यधिक सिफारिश की जाती है: जब तक कि जरूरत नहीं हो, इस तरीके का इस्तेमाल करने से बचिए。

किस तरीके का इस्तेमाल करना

जैसा कि पहले कहा गया है, वर्तमान में सबसे अधिक व्यापक रूप से इस्तेमाल किया जाने वाला है मिश्रित कंस्ट्रक्टर/प्रोटोटाइप तरीका। इसके अलावा, डायनेमिक आरंभिक विधियां भी लोकप्रिय हैं, जो कार्यक्षेत्र में कंस्ट्रक्टर/प्रोटोटाइप तरीके से समान हैं। इन दोनों तरीकों में से किसी एक का इस्तेमाल किया जा सकता है। लेकिन केवल शास्त्रीय कंस्ट्रक्टर या प्रोटोटाइप तरीके को अलग नहीं इस्तेमाल करें, क्योंकि यह कोड में समस्याएँ प्रवेश कर सकता है。

उदाहरण

वस्तु के आगे की एक आकर्षक बात इनके समस्या सुलझाने के तरीके हैं। ECMAScript में सबसे अधिक आम समस्या एक्सेस्ट्रिंग की प्रदर्शन विशेषता है। अन्य भाषाओं के तरह, ECMAScript के स्ट्रिंग्स अपरिवर्तनीय हैं, अर्थात उनके मूल्य को बदला नहीं जा सकता। नीचे दिए गए कोड को देखें:

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

वास्तव में, इस कोड पीछे से इस प्रकार कार्य करता है:

  1. जोड़ने के परिणाम को संग्रह करने के लिए "hello " को बनाएं
  2. जोड़ने के परिणाम को संग्रह करने के लिए "world" को बनाएं
  3. जोड़ने के परिणाम को संग्रह करने के लिए शब्द को बनाएं
  4. str के वर्तमान सामग्री को परिणाम में नक़ल कर दें
  5. "world" को परिणाम में नक़ल कर दें
  6. str को अद्यतन करें, ताकि यह परिणाम की ओर संदर्भित हो।

इस तरह की शब्द जोड़ने के प्रक्रिया पूरा करने के बाद हर बार चरण 2 से 6 तक कार्य किया जाता है, जिससे इस कार्य को काफी अधिक संसाधन लगते हैं। यदि इस प्रक्रिया को कई बार अनुक्रमित रूप से किया जाए, फिर यह प्रदर्शन समस्या पैदा कर सकता है। समाधान के लिए, शब्दों को Array ऑब्जेक्ट में संग्रह करें, फिर शब्दों को जोड़ने के लिए join() मेथड्स (पारामीटर खाली शब्द) का उपयोग करें। इस तरह के कोड का उपयोग करके पहले के कोड के बदले में सोचें:

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

इस प्रकार, तालिका में कितने भी शब्दों को शामिल किया जाए, इससे कोई समस्या नहीं होगी, क्योंकि जोड़ना केवल join() मेथड्स को बुलाने पर होता है। इस समय, कार्य की चरण इस प्रकार होती हैं:

  1. परिणाम में संग्रह के लिए शब्द को बनाएं
  2. प्रत्येक शब्द को परिणाम में उचित स्थान पर नक़ल कर दें

यद्यपि यह समाधान अच्छा है, लेकिन बेहतर तरीका है। समस्या यह है कि इस कोड इसके इरादे को सही तरीके से दिखाने में असमर्थ है। इसे आसान तरीके से समझाने के लिए 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

इस कोड ने शब्दों के जोड़ने के लिए दो टेस्ट किए हैं, पहला जोड़ने के लिए जोड़ने के लिए और दूसरा StringBuffer क्लास का उपयोग करके।प्रत्येक ऑपरेशन 10000 शब्दों को जोड़ता है।तारीखीय मूल्य d1 और d2 को ऑपरेशन पूरा होने के लिए लगाए जाने वाले समय को निर्धारित करने के लिए उपयोग किया जाता है।डेट के मिलीसेकंड प्रतिनिधित्व को (getTime() विधि की वापसी) कोड कोड करके ऑपरेशन के समय की गणना करें।यह जावास्क्रिप्ट की प्रदर्शन गुणता को मापने का एक आम तरीका है।इस टेस्ट के परिणाम से आपको StringBuffer क्लास के उपयोग के साथ जोड़ने के लिए जोड़ने के उपयोग के बीच की गति की अंतराल को तुलना करने में मदद कर सकते हैं。