वैरिएबल

वैरिएबल एक डेटा स्ट्रक्चर होता है, जो किसी वैल्यू को कोई नाम असाइन करता है. इनमें किसी भी तरह का डेटा हो सकता है.

वैरिएबल के नाम को आइडेंटिफ़ायर कहा जाता है. मान्य आइडेंटिफ़ायर को इन नियमों का पालन करना चाहिए:

• आइडेंटिफ़ायर में यूनिकोड के अक्षर, डॉलर के निशान ($), अंडरस्कोर वर्ण (_), अंक (0-9), और कुछ यूनिकोड वर्ण भी शामिल हो सकते हैं.
• आइडेंटिफ़ायर में स्पेस नहीं हो सकता, क्योंकि पार्स करने वाला टूल, इनपुट एलिमेंट को अलग करने के लिए स्पेस का इस्तेमाल करता है. उदाहरण के लिए, अगर myVariable के बजाय किसी वैरिएबल को my Variable के तौर पर कॉल करने की कोशिश की जाती है, तो पार्स करने वाले को दो आइडेंटिफ़ायर, my और Variable दिखते हैं. साथ ही, सिंटैक्स से जुड़ी गड़बड़ी ("अनचाहा टोकन: आइडेंटिफ़ायर") दिखती है.

• आइडेंटिफ़ायर की शुरुआत किसी अक्षर, अंडरस्कोर (_) या डॉलर के निशान ($) से होनी चाहिए. ये अंकों से शुरू नहीं हो सकते, ताकि संख्याओं और आइडेंटिफ़ायर के बीच भ्रम न हो:

  let 1a = true;
  
  > Uncaught SyntaxError: Invalid or unexpected token
  

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

  let 10 = 20
  
  10 + 5
  > ?
  

• "रिज़र्व किए गए शब्द" जिनका सिंटैक्स पहले से ही काम का है, उनका इस्तेमाल आइडेंटिफ़ायर के तौर पर नहीं किया जा सकता.

• आइडेंटिफ़ायर में विशेष वर्ण (! . , / \ + - * =) नहीं होने चाहिए.

आइडेंटिफ़ायर बनाने के लिए, यहां दिए गए नियम ज़रूरी नहीं हैं. हालांकि, ये इंडस्ट्री के सबसे सही तरीके हैं. इनकी मदद से, अपने कोड को आसानी से मैनेज किया जा सकता है. अगर आपके किसी खास प्रोजेक्ट के लिए अलग स्टैंडर्ड तय किए गए हैं, तो उनका पालन करें.

JavaScript के पहले से मौजूद तरीकों और प्रॉपर्टी के उदाहरण के मुताबिक, कई शब्दों से बने आइडेंटिफ़ायर के लिए, कैमल केस (इसे "कैमल केस" भी कहा जाता है) एक बहुत ही सामान्य तरीका है. कैमल केस में, पहले शब्द को छोड़कर हर शब्द के पहले अक्षर को कैपिटल लेटर में लिखा जाता है. इससे, स्पेस के बिना भी टेक्स्ट को आसानी से पढ़ा जा सकता है.

let camelCasedIdentifier = true;

कुछ प्रोजेक्ट, डेटा के कॉन्टेक्स्ट और टाइप के हिसाब से, नाम रखने के दूसरे कन्वेंशन का इस्तेमाल करते हैं. उदाहरण के लिए, आम तौर पर क्लास के पहले अक्षर को कैपिटल लेटर में लिखा जाता है. इसलिए, कई शब्दों वाली क्लास के नामों में अक्सर कैमल केस का इस्तेमाल किया जाता है. इसे आम तौर पर "अपर कैमल केस" या Pascal केस कहा जाता है.

class MyClass {

}

आइडेंटिफ़ायर में मौजूद डेटा के बारे में कम शब्दों में जानकारी होनी चाहिए. उदाहरण के लिए, currentMonthDays, theNumberOfDaysInTheCurrentMonth से बेहतर नाम है. साथ ही, एक नज़र में आइडेंटिफ़ायर को साफ़ तौर पर पढ़ा जा सकता हो. जैसे, originalValue, val से बेहतर है. इस मॉड्यूल में इस्तेमाल किए गए myVariable आइडेंटिफ़ायर, अलग-अलग उदाहरणों के संदर्भ में काम करते हैं. हालांकि, प्रोडक्शन कोड में इनका कोई फ़ायदा नहीं होगा, क्योंकि इनसे यह जानकारी नहीं मिलती कि इनमें कौनसा डेटा शामिल है.

