वैरिएबल

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

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

• आइडेंटिफ़ायर में यूनिकोड के अक्षर, डॉलर का निशान ($), अंडरस्कोर (_), अंक (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;

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

class MyClass {

}

आइडेंटिफ़ायर को कम शब्दों में अपने डेटा की प्रकृति के बारे में बताना चाहिए (उदाहरण के लिए, theNumberOfDaysInTheCurrentMonth से currentMonthDays बेहतर नाम है) और एक नज़र में आसानी से पढ़ा जा सकता है (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 is not found" गड़बड़ी से अलग है, जिसकी उम्मीद आपको किसी अघोषित वैरिएबल को ऐक्सेस करते समय हो सकती है. JavaScript ने वैरिएबल को शामिल किया है, इसलिए यह जानते हैं कि वैरिएबल को दिए गए स्कोप में बनाया जाएगा. हालांकि, उस वैरिएबल के एलान से पहले उसे undefined की वैल्यू के साथ उपलब्ध कराने के बजाय, अनुवादक, गड़बड़ी का मैसेज दिखाता है. let या const (या class) के साथ घोषित किए गए वैरिएबल, एनक्लोज़र ब्लॉक की शुरुआत से "अस्थायी डेड ज़ोन" ("TDZ") में मौजूद होते हैं. यह तब तक मौजूद रहता है, जब तक कि वैरिएबल के एलान वाले कोड में मौजूद पॉइंट न हो.

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

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

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

अक्षर

अंडरस्कोर

अंक

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

ले जाने

const

var