स्ट्रिंग्स

docs.scrimba.com

आप एक साइन इन किए गए उपयोगकर्ता के लिए एक अभिनंदन बना रहे हैं, और उनका नाम एक वेरिएबल में है। आपको पृष्ठ पर "Welcome back, प्रिया" कहना है बिना "प्रिया" को हाथ से टाइप किए, क्योंकि कल यह राज है, और उसके बाद यह कोई ऐसा है जिसे आपने कभी नहीं सुना है। पाठ जिसे आप तुरंत बना सकते हैं, माप सकते हैं और पुन: आकार दे सकते हैं, एक स्ट्रिंग है, और यह अध्याय उनके साथ काम करने के बारे में है।

स्ट्रिंग्स बनाना

एक स्ट्रिंग पाठ है: quotes में लपेटे गए किसी भी रन का। आप single quotes या double quotes का उपयोग कर सकते हैं, और वे समान व्यवहार करते हैं, इसलिए एक को चुनें और सुसंगत रहें।

const firstName = "प्रिया";
const greeting = "स्वागत है";

स्ट्रिंग बनाने का सबसे उपयोगी तरीका एक template literal है, जिसे quotes के बजाय backticks के साथ लिखा जाता है। एक template literal के अंदर आप ${...} के साथ पाठ में एक value को छोड़ सकते हैं, और JavaScript जो भी उस value को धारण करता है उसे भर देता है:

const firstName = "प्रिया";
const message = `स्वागत है, ${firstName}`;
console.log(message); // स्वागत है, प्रिया

वह ${firstName} एक स्लॉट है। जब स्ट्रिंग बनाई जाती है, तो स्लॉट को firstName के value से replace किया जाता है। जब भी आप pieces से बाहर पाठ बना रहे हों तो template literals का उपयोग करें।

एक स्ट्रिंग पाठ से बना एक value है। Single quotes और double quotes समान strings का उत्पादन करते हैं, इसलिए उनके बीच चुनाव style और इस बारे में है कि किस quote character को शामिल करने की आवश्यकता है: "it's here" escaping से बचता है, और 'she said "hi"' भी करता है।

जिस form को प्राथमिकता दें वह template literal है, backticks के साथ लिखी गई एक स्ट्रिंग। यह दो चीजें करता है जो सामान्य quotes नहीं कर सकते। यह ${...} के साथ values को interpolate करता है, किसी भी expression के परिणाम को सीधे पाठ में छोड़ता है, और यह बिना विशेष escape के कई लाइनों तक विस्तृत हो सकता है:

const firstName = "प्रिया";
const itemCount = 3;
const message = `स्वागत है, ${firstName}। आपके पास ${itemCount} items प्रतीक्षा में हैं।`;
console.log(message); // स्वागत है, प्रिया। आपके पास 3 items प्रतीक्षा में हैं।

कोई भी चीज़ जो एक value का उत्पादन करती है वह स्लॉट में जा सकती है, न कि केवल variable names, इसलिए ${itemCount} समान रूप से ${itemCount + 1} हो सकता है। ${...} के साथ पाठ बनाना quotes और plus signs के साथ pieces को glue करने की तुलना में बहुत स्वच्छ पढ़ता है, यही कारण है कि यह डिफ़ॉल्ट है।

एक string JavaScript का पाठ primitive है: language के basic value types में से एक, numbers और booleans के साथ-साथ (पूर्ण set के लिए data types देखें)। Single और double quotes interchangeable हैं और बिल्कुल same value का उत्पादन करते हैं; एकमात्र वास्तविक निर्णय जो वे force करते हैं वह है कि किस quote character को अन्यथा escape करना होगा।

जिस form पर डिफ़ॉल्ट करना लायक है वह template literal है, backticks द्वारा delimited। यह किसी भी expression को ${...} के साथ interpolate करता है, अंदर क्या है यह evaluate करता है और परिणाम को एक string के लिए coerce करता है, और यह literal newlines को preserve करता है इसलिए multi-line text को कोई \n की आवश्यकता नहीं है:

const firstName = "प्रिया";
const itemCount = 3;
const summary = `हाय ${firstName}, आपके पास ${itemCount} items हैं और ${itemCount === 1 ? "यह है" : "वे हैं"} प्रतीक्षा में।`;
console.log(summary); // हाय प्रिया, आपके पास 3 items हैं और वे हैं प्रतीक्षा में।