आइडेंटिफ़ायर में मौजूद डेटा के बारे में ज़्यादा जानकारी नहीं होनी चाहिए, क्योंकि स्क्रिप्ट उस डेटा पर कैसे काम करती हैं या आने वाले समय में डेटा मैनेजर कौनसे फ़ैसले लेते हैं, इनके आधार पर उनकी वैल्यू बदल सकती हैं. उदाहरण के लिए, किसी वैरिएबल को मूल रूप से आइडेंटिफ़ायर miles दिया गया है. हो सकता है कि प्रोजेक्ट में बाद में, उसे किलोमीटर में बदलने की ज़रूरत पड़े. ऐसे में, प्रोजेक्ट को मैनेज करने वाले लोगों को उस वैरिएबल के सभी रेफ़रंस बदलने होंगे, ताकि आने वाले समय में किसी तरह की गड़बड़ी न हो. इससे बचने के लिए, अपने आइडेंटिफ़ायर के तौर पर distance का इस्तेमाल करें.

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

वैरिएबल का एलान

JavaScript को किसी आइडेंटिफ़ायर के बारे में बताने के कई तरीके हैं. इस प्रोसेस को वैरिएबल "एलान करना" कहा जाता है. वैरिएबल को let, const या var कीवर्ड का इस्तेमाल करके एलान किया जाता है.

let myVariable;

किसी ऐसे वैरिएबल का एलान करने के लिए let या var का इस्तेमाल करें जिसे किसी भी समय बदला जा सकता है. ये कीवर्ड, JavaScript इंटरप्रेटर को बताते हैं कि वर्णों की स्ट्रिंग एक आइडेंटिफ़ायर है, जिसमें कोई वैल्यू हो सकती है.

नए कोडबेस में काम करते समय, var के बजाय let का इस्तेमाल करें. var अब भी आधुनिक ब्राउज़र में काम करता है. हालांकि, इसमें कुछ ऐसे व्यवहार हैं जो JavaScript के शुरुआती वर्शन में तय किए गए थे. साथ ही, पुराने सिस्टम के साथ काम करने की सुविधा को बनाए रखने के लिए, बाद में इनमें बदलाव नहीं किया जा सका. let को ES6 में इसलिए जोड़ा गया था, ताकि var के डिज़ाइन से जुड़ी कुछ समस्याओं को हल किया जा सके.

किसी वैरिएबल को वैल्यू असाइन करके, उसे शुरू किया जाता है. किसी वैरिएबल को वैल्यू असाइन करने या फिर से असाइन करने के लिए, बराबर के एक निशान (=) का इस्तेमाल करें. इसे उसी स्टेटमेंट के हिस्से के तौर पर किया जा सकता है जिसमें इसकी जानकारी दी गई है:

let myVariable = 5;

myVariable + myVariable
> 10

वैरिएबल को तुरंत शुरू किए बिना भी, let (या var) के साथ वैरिएबल का एलान किया जा सकता है. ऐसा करने पर, वैरिएबल की शुरुआती वैल्यू undefined होती है. ऐसा तब तक होता है, जब तक आपका कोड उसे कोई वैल्यू असाइन नहीं करता.

let myVariable;

myVariable;
> undefined

myVariable = 5;

myVariable + myVariable
> 10

undefined वैल्यू वाला वैरिएबल, ऐसे वैरिएबल से अलग होता है जिसका आइडेंटिफ़ायर अब तक तय नहीं किया गया है. ऐसे वैरिएबल का रेफ़रंस देने पर गड़बड़ी होती है जिसे आपने एलान नहीं किया है.

myVariable
> Uncaught ReferenceError: myVariable is not defined

let myVariable;

myVariable
> undefined

किसी आइडेंटिफ़ायर को वैल्यू से जोड़ने को आम तौर पर "बाइंडिंग" कहा जाता है. let, var या const कीवर्ड के बाद आने वाले सिंटैक्स को "बाइंडिंग सूची" कहा जाता है. इसमें कॉमा लगाकर अलग किए गए एक से ज़्यादा वैरिएबल एलान किए जा सकते हैं. ये वैरिएबल, अर्धविराम पर खत्म होते हैं. इससे, नीचे दिए गए कोड स्निपेट के काम करने का तरीका एक जैसा हो जाता है:

let firstVariable,
     secondVariable,
     thirdVariable;

let firstVariable;
let secondVariable;
let thirdVariable;

