Skip to content
This page has been auto-translated and may contain errors.View in English

चर और मान

docs.scrimba.com

कल्पना करें कि आप एक चेकआउट पेज बना रहे हैं और किसी आइटम की कीमत तीन जगहों पर दिखाई देती है: प्रोडक्ट लाइन में, चल रहे कुल में, और पुष्टि में। सभी तीन जगहों पर 19.99 को मैन्युअल रूप से टाइप करें और एक बिक्रय दोपहर भर की खोज-और-प्रतिस्थापन बन जाती है। इसे एक बार एक नाम के तहत स्टोर करें और इसे एक जगह बदलें, और हर जगह जो इसे उपयोग करता है वह आपके साथ अपडेट हो जाता है। वह नाम एक चर है, और यह अध्याय इसे कैसे बनाएं, इसे कब लॉक करें, और इसे क्या कहें, इसके बारे में है।

मान को स्टोर करना

एक चर एक नाम है जो आप किसी मान को देते हैं ताकि आप इसे बाद में फिर से उपयोग कर सकें। आप इसे शब्द let के साथ बनाते हैं, फिर एक नाम, फिर =, फिर वह मान जो आप स्टोर करना चाहते हैं:

js
let userName = "राज";
console.log(userName); // राज

वह लाइन कहती है: पाठ "राज" लें और इसे नाम userName के तहत याद रखें। उसके बाद, जहां भी आप userName लिखते हैं, JavaScript आपको वह वापस देता है जो आपने स्टोर किया है।

= को "इस मान को इस नाम के तहत रखो" के रूप में पढ़ें। यह गणित की कक्षा से बराबर चिन्ह नहीं है, जहां दोनों पक्ष पहले से ही समान हैं। यह एक निर्देश है: दाईं ओर का मान लें, और इसे बाईं ओर के नाम के तहत छिपाएं।

क्योंकि यह एक स्टोर-यह निर्देश है, आप बाद में अपना विचार बदल सकते हैं। नाम और = को फिर से लिखें एक नए मान के साथ, और JavaScript नवीनतम को रखता है:

js
let score = 0;
score = 10;
console.log(score); // 10

पहली लाइन score बनाता है और इसमें 0 डालता है। दूसरी इसे एक नया मान देता है। कोई दूसरा let नहीं है, क्योंकि score पहले से मौजूद है; आप इसे फिर से बना नहीं रहे हैं, बल्कि इसे अपडेट कर रहे हैं।

एक चर एक नाम है जो एक मान के साथ बंधा हुआ है। आप इसे let के साथ घोषित करते हैं और असाइनमेंट ऑपरेटर = के साथ इसका मान सेट करते हैं:

js
let total = 0;
total = 42;
console.log(total); // 42

= असाइनमेंट है, तुलना नहीं। यह दाईं ओर की अभिव्यक्ति का मूल्यांकन करता है, फिर परिणाम को बाईं ओर के नाम के तहत स्टोर करता है। यह है कि क्यों = का अर्थ "इस मान को असाइन करें" है, कभी "बराबर है नहीं"; तुलना जो आप ऑपरेटर्स में मिलेंगे एक अलग प्रतीक है, ===

let के साथ घोषित करना नाम बनाता है; फिर से असाइन करना इसके द्वारा आयोजित मान को अपडेट करता है। आप प्रति चर केवल एक बार let का उपयोग करते हैं। उसके बाद, बाईं ओर का नंगा नाम पर्याप्त है:

js
let itemPrice = 19.99;
itemPrice = 24.99;
console.log(itemPrice); // 24.99

दाईं ओर का मान JavaScript के किसी भी डेटा प्रकार हो सकता है: पाठ, एक संख्या, एक बूलियन। चर इस बारे में परवाह नहीं करता; यह जो भी आपने अंतिम बार असाइन किया है उसे रखता है।

एक चर एक पहचानकर्ता है (आपके कोड में एक नाम) जो एक मान के साथ बंधा हुआ है। = असाइनमेंट ऑपरेटर है: यह दाईं ओर की अभिव्यक्ति का मूल्यांकन करता है और परिणाम को बाईं ओर के नाम के साथ बंधता है। यह कभी समानता का परीक्षण नहीं करता है, और यह कभी एक मान को एक निश्चित बॉक्स में कॉपी नहीं करता है; यह एक नाम को एक मान की ओर इशारा करता है।

js
let total = 0;
total = 42;
console.log(total); // 42