स्लॉट एक expression रखता है, न कि केवल एक name, इसलिए arithmetic, method calls, और comparisons सभी इसके अंदर काम करते हैं। वह expressiveness वही है जो interpolation को concatenation को हराता है दो-भाग वाली string से कुछ भी अधिक के लिए: final text का आकार source में readable रहता है। एक ही habit जो build करने लायक है वह है backticks को डिफ़ॉल्ट रूप से reach करना और plain quotes पर केवल एक fixed, single-piece string के लिए drop करना जहां interpolation आपको कुछ नहीं बनाता है।

Junoस्ट्रिंग्स बनाना एक string quotes में पाठ है, और single या double quotes दोनों समान तरीके से काम करते हैं, इसलिए एक को चुनें और इसे सुसंगत रखें। pieces से बाहर पाठ बनाने के लिए, एक template literal का उपयोग करें: backticks with ${...} slots जो आपकी values से भरे जाते हैं। यह वह tool है जिसे आप सबसे अधिक reach करेंगे।

Junoस्ट्रिंग्स बनाना Single और double quotes समान strings बनाते हैं, इसलिए आप जिस quote की आवश्यकता है बिना escaping के चुनें। हालांकि template literals पर डिफ़ॉल्ट रखें: backticks आपको किसी भी value को ${...} के साथ drop करने देते हैं और बिना किसी चीज़ के कई लाइनें span करते हैं। एक बार interpolate करने के बाद, strings को हाथ से glue करना करना बंद कर देता है।

Junoस्ट्रिंग्स बनाना Quotes interchangeable हैं; केवल एक चीज़ जो एक को दूसरे पर pick करती है वह है कि किस character को escape करना होगा। Backticks पर डिफ़ॉल्ट रूप से reach करें क्योंकि ${...} एक पूरे expression को लेता है, न कि केवल एक name, इसलिए arithmetic और comparisons पाठ के अंदर सही तरीके से काम करते हैं। Plain quotes को fixed single-piece strings के लिए रखें जहां interpolation कुछ नहीं कमाता है।

जोड़ना और मापना

आप दो strings को + operator के साथ जोड़ सकते हैं। इसे concatenation कहा जाता है:

const firstName = "राज";
const greeting = "नमस्ते " + firstName;
console.log(greeting); // नमस्ते राज

'नमस्ते ' के अंदर space पर ध्यान दें। Concatenation strings को बिल्कुल जैसा लिखा है glue करता है, इसलिए अगर आप space भूल जाते हैं तो आपको नमस्तेराज मिलता है। एक template literal आमतौर पर same job के लिए बेहतर पढ़ता है: `नमस्ते ${firstName}`।

हर string अपनी length जानता है। इसे .length के साथ पूछें:

const firstName = "राज";
console.log(firstName.length); // 3

आप square brackets का उपयोग करके अपनी position द्वारा एक single character भी पढ़ सकते हैं, zero से counting:

const firstName = "राज";
console.log(firstName[0]); // र

पहला character position 0 पर है, न कि 1। वह zero-based counting JavaScript में हर जगह है, इसलिए अभी comfortable हो जाना लायक है।

दो strings + के साथ जुड़ते हैं, एक operation जिसे concatenation कहा जाता है। यह काम करता है, लेकिन यह जल्दी noisy हो जाता है, क्योंकि हर literal space और separator को quotes के अंदर टाइप किया जाना है:

const firstName = "राज";
const lastName = "शर्मा";
console.log("नमस्ते " + firstName + " " + lastName); // नमस्ते राज शर्मा

एक template literal के रूप में same line `नमस्ते ${firstName} ${lastName}` है, यही कारण है कि interpolation एक से अधिक pieces के साथ कुछ भी के लिए डिफ़ॉल्ट है।

एक string .length के साथ अपने आकार की रिपोर्ट करता है, इसके characters की एक count:

const firstName = "राज";
console.log(firstName.length); // 3

और आप square brackets के साथ एक single character को index द्वारा पढ़ते हैं, zero से counting, तो firstName[0] first character है और firstName[2] five-character string का last है:

const firstName = "राज";
console.log(firstName[0]); // र

Indexing zero-based है: पहला character position 0 पर है।