किसी वैरिएबल की वैल्यू को फिर से असाइन करने के लिए, let (या var) का इस्तेमाल नहीं किया जाता, क्योंकि JavaScript को पहले से पता होता है कि वैरिएबल मौजूद है:

let myVariable = true;

myVariable
> true

myVariable = false;

myVariable
> false

वैरिएबल की मौजूदा वैल्यू के आधार पर, उन्हें नई वैल्यू असाइन की जा सकती हैं:

let myVariable = 10;

myVariable
> 10

myVariable = myVariable * myVariable;

myVariable
> 100

अगर किसी प्रोडक्शन एनवायरमेंट में let का इस्तेमाल करके, किसी वैरिएबल को फिर से घोषित करने की कोशिश की जाती है, तो आपको सिंटैक्स से जुड़ी गड़बड़ी का मैसेज मिलेगा:

let myVariable = true;
let myVariable = false;
> Uncaught SyntaxError: redeclaration of let myVariable

ब्राउज़र के डेवलपर टूल, let (और class) को फिर से एलान करने के लिए ज़्यादा अनुमति देते हैं. इसलिए, हो सकता है कि आपको अपने डेवलपर कंसोल में वही गड़बड़ी न दिखे.

लेगसी ब्राउज़र के साथ काम करने की सुविधा को बनाए रखने के लिए, var किसी भी कॉन्टेक्स्ट में गड़बड़ी के बिना, ज़रूरत के बिना फिर से एलान करने की अनुमति देता है:

var myVariable = true;
var myVariable = false;

myVariable\
> false

const

किसी कॉन्स्टेंट का एलान करने के लिए, const कीवर्ड का इस्तेमाल करें. यह एक तरह का वैरिएबल है, जिसे तुरंत शुरू किया जाना चाहिए और फिर इसे बदला नहीं जा सकता. कॉन्स्टेंट के आइडेंटिफ़ायर, let (और var) का इस्तेमाल करके तय किए गए वैरिएबल के सभी नियमों का पालन करते हैं:

const myConstant = true;

myConstant
> true

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

const myConstant;
Uncaught SyntaxError: missing = in const declaration

const से तय किए गए वैरिएबल की वैल्यू को उसी तरह बदलने की कोशिश करने पर जिस तरह let (या var) से तय किए गए वैरिएबल की वैल्यू बदली जाती है, तो गड़बड़ी का मैसेज दिखता है:

const myConstant = true;

myConstant = false;
> Uncaught TypeError: invalid assignment to const 'myConstant'

हालांकि, जब किसी ऑब्जेक्ट से कोई कॉन्स्टेंट जुड़ा होता है, तो उस ऑब्जेक्ट की प्रॉपर्टी में बदलाव किया जा सकता है.

const constantObject = { "firstvalue" : true };

constantObject
> Object { firstvalue: true }

constantObject.secondvalue = false;

constantObject
> Object { firstvalue: true, secondvalue: false }

कॉन्सटेंट में मौजूद ऑब्जेक्ट, बदली जा सकने वाली डेटा वैल्यू का ऐसा रेफ़रंस होता है जिसे बदला नहीं जा सकता. कॉन्स्टेंट को बदला नहीं जा सकता. हालांकि, रेफ़रंस वाले ऑब्जेक्ट की प्रॉपर्टी में बदलाव किया जा सकता है, उन्हें जोड़ा जा सकता है या हटाया जा सकता है:

const constantObject = { "firstvalue" : true };

constantObject = false
> Uncaught TypeError: invalid assignment to const 'constantObject'

जब आपको लगता है कि किसी वैरिएबल को फिर से असाइन नहीं किया जाएगा, तो उसे एक कॉन्स्टेंट बनाना सबसे सही तरीका है. const का इस्तेमाल करने से, आपके डेवलपमेंट टीम या किसी प्रोजेक्ट के मैनेजर को यह पता चलता है कि उस वैल्यू में बदलाव नहीं करना है. इससे, आपके कोड के इस्तेमाल के बारे में की गई उन मान्यताओं को तोड़ने से बचा जा सकता है जो आपके कोड में मौजूद हैं. उदाहरण के लिए, यह कि किसी वैरिएबल का आकलन, उम्मीद के मुताबिक डेटा टाइप के हिसाब से किया जाएगा.

वैरिएबल का दायरा

वैरिएबल का स्कोप, स्क्रिप्ट का वह हिस्सा होता है जहां वह वैरिएबल उपलब्ध होता है. वैरिएबल के दायरे से बाहर, इसे undefined वैल्यू वाले आइडेंटिफ़ायर के तौर पर नहीं, बल्कि ऐसे तय किया जाएगा जैसे कि इसे एलान नहीं किया गया हो.

