क्लास

ES6 ने JavaScript में "classes" का सिद्धांत पेश किया, जो कि दूसरी प्रोग्रामिंग भाषाओं की क्लास से अलग है. यहां क्लास खास फ़ंक्शन हैं, जो ऐसे ऑब्जेक्ट बनाने के लिए टेंप्लेट के तौर पर काम करते हैं जिनमें पहले से ही डेटा मौजूद है. साथ ही, उस डेटा से जुड़ी प्रॉपर्टी और उस डेटा से छेड़छाड़ करने के तरीकों के बारे में भी बताया गया है. इन ऑब्जेक्ट, प्रॉपर्टी, और तरीकों को सामूहिक रूप से क्लास के "सदस्य" कहा जाता है.

क्लास तय करने के लिए, class कीवर्ड का इस्तेमाल करें. सबसे सही तरीकों और JavaScript में पहले से मौजूद कंस्ट्रक्टर फ़ंक्शन से तय किए गए तरीकों के मुताबिक, क्लास के किसी भी आइडेंटिफ़ायर की शुरुआत कैपिटल लेटर से करें:

class MyClass {}

क्लास का मकसद, प्रोटोटाइप और कंस्ट्रक्टर फ़ंक्शन की बेहतर सुविधाओं के साथ काम करने के ज़्यादा सुलभ तरीके उपलब्ध कराना है:

class MyClass {}

typeof MyClass;
> "function"

बेहतर JavaScript सुविधाओं के साथ काम करना आसान और दिलचस्प बनाने के लिए, क्लास का कुछ हिस्सा जोड़ा गया था. इसलिए, इन्हें "सिंटैक्टिक शुगर" भी कहा जाता है. हालांकि, क्लास प्रोटोटाइप इनहेरिटेंस के साथ काम करने के लिए, सिर्फ़ शॉर्टहैंड की मदद नहीं करती हैं. पेश है क्लास सिंटैक्स, जिससे JavaScript में डिज़ाइन से जुड़ी पुरानी समस्याओं को हल किया जा सकता है. ऐसा करने के लिए, पुराने सिस्टम के साथ काम करने से जुड़ी समस्याओं का सामना नहीं करना पड़ता. एक उदाहरण के तौर पर, क्लास के मुख्य भाग के सभी कोड का आकलन हमेशा स्ट्रिक्ट मोड में किया जाता है.

क्लास का इंस्टेंस बनाने के लिए, new ऑपरेटर का इस्तेमाल करें.

class MyClass {}

const myClassInstance = new MyClass();

myClassInstance;
> Object { }

क्लास के मुख्य हिस्से में बताए गए फ़ंक्शन को उस क्लास के हर इंस्टेंस के तरीके के तौर पर दिखाया जाता है.

class MyClass {
    classMethod() {
        console.log( "My class method." );
    }
}

const myClassInstance = new MyClass();

myClassInstance.classMethod();
> "My class method."

क्लास में तय किया गया तरीका, नतीजे के इंस्टेंस के प्रोटोटाइप का तरीका बन जाता है. प्रोटोटाइप चेन के होने की वजह से, इन तरीकों को सीधे नतीजे वाले ऑब्जेक्ट पर कॉल किया जा सकता है:

class MyClass {
  classMethod() {
    console.log( "My class method." );
  }
}

const myClassInstance = new MyClass( "A string." );

myClassInstance;
> Object { }
    <prototype>: Object { … }
        classMethod: function classMethod()
        constructor: class MyClass { constructor(myPassedValue) }
        <prototype>: Object { … }

myClassInstance.classMethod();
> "My class method."

क्लास का इंस्टेंस बनाने पर, constructor() के खास तरीके को कॉल किया जाता है. यह नए इंस्टेंस के लिए सभी ज़रूरी "सेटअप" करता है और इससे जुड़ी कोई भी प्रॉपर्टी शुरू कर देता है. इंस्टेंस बनाए जाने के दौरान, क्लास में पास किए गए सभी तर्क constructor() तरीके में उपलब्ध होते हैं:

class MyClass {
  constructor( myPassedValue ) {
    console.log( myPassedValue );
  }
}

const myClassInstance = new MyClass( "A string." );
> "A string."

क्लास के मुख्य भाग में, this की वैल्यू खुद इंस्टेंस की जानकारी देती है. साथ ही, this पर बताई गई किसी भी प्रॉपर्टी को उस क्लास के हर इंस्टेंस की प्रॉपर्टी के तौर पर दिखाया जाता है:

class MyClass {
  constructor( myPassedValue ) {
    this.instanceProperty = myPassedValue;
  }
}

const myClassInstance = new MyClass( "A string." );

myClassInstance;
> Object { instanceProperty: "A string." }

ये प्रॉपर्टी, क्लास के मुख्य भाग में मौजूद सभी तरीकों के लिए भी उपलब्ध हैं:

class MyClass {
  constructor( myPassedValue ) {
    this.instanceProp = myPassedValue;
  }
  myMethod() {
    console.log( this.instanceProp );
  }
}

const myClassInstance = new MyClass( "A string." );

myClassInstance.myMethod();
> "A string."

अगर आपने अपनी क्लास के लिए constructor() तय नहीं किया है, तो JavaScript इंजन खाली "डिफ़ॉल्ट" constructor को मान लेता है. हर क्लास में constructor() नाम का सिर्फ़ एक खास तरीका हो सकता है:

class MyClass {
  constructor() {}
  constructor() {}
}
> Uncaught SyntaxError: A class may only have one constructor

आपके पास क्लास का एलान करने वाला फ़ॉर्म या क्लास एक्सप्रेशन का इस्तेमाल करके क्लास तय करने का विकल्प होता है. पिछले उदाहरण में क्लास के बारे में एलान किए गए हैं, जिनमें new का इस्तेमाल करके नामों को शुरू करना ज़रूरी है. "अनाम" क्लास बनाने के लिए, क्लास एक्सप्रेशन को नाम दिया जा सकता है या बिना नाम दिए छोड़ दिया जा सकता है.

let ClassExpression = class {
    constructor() {}
};

ClassExpression;
> class  {}

अनाम क्लास एक्सप्रेशन का इस्तेमाल उन फ़ंक्शन के लिए किया जा सकता है जो क्लास को "तुरंत" बनाते हैं:

function classMaker() {
  return class {
    constructor() {}
  };
}

let MyVariable = classMaker();

MyVariable;
> class  {}

क्लास की जानकारी देने वाली सुविधा का इस्तेमाल करके, क्लास को फिर से तय करने से सिंटैक्स में गड़बड़ी होती है:

class MyClass {
    constructor( ) {
        console.log( "My class." );
    }
};

class MyClass {
    constructor() {
        console.log( "My new class." );
    }
};
> Uncaught SyntaxError: redeclaration of class MyClass

हालांकि, क्लास एक्सप्रेशन का इस्तेमाल करके क्लास को फिर से परिभाषित किया जा सकता है:

let ClassExpression = class MyClass { };

ClassExpression = class MyOtherClass {
    constructor( myString ) {
        this.myProp = myString;
    }
};

new ClassExpression( "String." );
> MyOtherClass {myProp: 'String.'}

नाम वाले क्लास एक्सप्रेशन को, क्लास डिक्लेरेशन की तरह नाम से शुरू नहीं किया जा सकता. हालांकि, क्लास एक्सप्रेशन का असाइन किया गया नाम, बनाए गए इंस्टेंस की प्रॉपर्टी के तौर पर उपलब्ध होता है. इससे डीबग करना आसान हो जाता है:

let MyVariable = class MyClass {};

MyClass;
> Uncaught ReferenceError: MyClass is not defined

MyVariable;
> class MyClass {}

MyVariable.name;
> "MyClass"

जब किसी क्लास एक्सप्रेशन का इस्तेमाल करके कोई वैरिएबल शुरू किया जाता है, तो उस वैरिएबल के उद्धरण नियम उम्मीद के मुताबिक लागू होते हैं. क्लास के एलान, "let और const जैसे"अस्थायी डेड ज़ोन" नियमों के मुताबिक होते हैं. साथ ही, ये इस तरह से दिखते हैं जैसे कि इन्हें मौजूदा स्कोप में शामिल नहीं किया गया हो. इसका मतलब है कि क्लास के एलान से पहले क्लास का अनुरोध करने से गड़बड़ी होती है:

{
    let myVar = new MyClass( "Property string." );

    class MyClass {
        myProp;

        constructor( myString ) {
            this.myProp = myString;
        }
    };
};
> Uncaught ReferenceError: Cannot access 'MyClass' before initialization

जांचें कि आपको कितना समझ आया

इनमें से कौनसा विकल्प किसी क्लास के बारे में सही जानकारी देता है?

class MyClass {}

myClass = class {}

new class()

क्लास के लिए, constructor() के कितने तरीके इस्तेमाल किए जा सकते हैं?

एक

कोई नहीं

अनलिमिटेड