Strings + के साथ जुड़ते हैं, एक operation जिसे concatenation कहा जाता है। यह एक quick two-part join के लिए ठीक है, लेकिन ध्यान दें कि + overloaded है: एक string के दोनों ओर यह concatenate करता है, और एक number को mix करने से वह number एक string के लिए coerce होता है, इसलिए 'कुल: ' + 3 'कुल: 3' देता है जबकि 3 + 3 6 देता है। Template literals ambiguity को हमेशा text produce करके sidestep करते हैं, जो सबसे सरल case से परे उन्हें prefer करने का एक और कारण है।

.length एक property है, method नहीं, इसलिए आप इसे parentheses के बिना read करते हैं:

const label = "शर्मा";
console.log(label.length); // 5

Square brackets के साथ Indexing zero-based है और एक one-character string return करता है:

const label = "शर्मा";
console.log(label[0]); // श

एक चीज़ जो ध्यान में रखने की है: .length string के underlying units count करता है, हमेशा जो एक human "characters" कहेगा नहीं। साधारण पाठ के लिए दोनों match करते हैं। कुछ emoji और combined characters के लिए वे नहीं करते, क्योंकि एक single visible symbol एक से अधिक unit के रूप में store किया जा सकता है, इसलिए '😀'.length 2 report करता है। यह शायद ही कभी आपको काटता है, लेकिन जब emoji के साथ पाठ के लिए "letters" की एक count गलत दिखती है, तो वह mismatch यही है।

Junoजोड़ना और मापना Strings को + के साथ जोड़ें, लेकिन अपने स्वयं के spaces शामिल करना याद रखें, या नमस्ते और एक name एक साथ run करें। एक template literal आमतौर पर same चीज़ के लिए cleaner है। .length का उपयोग characters count करने के लिए करें, और name[0] जैसे square brackets का उपयोग one को position द्वारा read करने के लिए करें, zero से counting।

Junoजोड़ना और मापना+ concatenate करता है, लेकिन जिस क्षण आपके पास दो से अधिक pieces हैं यह noisy हो जाता है, इसलिए template literals कुछ भी real के लिए जीतते हैं। .length characters count करता है और parentheses नहीं लेता क्योंकि यह एक property है। name[0] के साथ Indexing zero-based है, इसलिए पहला character position 0 पर बैठता है और last length minus one पर।

Junoजोड़ना और मापना+ overloaded है: string plus कुछ भी concatenate करता है और coerce करता है, जो surprises का एक quiet source है, इसलिए template literals पर lean करें। .length एक property है, कोई parentheses नहीं। यह storage units count करता है, हमेशा visible characters नहीं, इसलिए एक emoji 2 की length report कर सकता है। वह gap केवल unicode के साथ दिखता है, लेकिन यह जानने के लिए लायक है इससे पहले कि यह आपको confuse करे।

उपयोगी string methods

Strings built-in methods के साथ आते हैं: actions जो आप एक dot लिख कर और method name को लिख कर एक string पर run करते हैं। यहाँ वे हैं जिनका आप सबसे अधिक उपयोग करेंगे।

toUpperCase() और toLowerCase() के साथ case बदलें:

const firstName = "प्रिया";
console.log(firstName.toUpperCase()); // प्रिया

जांचें कि क्या एक piece of text दूसरे के अंदर दिखाई देता है includes() के साथ, जो true या false के साथ जवाब देता है:

const message = "स्वागत है";
console.log(message.includes("है")); // true

एक string के कुछ हिस्से को slice() के साथ काट दें, इसे start position और कहाँ रुकना है दें। trim() के साथ stray spaces को ends से साफ करें। और replace() के साथ एक piece of text को दूसरे के साथ swap करें:

const raw = "  नमस्ते  ";
console.log(raw.trim()); // नमस्ते

const message = "नमस्ते राज";
console.log(message.replace("राज", "प्रिया")); // नमस्ते प्रिया

बहुत सारी और string methods हैं, और आपको उन्हें याद रखने की आवश्यकता नहीं है। इन पांच को सीखें, और जब एक job उन्हें call करे तो बाकी को look up करें।

Strings methods carry करते हैं, functions जिन्हें आप एक dot के साथ एक string पर call करते हैं, और एक handful अधिकांश day-to-day work को cover करता है।

toUpperCase() और toLowerCase() case change करते हैं, जो उपयोगकर्ता द्वारा टाइप किए गए पाठ की तुलना करने के लिए handy है बिना capitalization के बारे में चिंता किए। includes() एक boolean return करता है कि क्या एक string दूसरे के अंदर दिखाई देता है:

const email = "[email protected]";
console.log(email.toLowerCase().includes("@site.com")); // true