वैरिएबल का एलान करने के लिए इस्तेमाल किए गए कीवर्ड और उस संदर्भ के आधार पर जिसमें आपने वैरिएबल तय किया है, वैरिएबल को ब्लॉक स्टेटमेंट (ब्लॉक स्कोप), अलग-अलग फ़ंक्शन (फ़ंक्शन स्कोप) या पूरे JavaScript ऐप्लिकेशन (ग्लोबल स्कोप) के लिए तय किया जा सकता है.

ब्लॉक का दायरा

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

{
    let scopedVariable = true;
    console.log( scopedVariable );
}
> true

scopedVariable
> ReferenceError: scopedVariable is not defined

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

{
  const myConstant = false;
}
const myConstant = true;

scopedConstant;
> true

हालांकि, एलान किया गया वैरिएबल अपने पैरंट ब्लॉक में नहीं जा सकता, लेकिन यह सभी डिसेंटेंट ब्लॉक के लिए उपलब्ध होता है:

{
    let scopedVariable = true;
    {
    console.log( scopedVariable );
    }
}
> true

किसी एलान किए गए वैरिएबल की वैल्यू, उसके वंश के ब्लॉक में जाकर बदली जा सकती है:

{
    let scopedVariable = false;
    {
    scopedVariable = true;
    }
    console.log( scopedVariable );
}
> true

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

{
    let scopedVariable = false;
    {
    let scopedVariable = true;
    }
    console.log( scopedVariable );
}
> false

फ़ंक्शन का स्कोप

var का इस्तेमाल करके एलान किए गए वैरिएबल, अपने सबसे नज़दीकी फ़ंक्शन (या क्लास में मौजूद स्टैटिक शुरू करने वाले ब्लॉक) के दायरे में होते हैं.

function myFunction() {
    var scopedVariable = true;

    return scopedVariable;
}

scopedVariable;
> ReferenceError: scopedVariable is not defined

फ़ंक्शन को कॉल करने के बाद भी, यह स्थिति बनी रहती है. फ़ंक्शन के चालू होने के दौरान वैरिएबल को शुरू किया जाता है, फिर भी वह वैरिएबल फ़ंक्शन के दायरे से बाहर उपलब्ध नहीं होता:

function myFunction() {
    var scopedVariable = true;

    return scopedVariable;
}

scopedVariable;
> ReferenceError: scopedVariable is not defined

myFunction();
> true

scopedVariable;
> ReferenceError: scopedVariable is not defined

ग्लोबल स्कोप

ग्लोबल वैरिएबल, पूरे JavaScript ऐप्लिकेशन में उपलब्ध होता है. साथ ही, यह पेज पर मौजूद किसी भी स्क्रिप्ट के सभी ब्लॉक और फ़ंक्शन में भी उपलब्ध होता है.

ऐसा लग सकता है कि यह डिफ़ॉल्ट रूप से सही है. हालांकि, ऐसे वैरिएबल जिन्हें ऐप्लिकेशन का कोई भी हिस्सा ऐक्सेस और बदल सकता है, वे ऐप्लिकेशन के परफ़ॉर्मेंस पर असर डाल सकते हैं. इसके अलावा, एक ही आइडेंटिफ़ायर वाले ऐप्लिकेशन के किसी दूसरे हिस्से में मौजूद वैरिएबल के साथ भी गड़बड़ी हो सकती है. यह किसी पेज को रेंडर करने में शामिल किसी भी और सभी JavaScript पर लागू होता है. इसमें तीसरे पक्ष की लाइब्रेरी और उपयोगकर्ता के आंकड़े जैसी चीज़ें भी शामिल हैं. इसलिए, जब भी हो सके, ग्लोबल स्कोप को गलत डेटा से भरने से बचें.

पैरंट फ़ंक्शन के बाहर var का इस्तेमाल करके या पैरंट ब्लॉक के बाहर let या const का इस्तेमाल करके एलान किया गया कोई भी वैरिएबल ग्लोबल होता है:

var functionGlobal = true; // Global
let blockGlobal = true; // Global

{
    console.log( blockGlobal );
    console.log( functionGlobal );
}
> true
> true

(function() {
    console.log( blockGlobal );
    console.log( functionGlobal );
}());
> true
> true

