वैरिएबल

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

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

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

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

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

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

  let 10 = 20
  
  10 + 5
  > ?
  

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

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

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

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

let camelCasedIdentifier = true;

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

class MyClass {

}

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

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

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

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

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

let myVariable;

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

मॉडर्न कोड बेस में काम करते समय, var के बजाय let का इस्तेमाल करें. var अब भी काम करेगा आधुनिक ब्राउज़र में देखा है, लेकिन इसमें कुछ ऐसे अनजाने व्यवहार हैं जिनके बारे में का सबसे पुराना वर्शन है, और उसे बाद में पुराने सिस्टम के साथ काम करने की सुविधा को बनाए रखें. कुछ समस्याओं को हल करने के लिए, 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

यह साधारण व्यवहार काफ़ी हद तक डिज़ाइन से जुड़े फ़ैसलों की वजह से सबसे पुराने वर्शन में हैं, और जिन्हें खतरे के जोखिम के बिना बदला नहीं जा सकता नुकसान पहुंचा सकता है.

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

{
    hoistedVariable;

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

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

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

देखें कि आपको कितना समझ आया है