slice(start, end) एक section pull करता है, start index से लेकर लेकिन end index को शामिल किए बिना। trim() दोनों ends से whitespace remove करता है, जो आप लगभग किसी भी user input पर want करते हैं। replace() एक piece of text के पहले match को दूसरे के साथ swap करता है:

const raw = "  order-2024  ";
const clean = raw.trim(); // 'order-2024'
console.log(clean.slice(0, 5)); // order
console.log(clean.replace("order", "invoice")); // invoice-2024

ये पांच workhorses हैं। बहुत अधिक exist करते हैं, इसलिए जब आप कुछ ऐसा hit करें तो reference के लिए reach करें जो वे cover नहीं करते, लेकिन इन पर lean करने की expect करें।

Strings एक बड़े set को expose करते हैं methods, functions जिन्हें आप एक dot के साथ value पर invoke करते हैं। एक छोटा core अधिकांश load carry करता है: toUpperCase() / toLowerCase() case के लिए, includes() एक boolean substring check के लिए, slice(start, end) एक section extract करने के लिए (start inclusive, end exclusive, और negatives end से count करते हैं), trim() surrounding whitespace strip करने के लिए, और replace() substitution के लिए।

property जो उन्हें एक साथ बांधता है: string methods original को कभी नहीं बदलते, वे एक नई string return करते हैं। Strings immutable हैं, मतलब एक string value को place में alter नहीं किया जा सकता, इसलिए हर method आपको एक fresh string hand करता है और source को untouched छोड़ता है:

const raw = "  प्रिया शर्मा  ";
const cleaned = raw.trim().toLowerCase();
console.log(cleaned); // प्रिया शर्मा
console.log(raw); // '  प्रिया शर्मा  '  (unchanged)

क्योंकि result स्वयं एक string है, methods chain, जैसा कि trim().toLowerCase() ऊपर दिखाता है। दो edge cases worth carrying: replace() केवल पहले match को swap करता है जब तक आप सभी के लिए ask न करें, और indexing end से beyond undefined return करता है न कि एक error, इसलिए raw[999] undefined है, एक crash नहीं। वह silent undefined उस चीज़ का एक kind है जो बाद में एक confusing result के रूप में surface होती है न कि एक clear failure के रूप में।

Junoउपयोगी string methods Methods actions हैं जो आप एक dot के साथ एक string पर run करते हैं: toUpperCase(), includes() एक हाँ या नहीं check के लिए, slice() एक part को काटने के लिए, trim() stray spaces को remove करने के लिए, और replace() पाठ को swap करने के लिए। बहुत अधिक हैं, इसलिए ये पांच सीखें और rest को look up करें जब आपको उनकी आवश्यकता हो।

Junoउपयोगी string methods पांच पर lean करें: toUpperCase() और toLowerCase() case के लिए, includes() एक boolean check के लिए, slice(start, end) extract करने के लिए (end included नहीं है), trim() user input के लिए, और replace() पहले match के लिए। बहुत अधिक exist करते हैं, इसलिए जब ये fall short करें तो reference के लिए reach करें, लेकिन ये अधिकांश days को cover करते हैं।

Junoउपयोगी string methods Core five हैं toUpperCase/toLowerCase, includes, slice, trim, और replace, और वे सभी एक नई string return करते हैं क्योंकि strings immutable हैं, तो results chain करते हैं और original कभी नहीं बदलता। दो traps: replace डिफ़ॉल्ट रूप से केवल पहले match को hit करता है, और indexing end से beyond undefined देता है एक clean crash के बजाय, जो बाद में एक puzzling result के रूप से surface करता है।

Strings अगले कहाँ जाते हैं

Strings JavaScript के core building blocks में से एक हैं, और आपके पास अब वह pieces हैं जो matter करते हैं: उन्हें quotes या template literals के साथ बनाना, उन्हें जोड़ना और मापना, और उन्हें methods के साथ reshape करना जो हमेशा कुछ नया return करते हैं। same dot-and-method pattern जिसे आपने यहाँ उपयोग किया है अन्य types पर दिखता है, सबसे विशेष रूप से जब आप array methods में lists के साथ काम करना शुरू करते हैं।

पाठ भी शायद ही कभी अकेले travels करता है। जिस moment आप एक count, एक price, या एक total दिखाते हैं, आप strings को numbers के साथ mixing कर रहे हैं, और template literals वह है जो आप दोनों को एक साथ cleanly stitch करते हैं।