किसी वैरिएबल को साफ़ तौर पर एलान किए बिना वैल्यू असाइन करने पर (यानी, var, let या const का इस्तेमाल किए बिना वैरिएबल बनाने पर), वैरिएबल को ग्लोबल स्कोप में ले जाया जाता है. भले ही, उसे किसी फ़ंक्शन या ब्लॉक में शुरू किया गया हो. इस पैटर्न का इस्तेमाल करके बनाए गए वैरिएबल को कभी-कभी "इंप्लीड ग्लोबल" कहा जाता है.

function myFunction() {
    globalVariable = "global";

    return globalVariable
}

myFunction()\
> "global"

globalVariable\
> "global"

वैरिएबल होइस्टिंग

वैरिएबल और फ़ंक्शन के एलान को उनके दायरे में सबसे ऊपर होस्ट किया जाता है. इसका मतलब है कि JavaScript इंटरप्रेटर, स्क्रिप्ट में किसी भी समय किए गए किसी भी वैरिएबल को प्रोसेस करता है और स्क्रिप्ट को लागू करने से पहले, उसे अपने दायरे की पहली लाइन पर ले जाता है. इसका मतलब है कि var का इस्तेमाल करके एलान किए गए वैरिएबल का रेफ़रंस, वैरिएबल के एलान से पहले दिया जा सकता है. ऐसा करने पर, कोई गड़बड़ी नहीं होती:

hoistedVariable
> undefined

var hoistedVariable;

वैरिएबल का एलान करने के साथ-साथ, उसे शुरू करने की प्रोसेस को होस्ट नहीं किया जाता. इसलिए, var, let या const के साथ साफ़ तौर पर एलान नहीं किए गए वैरिएबल को होस्ट नहीं किया जाता:

unhoistedVariable;
> Uncaught ReferenceError: unhoistedVariable is not defined

unhoistedVariable = true;

जैसा कि पहले बताया गया है, एलान किए गए, लेकिन शुरू नहीं किए गए वैरिएबल को undefined वैल्यू असाइन की जाती है. यह व्यवहार, होस्ट किए गए वैरिएबल के एलान पर भी लागू होता है. हालांकि, यह सिर्फ़ उन एलान पर लागू होता है जिन्हें var का इस्तेमाल करके एलान किया गया है.

hoistedVariable
> undefined

var hoistedVariable = 2 + 2;

hoistedVariable\
> 4

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

let और const, इस समस्या को ठीक करते हैं. इसके लिए, वे वैरिएबल के बनने से पहले उसे ऐक्सेस करने पर गड़बड़ी का मैसेज दिखाते हैं:

{
    hoistedVariable;

    let hoistedVariable;
}
> Uncaught ReferenceError: can't access lexical declaration 'hoistedVariable' before initialization

यह गड़बड़ी, "hoistedVariable की जानकारी नहीं दी गई है" गड़बड़ी से अलग है. ऐसा तब हो सकता है, जब किसी ऐसे वैरिएबल को ऐक्सेस करने की कोशिश की जाए जिसके बारे में पहले से जानकारी नहीं दी गई है. JavaScript ने वैरिएबल को होस्ट किया है, इसलिए उसे पता है कि वैरिएबल दिए गए स्कोप में बनाया जाएगा. हालांकि, इंटरप्रेटर उस वैरिएबल को undefined की वैल्यू के साथ एलान करने से पहले उपलब्ध कराने के बजाय, गड़बड़ी का मैसेज दिखाता है. let या const (या class) के साथ एलान किए गए वैरिएबल, अपने एन्क्लोज़िंग ब्लॉक की शुरुआत से लेकर कोड के उस पॉइंट तक "टेम्पोरल डेड ज़ोन" ("टीडीज़") में मौजूद होते हैं जहां वैरिएबल एलान किया गया है.

टाइम डेड ज़ोन की वजह से, लेखकों के लिए let का व्यवहार, var के मुकाबले ज़्यादा आसान हो जाता है. यह const के डिज़ाइन के लिए भी ज़रूरी है. कॉन्स्टेंट में बदलाव नहीं किया जा सकता. इसलिए, कॉन्स्टेंट को उसके स्कोप में सबसे ऊपर ले जाकर, undefined की वैल्यू दी गई है. हालांकि, इसे किसी काम की वैल्यू से शुरू नहीं किया जा सकता.

देखें कि आपको क्या समझ आया

आइडेंटिफ़ायर को किस तरह के वर्णों से शुरू किया जा सकता है?

एक पत्र

अंडरस्कोर

अंक

ऐसे वैरिएबल का एलान करने का कौनसा तरीका सबसे सही है जिसकी वैल्यू को कभी भी बदला जा सकता है?

let

const

var