पुनः असाइनमेंट एक नया चर नहीं बनाता है, यह मौजूदा बंधन को फिर से इंगित करता है। वह अंतर संख्या और स्ट्रिंग जैसी प्रिमिटिव के साथ अदृश्य रहता है, जहां प्रत्येक मान अलग और स्व-निहित होता है। यह उसी क्षण शुरू होता है जब एक चर कुछ साझा रखता है, जैसे कोई ऑब्जेक्ट, क्योंकि तब दो नाम एक ही मान की ओर इशारा कर सकते हैं और एक के माध्यम से परिवर्तन दूसरे के माध्यम से दिखाई देता है। आप ऑब्जेक्ट्स आने पर पूरा देखेंगे; अभी के लिए, इस विचार को रखें कि एक नाम एक मान की ओर इशारा करता है बजाय इसे रखने के।

एक और बात जो = नहीं करता है: यह मान को जगह में लॉक नहीं करता है। let score = 0 कहता है "अभी के लिए score को 0 की ओर इशारा करो", और अगली पंक्ति इसे कहीं और इंगित करने के लिए स्वतंत्र है। क्या एक बंधन बिल्कुल भी फिर से इंगित किया जा सकता है यह let और const के बीच का अंतर है, जो अगला है।

Junoमान को स्टोर करना एक चर एक मान के लिए एक नाम है जो आप पुनः उपयोग करना चाहते हैं, और आप इसे let name = value के साथ बनाते हैं। = को "इस मान को इस नाम के तहत रखो" के रूप में पढ़ें, गणित की कक्षा की बराबरी के रूप में नहीं। इसे बाद में बदलने के लिए, नाम और = को फिर से लिखें कोई दूसरा let नहीं, और JavaScript नवीनतम मान रखता है।
Junoमान को स्टोर करनाlet के साथ घोषित करना एक नाम बनाता है; = के साथ असाइन करना इसके तहत एक मान स्टोर करता है। = असाइनमेंट है, तुलना नहीं, इसलिए यह कभी "बराबर है" का अर्थ नहीं देता। आप प्रति चर केवल एक बार let लिखते हैं; उसके बाद नंगा नाम इसके द्वारा आयोजित मान को अपडेट करता है।
Junoमान को स्टोर करना= एक नाम को एक मान के साथ बंधता है, यह कभी एक बॉक्स में कॉपी नहीं करता या समानता का परीक्षण नहीं करता। पुनः असाइनमेंट एक नया चर बनाने के बजाय मौजूदा बंधन को फिर से इंगित करता है। यह संख्याओं और स्ट्रिंग्स के साथ अदृश्य रहता है और एक बार जब कोई नाम कुछ साझा की ओर इशारा करता है तो काटना शुरू करता है, इसलिए "नाम मान की ओर इशारा करता है" को याद रखें इससे पहले कि ऑब्जेक्ट्स दिखाएं।

let बनाम const

एक चर बनाने के लिए दो शब्द हैं: let और const। आपने let देखा है। const का उपयोग करें जब आप इसे सेट करने के बाद मान को कभी नहीं बदलना चाहते:

js
const taxRate = 0.2;
console.log(taxRate); // 0.2

एक कर दर निश्चित है, इसलिए const फिट बैठता है: यह कहता है "यह सेट है, और मैं नहीं चाहता कि यह दुर्घटनावश बदले"। यदि आप const को फिर से असाइन करने का प्रयास करते हैं, तो JavaScript आपको एक त्रुटि के साथ रोकता है, जो एक सहायक रेलिंग है।

पहले const तक पहुंचें। केवल let का उपयोग करें जब आप जानते हैं कि मान बदलेगा, जैसे एक स्कोर जो ऊपर जाता है या एक कुल जिसे आप जोड़ते हैं। यदि एक मान अपनी पूरी जीवन के लिए समान रहता है, तो const कहता है और इसे सुरक्षित करता है।

js
const currency = "USD";
let itemsInCart = 0;
itemsInCart = 3;
console.log(itemsInCart); // 3

मुद्रा नहीं बदलेगी, इसलिए यह const है। कार्ट की गिनती करेगी, इसलिए यह let है।

JavaScript आपको एक चर घोषित करने के दो तरीके देता है, और पसंद इस बारे में है कि क्या मान को फिर से असाइन किया जाएगा। const एक स्थिर बंधन घोषित करता है: एक बार जब आप इसे असाइन करते हैं, तो आप उस नाम को एक नए मान की ओर इंगित नहीं कर सकते।

js
const taxRate = 0.2;
taxRate = 0.25; // TypeError: Assignment to constant variable.

