article.md

Variables

ज्यादातर समय, एक जावास्क्रिप्ट एप्लिकेशन को जानकारी के साथ काम करने की आवश्यकता होती है। यहाँ दो उदाहरण हैं:

1. एक ऑनलाइन दुकान - जानकारी में बेचा जाने वाला सामान और खरीदारी की टोकरी शामिल हो सकती है।
2. एक चैट एप्लिकेशन - जानकारी में उपयोगकर्ता, संदेश और बहुत कुछ शामिल हो सकते हैं।

इस जानकारी को संग्रहीत करने के लिए Variable का उपयोग किया जाता है।

एक variable

एक variable(https://en.wikipedia.org/wiki/Variable_(computer_science)) डेटा के लिए एक "नामित भंडारण" है। हम उपहारों, आगंतुकों और अन्य डेटा को संग्रहीत करने के लिए variable का उपयोग कर सकते हैं।

जावास्क्रिप्ट में एक variable बनाने के लिए, let कीवर्ड का उपयोग करें।

नीचे दिया गया कथन "message" नाम के साथ एक variable बनाता है (दूसरे शब्दों में: घोषित करता है):

let message;

अब, हम असाइनमेंट ऑपरेटर = का उपयोग करके इसमें कुछ डेटा डाल सकते हैं:

let message;

*!*
message = 'Hello'; // string स्टोर करें
*/!*

string को अब variable के साथ जुड़े मेमोरी क्षेत्र में सहेजा गया है। हम variable नाम का उपयोग करके इसे प्राप्त कर सकते हैं:

let message;
message = 'Hello!';

*!*
alert(message); // variable सामग्री दिखाता है
*/!*

संक्षिप्त होने के लिए, हम variable घोषणा और असाइनमेंट को एक ही पंक्ति में जोड़ सकते हैं:

let message = 'Hello!'; // variable को परिभाषित करें और मान निर्दिष्ट करें

alert(message); // Hello!

हम एक पंक्ति में कई variables भी घोषित कर सकते हैं:

let user = 'John', age = 25, message = 'Hello';

यह छोटा लग सकता है, लेकिन हम इसकी अनुशंसा नहीं करते हैं। बेहतर पठनीयता के लिए, कृपया प्रति variable एकल लाइन का उपयोग करें।

मल्टीलाइन संस्करण थोड़ा लंबा है, लेकिन पढ़ने में आसान है:

let user = 'John';
let age = 25;
let message = 'Hello';

कुछ लोग इस बहुस्तरीय शैली में कई variable भी परिभाषित करते हैं:

let user = 'John',
  age = 25,
  message = 'Hello';

... या यहां तक ​​कि "अल्पविराम-पहली" शैली में:

let user = 'John'
  , age = 25
  , message = 'Hello';

तकनीकी रूप से, ये सभी प्रकार एक ही काम करते हैं। तो, यह व्यक्तिगत स्वाद और सौंदर्यशास्त्र की बात है।

````smart header="let के बजाय `var`" पुरानी लिपियों में, आपको एक और कीवर्ड भी मिल सकता है: `let` की जगह `var`:

*!*var*/!* message = 'Hello';

var कीवर्ड लगभग वही है जो let है। यह एक variable ही घोषित करता है, लेकिन थोड़ा अलग, "पुराने-स्कूल" तरीके से।

let और var के बीच सूक्ष्म अंतर हैं, लेकिन वे हमारे लिए अभी तक कोई मायने नहीं रखते हैं। हम उन्हें विस्तार से अध्याय info:var में शामिल करेंगे.

## एक वास्तविक जीवन सादृश्य

हम आसानी से "variable" की अवधारणा को समझ सकते हैं यदि हम इसे डेटा के लिए "बॉक्स" के रूप में कल्पना करते हैं, उस पर विशिष्ट रूप से नामित स्टिकर के साथ।

For instance, the variable `message` can be imagined as a box labeled `"message"` with the value `"Hello!"` in it:
उदाहरण के लिए, variable `message` को एक बॉक्स के रूप में कल्पना की जा सकती है, जिस पर `"message"` लिखा है, जिसका मूल्य `"Hello!"` है:

![](variable.svg)

हम बॉक्स में कोई भी मूल्य डाल सकते हैं।

हम इसे जितनी बार चाहें बदल सकते हैं:
```js run
let message;

message = 'Hello!';

message = 'World!'; // मान बदल गया

alert(message);
```

जब मूल्य बदल जाता है, तो पुराने डेटा को variable से हटा दिया जाता है:

![](variable-change.svg)

हम दो variables भी घोषित कर सकते हैं और एक से दूसरे में डेटा कॉपी कर सकते हैं।

```js run
let hello = 'Hello world!';

let message;

*!*
// 'Hello world' की प्रति हैलो से मैसेज में कॉपी करें
message = hello;
*/!*

// अब दो variables एक ही डेटा रखते हैं
alert(hello); // Hello world!
alert(message); // Hello world!
```

````warn header="दो बार घोषणा करने से त्रुटि हो जाती है"
एक variable को केवल एक बार घोषित किया जाना चाहिए।.

एक ही variable की बार-बार घोषणा एक त्रुटि है:

```js run
let message = "This";

// दोहराया 'let' एक त्रुटि की ओर जाता है
let message = "That"; // SyntaxError: 'message' has already been declared
पहले ही घोषित किया जा चुका है
```
तो, हमें एक बार एक variable घोषित करना चाहिए और फिर इसे `let` के बिना संदर्भित करना चाहिए

यह ध्यान रखना दिलचस्प है कि [functional](https://en.wikipedia.org/wiki/Functional_programming) प्रोग्रामिंग भाषाएं, जैसे कि [Scala](http://www.scala-lang.org/) या [Erlang](http://www.erlang.org/) मौजूद हैं| जो variable मानों को बदलने से मना करती है।

ऐसी भाषाओं में, मान को "बॉक्स में" संग्रहीत करने के बाद, यह हमेशा के लिए रहता है। अगर हमें कुछ और स्टोर करने की आवश्यकता है, तो भाषा हमें एक नया बॉक्स बनाने के लिए मजबूर करती है (एक नया variable घोषित करें)। हम पुराने का पुन: उपयोग नहीं कर सकते।

हालाँकि यह पहली नज़र में थोड़ा अजीब लग सकता है, लेकिन ये भाषाएँ गंभीर विकास के लिए काफी सक्षम हैं। इससे भी बड़ी बात यह है कि समानांतर संगणना जैसे क्षेत्र हैं जहाँ यह सीमा निश्चित लाभ देती है। ऐसी भाषा का अध्ययन (भले ही आप इसे जल्द ही उपयोग करने की योजना नहीं बना रहे हों) कर दिमाग को व्यापक बनाने की सिफारिश की जाती है।

Variable नामकरण [#variable-naming]

जावास्क्रिप्ट में variable नामों पर दो सीमाएँ हैं:

1. नाम में केवल अक्षर, अंक या चिह्न $ और _ होने चाहिए।
2. पहला वर्ण एक अंक नहीं होना चाहिए।

मान्य नामों के उदाहरण:

let userName;
let test123;

जब नाम में कई शब्द होते हैं, तो camelCase आमतौर पर इस्तेमाल किया जाता है। वह यह है: शब्द एक के बाद एक, प्रत्येक शब्द को छोड़कर पहले एक बड़े अक्षर से शुरू होते हैं: myVeryLongName।

क्या दिलचस्प है -- डॉलर चिह्न '$' और अंडरस्कोर '_' नामों में भी इस्तेमाल किया जा सकता है। वे बिना किसी विशेष अर्थ के, अक्षरों की तरह नियमित प्रतीक हैं।

ये नाम मान्य हैं:

let $ = 1; // "$" नाम के साथ एक variable घोषित
let _ = 2; // और अब "_" नाम के साथ एक variable

alert($ + _); // 3

गलत variable नामों के उदाहरण:

let 1a; // एक अंक से शुरू नहीं हो सकता

let my-name; // नाम में '-' की अनुमति नहीं है

`apple` और `AppLE` नाम के variables दो अलग-अलग variables हैं।

किसी भी भाषा का उपयोग करना संभव है, जिसमें cyrillic अक्षरों या यहां तक ​​कि चित्रलिपि भी शामिल हैं:

```js
let имя = '...';
let 我 = '...';
```

तकनीकी रूप से, यहां कोई त्रुटि नहीं है। ऐसे नामों की अनुमति है, लेकिन variable नामों में अंग्रेजी का उपयोग करने के लिए एक अंतर्राष्ट्रीय सम्मेलन है। यहां तक ​​कि अगर हम एक छोटी सी स्क्रिप्ट लिख रहे हैं, उसका आगे का लंबा जीवन हो सकता है। अन्य देशों के लोगों को इसे कुछ समय पढ़ने की आवश्यकता हो सकती है।

[आरक्षित शब्दों की एक सूची] (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords) है, यह वे शब्द हैं जिसका उपयोग variable नामों के रूप में नहीं किया जा सकता है, क्योंकि ये शब्द जावास्क्रिप्ट द्वारा स्वयं ही उपयोग किए जाते हैं।

उदाहरण के लिए: `let`, `class`, `return`, और` function` आरक्षित हैं।

नीचे दिया गया कोड एक सिंटैक्स त्रुटि देता है:

```js run no-beautify
let let = 5; // एक variable "let" का नाम नहीं दे सकता, त्रुटि!
let return = 5; // यह भी "return" नाम नहीं दे सकता, त्रुटि!
```

````warn header="An assignment without use strict"

आम तौर पर, हमें इसका उपयोग करने से पहले एक variable को परिभाषित करने की आवश्यकता होती है। लेकिन पुराने समय में, let का उपयोग किए बिना मूल्य के मात्र असाइनमेंट द्वारा एक variable बनाना तकनीकी रूप से संभव था। अगर हम पुरानी लिपियों के साथ संगतता बनाए रखने के लिए अपनी स्क्रिप्ट में use strict नहीं करते हैं तब भी यह काम करता है।

// नोट: इस उदाहरण में कोई `use strict` नहीं है

num = 5; // variable "num" बनाया जाता है अगर यह मौजूद नहीं था

alert(num); // 5

यह एक बुरा अभ्यास है और इससे strict मोड में त्रुटि होगी:

"use strict";

*!*
num = 5; // त्रुटि: num को परिभाषित नहीं किया गया है
*/!*

## Constants

एक constant (अपरिवर्तनीय) variable घोषित करने के लिए, `let` के बजाय `const` का उपयोग करें:

```js
const myBirthday = '18.04.1982';
```

Variables declared using `const` are called "constants". They cannot be reassigned. An attempt to do so would cause an error:
`const` का उपयोग करके घोषित variables को "constants" कहा जाता है। उन्हें आश्वस्त नहीं किया जा सकता है। ऐसा करने का प्रयास त्रुटि पैदा करेगा:

```js run
const myBirthday = '18.04.1982';

myBirthday = '01.01.2001'; // त्रुटि, constant आश्वस्त नहीं कर सकता!
```

जब एक प्रोग्रामर यह सुनिश्चित करता है कि एक variable कभी नहीं बदलेगा, तो वे गारंटी देने के लिए इसे `const` के साथ घोषित कर सकते हैं और उस तथ्य को सभी को स्पष्ट रूप से बता सकते हैं।


### बड़े अक्षर वाले constants

मुश्किल से याद रखने वाले मूल्यों के लिए constants का उपयोग करना एक व्यापक अभ्यास है जिसे क्रियान्वयन से पहले जाना जाता है।

ऐसे constants को बड़े अक्षरों और अंडरस्कोर का उपयोग करके नाम दिया गया है।

उदाहरण के लिए, चलो तथाकथित "वेब" (हेक्साडेसिमल) प्रारूप में रंगों के लिए constants बनाते हैं:

```js run
const COLOR_RED = "#F00";
const COLOR_GREEN = "#0F0";
const COLOR_BLUE = "#00F";
const COLOR_ORANGE = "#FF7F00";

// ...जब हमें एक रंग चुनने की आवश्यकता होती है
let color = COLOR_ORANGE;
alert(color); // #FF7F00
```

लाभ:

-`COLOR_ORANGE` को `"#FF7F00"` की तुलना में याद रखना बहुत आसान है।
- `COLOR_ORANGE` की तुलना में `#FF7F00` को गलत ठहराना ज्यादा आसान है।
- कोड पढ़ते समय `COLOR_ORANGE`, `#FF7F00` की तुलना में बहुत अधिक अर्थपूर्ण है।

हमें एक स्थिरांक के लिए बड़े अक्षर का उपयोग कब करना चाहिए और हमें इसे सामान्य रूप से कब नाम देना चाहिए? स्पष्ट करते हैं।

"constant" होने का मतलब है कि एक variable का मूल्य कभी नहीं बदलता है। लेकिन ऐसे constants होते हैं जिन्हें क्रियान्वयन से पहले जाना जाता है (जैसे लाल के लिए एक हेक्साडेसिमल मान) और ऐसे constants हैं जो क्रियान्वयन के दौरान रन-टाइम में *गणना* करते हैं, लेकिन उनके प्रारंभिक असाइनमेंट के बाद नहीं बदलते हैं।

उदाहरण के लिए:
```js
const pageLoadTime = /* लोड करने के लिए वेबपृष्ठ द्वारा लिया गया समय */;
```

पेज लोड होने से पहले `pageLoadTime` का मूल्य ज्ञात नहीं है, इसलिए इसे सामान्य रूप से नाम दिया गया है। लेकिन यह अभी भी एक constant है क्योंकि यह असाइनमेंट के बाद नहीं बदलता है।

दूसरे शब्दों में, बड़ा-अक्षर-नामित constants केवल "हार्ड-कोडेड" मूल्यों के लिए उपनाम के रूप में उपयोग किए जाते हैं।  

## चीजों को सही नाम दें

Variables के बारे में बात करते हुए, एक और बहुत महत्वपूर्ण बात है।

एक variable नाम का एक साफ, स्पष्ट अर्थ होना चाहिए, यह उस डेटा का वर्णन करता है जो इसे संग्रहीत करता है।

Variable नामकरण प्रोग्रामिंग में सबसे महत्वपूर्ण और जटिल कौशल है। Variable नामों पर एक त्वरित नज़र बता सकती है कि किस कोड को एक शुरुआत बनाम एक अनुभवी द्वारा लिखा गया था।

एक वास्तविक परियोजना में, अधिकांश समय खरोंच को पूरी तरह से अलग करने के बजाय मौजूदा कोड आधार को संशोधित और विस्तारित करने में खर्च किया जाता है। जब हम कुछ समय के लिए कुछ और करने के बाद किसी कोड पर लौटते हैं, तो ऐसी जानकारी प्राप्त करना बहुत आसान होता है जो अच्छी तरह से लेबल की गई हो। या, दूसरे शब्दों में, जब variable के अच्छे नाम हैं।

कृपया इसे घोषित करने से पहले एक variable के लिए सही नाम के बारे में सोचने में समय व्यतीत करें। ऐसा करना आपके बहुत काम का साबित होगा।

कुछ अच्छे नियम हैं:

- मानव-पठनीय नामों का उपयोग करें जैसे `userName` या `shoppingCart`।
- संक्षिप्त या संक्षिप्त नाम जैसे `A`, `B`, `C` से दूर रहें, जब तक कि आप वास्तव में नहीं जानते कि आप क्या कर रहे हैं।
- अधिकतम विवरणात्मक और संक्षिप्त नाम बनाएं। बुरे नामों के उदाहरण `data` और `value` हैं। ऐसे नाम कुछ भी नहीं कहते हैं। यदि कोड का संदर्भ असाधारण रूप से स्पष्ट है कि कौन सा डेटा या variable क्या संदर्भित कर रहा है तो इसका उपयोग करना ही ठीक है।
- अपनी टीम के भीतर और अपने मन में शर्तों पर सहमत हों। यदि किसी साइट विज़िटर को "user" कहा जाता है, तो हमें 'currentVisitor' या `newManInTown` के बजाय संबंधित variable का नाम `currentUser` या `newUser` रखना चाहिए।

सरल लगता है? वास्तव में यह है भी, लेकिन हमारे व्यवहार में वर्णनात्मक और संक्षिप्त variable नाम बनाना नहीं है। इसका लाभ उठाएं।

```smart header="Reuse or create?"
और आखिरी नोट। कुछ आलसी प्रोग्रामर हैं, जो नए variable घोषित करने के बजाय मौजूदा चीजों का पुन: उपयोग करते हैं।

नतीजतन, उनके variable बक्से के समान होते हैं, जिसमें लोग अपने स्टिकर को बदले बिना विभिन्न चीजों को फेंक देते हैं। अब बॉक्स के अंदर क्या है? कौन जानता है? हमें करीब आने और जांचने की जरूरत है।

ऐसे प्रोग्रामर variable डिक्लेरेशन पर थोड़ा बचत करते हैं, लेकिन डिबगिंग पर दस गुना अधिक खो देते हैं।

एक अतिरिक्त variable अच्छा है, बुरा नहीं है।

आधुनिक जावास्क्रिप्ट मिनिफ़ायर और ब्राउज़र कोड को अच्छी तरह से अनुकूलित करते हैं, इसलिए यह प्रदर्शन समस्याओं को पैदा नहीं करेगा। अलग-अलग मूल्यों के लिए अलग-अलग variable का उपयोग करने से इंजन को आपके कोड को अनुकूलित करने में भी मदद मिल सकती है।
```

## सारांश

हम `var`, `let`, या `const` कीवर्ड का उपयोग करके डेटा को संग्रहीत करने के लिए variable घोषित कर सकते हैं।

- `let` -- एक आधुनिक परिवर्तनशील घोषणा है।
- `var` -- एक पुराने स्कूल की variable घोषणा है। आम तौर पर हम इसका उपयोग बिल्कुल नहीं करते हैं, लेकिन हम अध्याय <info:var> में सूक्ष्म अंतरों को कवर करेंगे, बस अगर आपको उनकी आवश्यकता है तो।
- `const` -- `लेट` की तरह है, लेकिन variable की वैल्यू को बदला नहीं जा सकता।

Variable को इस तरह से नामित किया जाना चाहिए जो हमें आसानी से समझने की अनुमति दे कि उनके अंदर क्या है।