let पुनः असाइनमेंट की अनुमति देता है; const इसे निषिद्ध करता है। नियम जो कोड को साफ रखता है वह है डिफ़ॉल्ट रूप से const तक पहुंचना, और केवल तभी let का उपयोग करना जब आपको पुनः असाइन करना चाहिए। अधिकांश चर एक बार सेट किए जाते हैं और कई बार पढ़े जाते हैं, इसलिए अधिकांश को const होना चाहिए।

js
const currency = "USD";
let runningTotal = 0;
runningTotal = 19.99;
console.log(runningTotal); // 19.99

const मान को विशेष के बारे में नहीं है; यह किसी भी को पढ़ने वाले कोड के लिए एक संकेत है, आपको अगले हफ्ते भी, कि यह नाम नहीं चलेगा। वह संकेत एक प्रोग्राम को अनुसरण करना आसान बनाता है, क्योंकि एक const जिस पर आप भरोसा कर सकते हैं वह जगह में रहे।

let और const दोनों एक बंधन घोषित करते हैं (एक नाम और एक मान के बीच संबंध)। अंतर यह है कि क्या उस बंधन को फिर से असाइन किया जा सकता है। const बंधन को फ्रीज करता है: प्रारंभिक असाइनमेंट के बाद, नाम को एक नए मान की ओर इंगित करना एक TypeError है।

js
const taxRate = 0.2;
taxRate = 0.25; // TypeError: Assignment to constant variable.

const को डिफ़ॉल्ट करें और केवल जहां पुनः असाइनमेंट वास्तविक है वहां let पर ड्रॉप करें। यह शैलीगत संवेदनशीलता नहीं है; एक const एक तथ्य है जिस पर आप पढ़ते समय भरोसा कर सकते हैं, एक कम नाम जो आपके अंतर्गत बदल सकता है, और यह संकीर्ण करता है कि एक बग कहां जी सकता है।

जल्दी बताने के लायक सूक्ष्मता: const बंधन को ठीक करता है, सामग्री को नहीं। यह आपको नाम को फिर से इंगित करने से रोकता है, लेकिन यदि मान कुछ आंतरिक भागों के साथ है, तो वे भाग अभी भी बदल सकते हैं। एक संख्या या एक स्ट्रिंग के पास बदलने के लिए कोई आंतरिक भाग नहीं है, इसलिए उन const के साथ बिल्कुल "यह मान निश्चित है" जैसा व्यवहार करता है। एक ऑब्जेक्ट के साथ, हालांकि, const केवल यह गारंटी देता है कि नाम एक ही ऑब्जेक्ट की ओर इंगित करता है; ऑब्जेक्ट की अपनी सामग्री संपादित योग्य रहती है। वह अंतर लोगों को आश्चर्यचकित करता है, और यह मध्य-डीबग से पहले समझना आसान है, इसलिए ऑब्जेक्ट्स सीधे इसे वापस करते हैं।

js
const currency = "USD";
let runningTotal = 0;
runningTotal = 19.99;
console.log(runningTotal); // 19.99

एक तीसरा, पुराना कीवर्ड है जो आप मौजूदा कोड में मिलेंगे: var। इसका उपयोग न करें। यह let से दो तरीकों में भिन्न है जो बग का कारण बनते हैं। पहला, var है फंक्शन-स्कोपड: यह { } ब्लॉक को अनदेखा करता है जिन्हें let और const सम्मान करते हैं, इसलिए एक ब्लॉक के अंदर घोषित var पूरे आस-पास फंक्शन में लीक हो जाता है, जबकि let और const है ब्लॉक-स्कोपड और निकटतम { } के अंदर रहें। दूसरा, var है hoisted: घोषणा को ऐसे माना जाता है जैसे यह अपने दायरे के शीर्ष पर चली गई, इसलिए एक var नाम मौजूद है (undefined रखते हुए) उस पंक्ति से पहले जो इसे घोषित करता है, जो गलतियों को पकड़ने के बजाय छिपाता है।

let और const को भी होइस्ट किया जाता है, लेकिन उन्हें उनकी घोषणा पंक्ति से पहले तक पहुंचना चुप से undefined देने के बजाय फेंकता है; वह प्रारंभिक खिड़की को अस्थायी मृत क्षेत्र कहा जाता है, और जो त्रुटि इसे उत्पन्न करता है वह एक सुविधा है, क्योंकि यह एक चुप बग को जोर से चालू करता है। संक्षिप्त संस्करण: डिफ़ॉल्ट रूप से const लिखें, जब आपको पुनः असाइन करना चाहिए तो let, और पुरानी कोड को बनाए रखने के लिए var को पढ़ने के लिए केवल-ज्ञान के रूप में संभालें।

Junolet बनाम const एक ऐसे मान के लिए const का उपयोग करें जो कभी नहीं बदलना चाहिए, और एक के लिए let जो करेगा। पहले const तक पहुंचें, और केवल तभी let पर स्विच करें जब आप जानते हैं कि मान को बदलने की जरूरत है। एक const को फिर से असाइन करने से आपको एक त्रुटि मिलती है, जो रेलिंग अपना काम कर रहा है।
Junolet बनाम constconst पुनः असाइनमेंट को रोकता है; let इसकी अनुमति देता है। const को डिफ़ॉल्ट करें और केवल जब एक मान को बदलना है तो let तक पहुंचें। एक const अगले पाठक को बताता है कि यह नाम नहीं चलेगा, और अधिकांश चर एक बार सेट किए जाते हैं और कई बार पढ़े जाते हैं, इसलिए अधिकांश को const होना चाहिए।
Junolet बनाम constconst बंधन को फ्रीज करता है, सामग्री को नहीं, इसलिए नाम को फिर से असाइन करना एक TypeError है लेकिन एक ऑब्जेक्ट जिस पर यह इंगित करता है अभी भी संपादित किया जा सकता है। const को डिफ़ॉल्ट करें, वास्तविक पुनः असाइनमेंट के लिए केवल let का उपयोग करें, और पुराने var को पढ़ने के लिए-ज्ञान के रूप में संभालें, क्योंकि यह फंक्शन-स्कोपड है और उन तरीकों से hoisted है जो बग को छिपाते हैं। बंधन-बनाम-सामग्री का अंतर लोगों को पकड़ता है, इसलिए ऑब्जेक्ट्स आने से पहले इसे याद रखें।

चर का नामकरण

एक चर के नाम के कुछ नियम हैं। यह अक्षरों, अंकों, _, और $ का उपयोग कर सकता है, लेकिन यह एक अंक के साथ शुरू नहीं हो सकता है, और इसमें रिक्त स्थान नहीं हो सकते:

js
let firstName = "राज";
let item2 = "book";

नाम केस-संवेदनशील हैं, जिसका अर्थ है firstName और firstname दो अलग-अलग चर हैं। पूंजीकरण को गलत तरीके से प्राप्त करना एक सामान्य प्रारंभिक गलती है, इसलिए नामों को सुसंगत रखने में मदद मिलती है।

JavaScript डेवलपर्स जिस शैली का उपयोग करते हैं उसे camelCase कहा जाता है: कम शुरू करें, और बाद के प्रत्येक शब्द के पहले अक्षर को बड़े अक्षर करें, रिक्त स्थान के बिना। तो firstName, itemPrice, isLoggedIn

js
let itemPrice = 19.99;
let isLoggedIn = true;

नियमों से परे, ऐसे नाम चुनने का लक्ष्य रखें जो कहते हैं कि वे क्या रखते हैं। price p को मारता है, और userName x को मारता है। आप अपने कोड को जितना लिखते हैं उससे कहीं अधिक पढ़ते हैं, और स्पष्ट नाम ही इसे पठनीय बनाते हैं।

वैध नाम के नियम: इसमें अक्षर, अंक, _, और $ हो सकते हैं, किसी अंक से शुरू नहीं हो सकते, और let जैसे आरक्षित शब्द शामिल नहीं कर सकते। नाम केस-संवेदनशील हैं, इसलिए total और Total अलग-अलग चर हैं।

उन नियमों के भीतर, सम्मेलन camelCase है: कम पहला शब्द, बाद के प्रत्येक शब्द को पूंजीकृत किया गया, कोई विभाजक नहीं।

js
let firstName = "राज";
let itemPrice = 19.99;
let isLoggedIn = true;

सम्मेलन भाषा द्वारा लागू नहीं है, लेकिन यह हर कोडबेस द्वारा लागू है जिसमें आप काम करेंगे, इसलिए शुरुआत से ही इसका पालन करें। एक बूलियन अक्सर is या has उपसर्ग (isLoggedIn, hasDiscount) के साथ अच्छी तरह से पढ़ता है, जो संकेत देता है कि मान सच है या गलत।

नाम दस्तावेज़ है। daysUntilExpiry अगले पाठक को बताता है कि मान का क्या अर्थ है; d उन्हें शिकार करने के लिए जाता है। वर्णनात्मक नाम कुछ कीस्ट्रोक खर्च करते हैं और वास्तविक समय बचाते हैं, इसलिए उन्हें खर्च करें।

शब्दकोषीय नियम: एक वैध पहचानकर्ता (कोड में एक नाम) में अक्षर, अंक, _, और $ हो सकते हैं, किसी अंक से शुरू नहीं हो सकते, और आरक्षित शब्द नहीं हो सकते (let, const, return, और इसी तरह)। पहचानकर्ता केस-संवेदनशील हैं, इसलिए total और Total भिन्न हैं।

शीर्ष पर रखी गई सम्मेलन चर के लिए camelCase है, और यह भी लायक है यहां तक कि भाषा इसे लागू नहीं करता है तब भी गैर-परक्राम्य के रूप में व्यवहार करना। Tooling, सहकर्मी, और हर लोकप्रिय शैली मार्गदर्शिका इसे मानते हैं, इसलिए विचलन लाभ के बिना घर्षण जोड़ता है।

js
const firstName = "राज";
const itemPrice = 19.99;
const isLoggedIn = true;

उच्च-मूल्य आदत अर्थ के लिए नामकरण है। एक नाम सबसे सस्ता दस्तावेज़ है जो आपके पास है और जो सबसे अधिक सटीक रहने की संभावना है, क्योंकि यह जिस मान का वर्णन करता है उस पर बैठा है। remainingCredits एक रीफेक्टर को जीवित रहता है जो एक टिप्पणी कह सकता है "क्रेडिट बचे हुए" नहीं हो सकता। बूलियन एक हां/नहीं प्रश्न के रूप में सबसे अच्छा पढ़ते हैं (isActive, hasAccess), और ऐसे नाम से बचें जो परिवर्तन के बाद झूठ बोलते हैं, जैसे एक const total जिसे आप वैचारिक रूप से जोड़ते रहते हैं; यदि अर्थ बहाव है, तो इसे फिर से नाम दें। स्पष्ट नामकरण इस अध्याय में सबसे अधिक-उत्तोलन आदत है, और यह मुक्त है।

Junoचर का नामकरण एक नाम अक्षर, अंक, _, और $ का उपयोग कर सकता है, लेकिन किसी अंक से शुरू नहीं हो सकता या रिक्त स्थान रखता है। नाम केस-संवेदनशील हैं, इसलिए firstName और firstname भिन्न हैं। itemPrice जैसे camelCase का उपयोग करें, और ऐसे नाम चुनें जो कहते हैं कि वे क्या रखते हैं, इसलिए p के बजाय price
Junoचर का नामकरण वैध नाम अक्षर, अंक, _, और $ का उपयोग करते हैं, कभी किसी अंक से शुरू नहीं हो सकते, और केस-संवेदनशील हैं। सम्मेलन camelCase है, और हालांकि भाषा इसे लागू नहीं करता है, हर कोडबेस करता है, इसलिए दिन एक से ही इसका पालन करें। एक वर्णनात्मक नाम दस्तावेज़ है जो सटीक रहता है, इसलिए d के बजाय daysUntilExpiry पर कीस्ट्रोक खर्च करें।
Junoचर का नामकरण पहचानकर्ता अक्षर, अंक, _, और $ की अनुमति देते हैं, किसी अंक से शुरू नहीं कर सकते, आरक्षित शब्द नहीं हो सकते, और केस-संवेदनशील हैं। camelCase का उपयोग करें; भाषा इसे लागू नहीं करता है लेकिन हर उपकरण और सहकर्मी इसे मानते हैं। अर्थ के लिए नामकरण यहां सबसे अधिक-उत्तोलन आदत है, और यह कुछ भी खर्च नहीं करता है, इसलिए r के बजाय remainingCredits को डिफ़ॉल्ट बनाएं।

चर यहां से कहां जाते हैं

चर का आधार है जिस पर बाकी सब कुछ बैठता है: एक मान तब तक उपयोगी नहीं है जब तक इसका एक नाम न हो जिसके द्वारा आप इसे प्राप्त कर सकें। अब आपके पास तीन कदम हैं जो मायने रखते हैं, let के साथ एक मान को संग्रहीत करना, एक को const के साथ लॉक करना, और इसे अच्छी तरह से नाम देना, और आप जो भी प्रोग्राम लिखते हैं उससे सभी तीन का उपयोग करेंगे।

अगले आप डेटा प्रकार में मान को देखेंगे: पाठ, संख्याएं, और बूलियन जो आप संग्रहीत कर रहे हैं, और प्रत्येक एक को ऐसे व्यवहार करने के लिए क्या बनाता है। उसके बाद, ऑपरेटर्स आपको दिखाते हैं कि उन मानों को कैसे संयोजित करें, और फंक्शन्स आपको एक नाम को काम करने का एक हिस्सा करने दें जिस तरह एक चर एक मान को नाम देता है।