S02L04 – जावास्क्रिप्ट में कीवर्ड्स, डेटा प्रकार

html

JavaScript कीवर्ड्स और डेटा प्रकारों को समझना: एक व्यापक गाइड
सामग्री सूची

परिचय ..........................................................1
JavaScript कीवर्ड्स ...................................3

रिज़र्व कीवर्ड्स ..................................4
नए ES6 कीवर्ड्स ..............................6
पुराने कीवर्ड्स ...................................8


JavaScript डेटा प्रकार ..............................10

प्रिमिटिव डेटा प्रकार .........................11
कंप्लेक्स डेटा प्रकार ............................14
JavaScript में डायनेमिक टाइपिंग .........17


निष्कर्ष ............................................................20


परिचय
JavaScript एक बहुमुखी और व्यापक रूप से उपयोग किया जाने वाला प्रोग्रामिंग भाषा है जो डेवलपर्स को डायनेमिक और इंटरैक्टिव वेब एप्लिकेशन बनाने में सक्षम बनाता है। JavaScript में महारत हासिल करने का एक मौलिक पहलू इसके कीवर्ड्स और डेटा प्रकारों को समझना है, जो कुशल और त्रुटि-मुक्त कोड लिखने के लिए आवश्यक निर्माण ब्लॉक हैं।
इस गाइड में, हम JavaScript में उपलब्ध विभिन्न कीवर्ड्स में गहराई से उतरते हैं, जिनमें ES6 में पेश किए गए कीवर्ड्स और वे कीवर्ड्स शामिल हैं जो समय के साथ अप्रचलित हो गए हैं। हम विभिन्न डेटा प्रकारों का भी अन्वेषण करते हैं, प्रिमिटिव प्रकारों जैसे स्ट्रिंग्स और नंबर से लेकर कंप्लेक्स प्रकारों जैसे ऑब्जेक्ट्स और फंक्शन्स तक। चाहे आप एक शुरुआती हों या अपनी बुनियादी ज्ञान को मजबूत करना चाहते हों, यह गाइड आपके JavaScript प्रोग्रामिंग कौशल को बढ़ाने के लिए एक व्यापक अवलोकन प्रदान करती है।
कवर किए गए मुख्य बिंदु:

JavaScript कीवर्ड्स की व्यापक सूची और व्याख्या
JavaScript डेटा प्रकारों का विस्तृत अवलोकन
JavaScript में डायनेमिक टाइपिंग को समझना
बेहतर समझ के लिए व्यावहारिक उदाहरण और कोड स्निपेट्स

फायदे और नुकसान:
फायदे:

कोड की पठनीयता और मेंटेनबिलिटी बढ़ाता है
आम प्रोग्रामिंग त्रुटियों को रोकता है
कुशल मेमोरी प्रबंधन को सुविधाजनक बनाता है

नुकसान:

रिज़र्व कीवर्ड्स का उपयोग वैरिएबल या फंक्शन नाम के रूप में नहीं किया जा सकता, जो नामकरण की लचीलापन को सीमित कर सकता है
डायनेमिक टाइपिंग कभी-कभी अप्रत्याशित टाइप कोएर्शन समस्याओं का कारण बन सकती है

कब और कहाँ उपयोग करें:
कीवर्ड्स और डेटा प्रकारों को समझना JavaScript विकास के सभी चरणों में महत्वपूर्ण है, चाहे आप:

React जैसे फ्रेमवर्क के साथ वेब एप्लिकेशन बना रहे हों
Node.js का उपयोग करके बैकएंड सेवाएं विकसित कर रहे हों
ऑटोमेशन या डेटा प्रोसेसिंग के लिए स्क्रिप्ट लिख रहे हों

तुलनात्मक तालिका: लेगेसी बनाम आधुनिक JavaScript कीवर्ड्स


विशेषता
लेगेसी JavaScript कीवर्ड्स
ES6+ JavaScript कीवर्ड्स


वेरिएबल घोषणाएँ
var
let, const


इटरेशन नियंत्रण
var, function
let, const, for...of, for...in


फंक्शन परिभाषाएँ
function
Arrow functions (=>)


मॉड्यूल्स
None
import, export



JavaScript कीवर्ड्स
JavaScript में कीवर्ड्स रिज़र्व्ड शब्द होते हैं जिनका भाषा की सिंटैक्स में विशेष अर्थ होता है। ये कोड की संरचना और व्यवहार को परिभाषित करने में महत्वपूर्ण भूमिका निभाते हैं। अपने प्रोग्रामों में संघर्ष और त्रुटियों से बचने के लिए इन कीवर्ड्स को समझना आवश्यक है।
रिज़र्व कीवर्ड्स
रिज़र्व कीवर्ड्स वे शब्द हैं जो JavaScript भाषा की सिंटैक्स का हिस्सा हैं और इन्हें आइडेंटिफायर (वेरिएबल नाम, फंक्शन नाम, आदि) के रूप में उपयोग नहीं किया जा सकता।
रिज़र्व कीवर्ड्स की सूची:

कंट्रोल फ्लो कीवर्ड्स: if, else, switch, case, default, for, while, do, break, continue, return, try, catch, finally, throw
वेरिएबल डिक्लेरेशन कीवर्ड्स: var, let, const
फंक्शन कीवर्ड्स: function
क्लास कीवर्ड्स: class, extends, super
अन्य: true, false, null, undefined, new, this, typeof, instanceof, delete, in, void, with, yield, await

उपयोग उदाहरण:




		
		
			
			
Java
			
			    // रिज़र्व कीवर्ड्स का सही उपयोग
    function greet(name) {
        if (name) {
            return `Hello, ${name}!`;
        } else {
            return 'Hello, World!';
        }
    }
			
				
					
				
					1
2
3
4
5
6
7
8
				
						    // रिज़र्व कीवर्ड्स का सही उपयोग
    function greet(name) {
        if (name) {
            return `Hello, ${name}!`;
        } else {
            return 'Hello, World!';
        }
    }
					
				
			
		


नए ES6 कीवर्ड्स
ES6 (ECMAScript 2015) के परिचय के साथ, कई नए कीवर्ड्स उभरे ताकि आधुनिक JavaScript फीचर्स का समर्थन किया जा सके, जिससे भाषा की क्षमताओं में वृद्धि हुई।
ES6 कीवर्ड्स की सूची:

ब्लॉक स्कोप डिक्लेरेशन: let, const
क्लास और इनहेरिटेंस: class, extends, super
मॉड्यूल्स: import, export
एरो फंक्शन्स: => (अरो फंक्शन सिंटैक्स)
प्रॉमिसेस और एसिंक्रोनस प्रोग्रामिंग: async, await
अन्य: yield, static, get, set, of

उपयोग उदाहरण:




		
		
			
			
Java
			
			    // ES6 कीवर्ड्स का उपयोग: class, extends, constructor, super
    class Person {
        constructor(name) {
            this.name = name;
        }
    
        greet() {
            return `Hello, ${this.name}!`;
        }
    }
    
    class Employee extends Person {
        constructor(name, position) {
            super(name);
            this.position = position;
        }
    
        describe() {
            return `${this.name} is a ${this.position}.`;
        }
    }
    
    const employee = new Employee('Alice', 'Developer');
    console.log(employee.greet());     // Output: Hello, Alice!
    console.log(employee.describe());  // Output: Alice is a Developer.
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						    // ES6 कीवर्ड्स का उपयोग: class, extends, constructor, super
    class Person {
        constructor(name) {
            this.name = name;
        }
    
        greet() {
            return `Hello, ${this.name}!`;
        }
    }
    
    class Employee extends Person {
        constructor(name, position) {
            super(name);
            this.position = position;
        }
    
        describe() {
            return `${this.name} is a ${this.position}.`;
        }
    }
    
    const employee = new Employee('Alice', 'Developer');
    console.log(employee.greet());     // Output: Hello, Alice!
    console.log(employee.describe());  // Output: Alice is a Developer.
					
				
			
		


पुराने कीवर्ड्स
समय के साथ, कुछ कीवर्ड्स अप्रचलित हो गए हैं या भविष्य के उपयोग के लिए रिज़र्व्ड हो गए हैं, और इनका उपयोग आधुनिक JavaScript विकास में हतोत्साहित किया जाता है।
पुराने कीवर्ड्स की सूची:

abstract, boolean, byte, char, double, final, float, goto, int, interface, long, native, package, private, protected, public, short, static, synchronized, throws, transient, volatile

उपयोग उदाहरण:




		
		
			
			
Java
			
			    // Deprecated उपयोग: throw और throws
    // आधुनिक JavaScript में केवल 'throw' का उपयोग करने की सिफारिश की जाती है
    
    // सही उपयोग:
    function checkValue(value) {
        if (value === undefined) {
            throw new Error('Value cannot be undefined');
        }
    }
    
    try {
        checkValue();
    } catch (error) {
        console.error(error.message);  // Output: Value cannot be undefined
    }
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						    // Deprecated उपयोग: throw और throws
    // आधुनिक JavaScript में केवल 'throw' का उपयोग करने की सिफारिश की जाती है
    
    // सही उपयोग:
    function checkValue(value) {
        if (value === undefined) {
            throw new Error('Value cannot be undefined');
        }
    }
    
    try {
        checkValue();
    } catch (error) {
        console.error(error.message);  // Output: Value cannot be undefined
    }
					
				
			
		


नोट: भविष्य की संगतता और सर्वोत्तम कोडिंग प्रथाओं का पालन सुनिश्चित करने के लिए पुराने कीवर्ड्स का उपयोग करने से बचें।

JavaScript डेटा प्रकार
JavaScript विभिन्न डेटा प्रकारों का समर्थन करता है, जिन्हें व्यापक रूप से प्रिमिटिव और कंप्लेक्स (रेफरेंस) प्रकारों में वर्गीकृत किया जाता है। इन डेटा प्रकारों को समझना आपके एप्लिकेशन में डेटा को प्रभावी ढंग से हेरफेर करने और संग्रहीत करने के लिए मौलिक है।
प्रिमिटिव डेटा प्रकार
प्रिमिटिव डेटा प्रकार JavaScript के सबसे बुनियादी डेटा प्रकार हैं। ये अपरिवर्तनीय होते हैं और सीधे अपने मानों को रखते हैं।
प्रिमिटिव डेटा प्रकारों की सूची:

String
Number
Boolean
Undefined
Null
Symbol (ES6 में परिचित)
BigInt (ES2020 में परिचित)

1. String
पाठ को प्रदर्शित करने के लिए उपयोग किया जाने वाला अक्षरों का अनुक्रम।
उदाहरण:




		
		
			
			
Java
			
			    let greeting = "Hello, World!";
    console.log(greeting);  // Output: Hello, World!
			
				
					
				
					1
2
				
						    let greeting = "Hello, World!";
    console.log(greeting);  // Output: Hello, World!
					
				
			
		


2. Number
पूरा और फ्लोटिंग-पॉइंट नंबरों दोनों का प्रतिनिधित्व करता है।
उदाहरण:




		
		
			
			
Java
			
			    let age = 25;            // Integer
    let price = 19.99;       // Floating-point number
    let largeNumber = 1e6;   // Exponential notation (1000000)
    console.log(age, price, largeNumber); // Output: 25 19.99 1000000
			
				
					
				
					1
2
3
4
				
						    let age = 25;            // Integer
    let price = 19.99;       // Floating-point number
    let largeNumber = 1e6;   // Exponential notation (1000000)
    console.log(age, price, largeNumber); // Output: 25 19.99 1000000
					
				
			
		


3. Boolean
एक तार्किक इकाई का प्रतिनिधित्व करता है और इसके दो मान हो सकते हैं: true या false।
उदाहरण:




		
		
			
			
Java
			
			    let isStudent = true;
    let hasGraduated = false;
    console.log(isStudent, hasGraduated); // Output: true false
			
				
					
				
					1
2
3
				
						    let isStudent = true;
    let hasGraduated = false;
    console.log(isStudent, hasGraduated); // Output: true false
					
				
			
		


4. Undefined
एक ऐसा वेरिएबल जिसे घोषित किया गया है लेकिन उसे कोई मूल्य असाइन नहीं किया गया है, उसकी प्रकार undefined होती है।
उदाहरण:




		
		
			
			
Java
			
			    let x;
    console.log(x); // Output: undefined
			
				
					
				
					1
2
				
						    let x;
    console.log(x); // Output: undefined
					
				
			
		


5. Null
null एक असाइनमेंट मूल्य है जो कोई मूल्य या कोई ऑब्जेक्ट नहीं दर्शाता है।
उदाहरण:




		
		
			
			
Java
			
			    let selectedItem = null;
    console.log(selectedItem); // Output: null
			
				
					
				
					1
2
				
						    let selectedItem = null;
    console.log(selectedItem); // Output: null
					
				
			
		


6. Symbol (ES6)
ऑब्जेक्ट की प्रॉपर्टीज़ के लिए यूनिक आइडेंटिफायर्स बनाने के लिए उपयोग किया जाता है।
उदाहरण:




		
		
			
			
Java
			
			    let sym1 = Symbol('description');
    let sym2 = Symbol('description');
    console.log(sym1 === sym2); // Output: false
			
				
					
				
					1
2
3
				
						    let sym1 = Symbol('description');
    let sym2 = Symbol('description');
    console.log(sym1 === sym2); // Output: false
					
				
			
		


7. BigInt (ES2020)
वे पूरे नंबर जो 2^53 - 1 से बड़े हैं, जिन्हें Number प्रकार के साथ विश्वसनीय रूप से प्रदर्शित किया जा सकता है, का प्रतिनिधित्व करता है।
उदाहरण:




		
		
			
			
Java
			
			    let bigNumber = 123456789012345678901234567890n;
    console.log(bigNumber); // Output: 123456789012345678901234567890n
			
				
					
				
					1
2
				
						    let bigNumber = 123456789012345678901234567890n;
    console.log(bigNumber); // Output: 123456789012345678901234567890n
					
				
			
		


कंप्लेक्स डेटा प्रकार
कंप्लेक्स डेटा प्रकार ऑब्जेक्ट्स होते हैं जो डेटा के संग्रह और अधिक जटिल संस्थाओं को संग्रहीत कर सकते हैं।
1. Object
ऑब्जेक्ट्स की-वैल्यू पेयर्स के संग्रह होते हैं। ये बहुमुखी होते हैं और JavaScript प्रोग्रामिंग की रीढ़ हैं।
उदाहरण:




		
		
			
			
Java
			
			    let person = {
        firstName: "John",
        lastName: "Doe",
        age: 30
    };
    console.log(person.firstName); // Output: John
			
				
					
				
					1
2
3
4
5
6
				
						    let person = {
        firstName: "John",
        lastName: "Doe",
        age: 30
    };
    console.log(person.firstName); // Output: John
					
				
			
		


2. Array
एरेज़ डेटा के क्रमबद्ध संग्रह होते हैं, जिनमें विभिन्न डेटा प्रकारों के तत्व शामिल हो सकते हैं।
उदाहरण:




		
		
			
			
Java
			
			    let fruits = ["Apple", "Banana", "Cherry"];
    console.log(fruits[1]); // Output: Banana
			
				
					
				
					1
2
				
						    let fruits = ["Apple", "Banana", "Cherry"];
    console.log(fruits[1]); // Output: Banana
					
				
			
		


3. Function
फंक्शन्स JavaScript में फर्स्ट-क्लास ऑब्जेक्ट्स हैं, जिसका अर्थ है कि उन्हें वेरिएबल्स को असाइन किया जा सकता है, आर्गुमेंट्स के रूप में पास किया जा सकता है, और अन्य फंक्शन्स से रिटर्न किया जा सकता है।
उदाहरण:




		
		
			
			
Java
			
			    // वेरिएबल को असाइन किया गया फंक्शन
    let greet = function(name) {
        return `Hello, ${name}!`;
    };
    
    console.log(greet("Alice")); // Output: Hello, Alice!
			
				
					
				
					1
2
3
4
5
6
				
						    // वेरिएबल को असाइन किया गया फंक्शन
    let greet = function(name) {
        return `Hello, ${name}!`;
    };
    
    console.log(greet("Alice")); // Output: Hello, Alice!
					
				
			
		


JavaScript में डायनेमिक टाइपिंग
JavaScript एक डायनेमिकली टाइप्ड भाषा है, जिसका मतलब है कि वेरिएबल प्रकार रनटाइम पर निर्धारित होते हैं और आवश्यकतानुसार बदल सकते हैं।
उदाहरण:




		
		
			
			
Java
			
			    let data = "Hello";
    console.log(typeof data); // Output: string
    
    data = 100;
    console.log(typeof data); // Output: number
    
    data = true;
    console.log(typeof data); // Output: boolean
			
				
					
				
					1
2
3
4
5
6
7
8
				
						    let data = "Hello";
    console.log(typeof data); // Output: string
    
    data = 100;
    console.log(typeof data); // Output: number
    
    data = true;
    console.log(typeof data); // Output: boolean
					
				
			
		


फायदे:

कोडिंग में लचीलापन
तेज़ विकास चक्र

नुकसान:

रनटाइम त्रुटियों की संभावना
टाइप-संबंधी समस्याओं को डिबग करना कठिन

व्यावहारिक उदाहरण और कोड स्निपेट्स
नीचे एक व्यापक उदाहरण दिया गया है जो विभिन्न डेटा प्रकारों और कीवर्ड्स को दर्शाता है जो इस गाइड में चर्चा किए गए हैं:




		
		
			
			
Java
			
			    // उदाहरण: छात्रों की सूची प्रबंधन
    
    // 'let' और 'const' कीवर्ड्स का उपयोग
    const className = "Introduction to JavaScript";
    let students = ["Alice", "Bob", "Charlie"];
    
    // नया छात्र जोड़ने के लिए फंक्शन
    function addStudent(name) {
        if (typeof name !== 'string') {
            throw new TypeError('Name must be a string');
        }
        students.push(name);
        console.log(`${name} has been added to ${className}.`);
    }
    
    // नया छात्र जोड़ना
    addStudent("David"); // Output: David has been added to Introduction to JavaScript.
    
    // अपरिभाषित छात्र जोड़ना (त्रुटि फेंकेगा)
    try {
        addStudent(undefined);
    } catch (error) {
        console.error(error.message); // Output: Name must be a string
    }
    
    // सभी छात्रों को प्रदर्शित करना
    console.log(students); // Output: ["Alice", "Bob", "Charlie", "David"]
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						    // उदाहरण: छात्रों की सूची प्रबंधन
    
    // 'let' और 'const' कीवर्ड्स का उपयोग
    const className = "Introduction to JavaScript";
    let students = ["Alice", "Bob", "Charlie"];
    
    // नया छात्र जोड़ने के लिए फंक्शन
    function addStudent(name) {
        if (typeof name !== 'string') {
            throw new TypeError('Name must be a string');
        }
        students.push(name);
        console.log(`${name} has been added to ${className}.`);
    }
    
    // नया छात्र जोड़ना
    addStudent("David"); // Output: David has been added to Introduction to JavaScript.
    
    // अपरिभाषित छात्र जोड़ना (त्रुटि फेंकेगा)
    try {
        addStudent(undefined);
    } catch (error) {
        console.error(error.message); // Output: Name must be a string
    }
    
    // सभी छात्रों को प्रदर्शित करना
    console.log(students); // Output: ["Alice", "Bob", "Charlie", "David"]
					
				
			
		


व्याख्या:

उपयोग किए गए कीवर्ड्स:

const का उपयोग className के लिए किया गया है जिससे यह अपरिवर्तनीय रहता है।
let का उपयोग students के लिए किया गया है जिससे इसे संशोधित किया जा सकता है।


डेटा प्रकार:

className एक String है।
students एक Array of Strings है।


फंक्शनैलिटी:

addStudent फंक्शन typeof ऑपरेटर का उपयोग करके डेटा प्रकार जांचने और त्रुटियों को हैंडल करने का प्रदर्शन करता है।


आउटपुट:

सफलतापूर्वक एक नया छात्र जोड़ता है और गलत डेटा प्रकार को सुगमता से संभालता है।




निष्कर्ष
JavaScript कीवर्ड्स और डेटा प्रकारों में महारत हासिल करना प्रभावी और कुशल कोड लिखने के लिए आवश्यक है। रिज़र्व कीवर्ड्स, ES6 और बाद के नए जोड़, और प्रिमिटिव और कंप्लेक्स डेटा प्रकारों की बारीकियों को समझकर, डेवलपर्स JavaScript की पूरी शक्ति का उपयोग करके मजबूत अनुप्रयोग बना सकते हैं।
मुख्य निष्कर्ष:

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

SEO ऑप्टिमाइज़्ड कीवर्ड्स:
JavaScript कीवर्ड्स, JavaScript डेटा प्रकार, ES6 कीवर्ड्स, JavaScript प्रोग्रामिंग, डायनेमिक टाइपिंग, प्रिमिटिव डेटा प्रकार, कंप्लेक्स डेटा प्रकार, JavaScript ट्यूटोरियल्स, JavaScript सीखना, JavaScript शुरुआती के लिए, JavaScript फंक्शन्स, JavaScript ऑब्जेक्ट्स, JavaScript एरेज़, typeof ऑपरेटर, JavaScript बेस्ट प्रैक्टिसेज़, JavaScript कोडिंग स्टैंडर्ड्स

उदाहरण प्रोग्राम कोड के साथ व्याख्या
नीचे एक नमूना JavaScript प्रोग्राम दिया गया है जो इस गाइड में चर्चा किए गए विभिन्न कीवर्ड्स और डेटा प्रकारों के उपयोग को दर्शाता है।




		
		
			
			
Java
			
			    // नमूना प्रोग्राम: स्टूडेंट मैनेजमेंट सिस्टम
    
    // अपरिवर्तनीय डेटा के लिए 'const' का उपयोग
    const schoolName = "Tech Academy";
    
    // परिवर्तनीय डेटा के लिए 'let' का उपयोग
    let students = [];
    
    // छात्र जोड़ने के लिए फंक्शन
    function addStudent(name, age) {
        if (typeof name !== 'string') {
            throw new TypeError('Student name must be a string.');
        }
        if (typeof age !== 'number') {
            throw new TypeError('Student age must be a number.');
        }
        
        // छात्र ऑब्जेक्ट बनाना
        const student = {
            name: name,
            age: age,
            enrolled: true
        };
        
        students.push(student);
        console.log(`${name} has been enrolled in ${schoolName}.`);
    }
    
    // छात्रों को जोड़ना
    addStudent("Emily", 22); // Output: Emily has been enrolled in Tech Academy.
    addStudent("Daniel", 25); // Output: Daniel has been enrolled in Tech Academy.
    
    // सभी छात्रों को प्रदर्शित करना
    console.log(students);
    /*
    Output:
    [
        { name: 'Emily', age: 22, enrolled: true },
        { name: 'Daniel', age: 25, enrolled: true }
    ]
    */
    
    // छात्र नाम प्रदर्शित करने के लिए फंक्शन
    function displayStudentNames() {
        students.forEach(function(student) {
            console.log(student.name);
        });
    }
    
    displayStudentNames();
    /*
    Output:
    Emily
    Daniel
    */
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
				
						    // नमूना प्रोग्राम: स्टूडेंट मैनेजमेंट सिस्टम
    
    // अपरिवर्तनीय डेटा के लिए 'const' का उपयोग
    const schoolName = "Tech Academy";
    
    // परिवर्तनीय डेटा के लिए 'let' का उपयोग
    let students = [];
    
    // छात्र जोड़ने के लिए फंक्शन
    function addStudent(name, age) {
        if (typeof name !== 'string') {
            throw new TypeError('Student name must be a string.');
        }
        if (typeof age !== 'number') {
            throw new TypeError('Student age must be a number.');
        }
        
        // छात्र ऑब्जेक्ट बनाना
        const student = {
            name: name,
            age: age,
            enrolled: true
        };
        
        students.push(student);
        console.log(`${name} has been enrolled in ${schoolName}.`);
    }
    
    // छात्रों को जोड़ना
    addStudent("Emily", 22); // Output: Emily has been enrolled in Tech Academy.
    addStudent("Daniel", 25); // Output: Daniel has been enrolled in Tech Academy.
    
    // सभी छात्रों को प्रदर्शित करना
    console.log(students);
    /*
    Output:
    [
        { name: 'Emily', age: 22, enrolled: true },
        { name: 'Daniel', age: 25, enrolled: true }
    ]
    */
    
    // छात्र नाम प्रदर्शित करने के लिए फंक्शन
    function displayStudentNames() {
        students.forEach(function(student) {
            console.log(student.name);
        });
    }
    
    displayStudentNames();
    /*
    Output:
    Emily
    Daniel
    */
					
				
			
		


कोड व्याख्या:

कांस्टेंट्स और वेरिएबल्स:

schoolName को const का उपयोग करके घोषित किया गया है क्योंकि स्कूल का नाम नहीं बदलता है।
students को let का उपयोग करके घोषित किया गया है क्योंकि हम इस एरे में छात्रों को जोड़ेंगे।


addStudent फंक्शन:

पैरामीटर्स: name (String), age (Number)
टाइप चेकिंग: typeof का उपयोग करके सही डेटा प्रकार सुनिश्चित करता है।
त्रुटि हैंडलिंग: गलत डेटा प्रकार होने पर त्रुटियाँ फेंकता है।
ऑब्जेक्ट क्रिएशन: नाम, उम्र, और enrolled प्रॉपर्टीज़ के साथ एक छात्र ऑब्जेक्ट बनाता है।
एरे में जोड़ना: छात्र ऑब्जेक्ट को students एरे में पुश करता है।
कंसोल आउटपुट: दाखिले की पुष्टि करता है।


छात्र जोड़ना:

दो छात्रों, Emily और Daniel, को उनकी उम्र के साथ जोड़ता है।


छात्र प्रदर्शित करना:

पूरे students एरे को लॉग करता है जिसमें छात्र ऑब्जेक्ट्स होते हैं।


displayStudentNames फंक्शन:

students एरे पर forEach का उपयोग करके इटरेट करता है।
प्रत्येक छात्र का नाम व्यक्तिगत रूप से लॉग करता है।



आउटपुट:




		
		
			
			
Java
			
			Emily has been enrolled in Tech Academy.
Daniel has been enrolled in Tech Academy.
[
    { name: 'Emily', age: 22, enrolled: true },
    { name: 'Daniel', age: 25, enrolled: true }
]
Emily
Daniel
			
				
					
				
					1
2
3
4
5
6
7
8
				
						Emily has been enrolled in Tech Academy.
Daniel has been enrolled in Tech Academy.
[
    { name: 'Emily', age: 22, enrolled: true },
    { name: 'Daniel', age: 25, enrolled: true }
]
Emily
Daniel
					
				
			
		


यह नमूना प्रोग्राम const, let, function जैसे कीवर्ड्स के व्यावहारिक अनुप्रयोग को प्रदर्शित करता है, और स्ट्रिंग, नंबर, और ऑब्जेक्ट जैसे डेटा प्रकारों का उपयोग करता है। यह throw का उपयोग करके त्रुटि हैंडलिंग और typeof ऑपरेटर के साथ टाइप चेकिंग को भी दिखाता है।
नोट: यह लेख AI द्वारा जनरेट किया गया है।
विशेषता	लेगेसी JavaScript कीवर्ड्स	ES6+ JavaScript कीवर्ड्स
वेरिएबल घोषणाएँ	var	let, const
इटरेशन नियंत्रण	var, function	let, const, for...of, for...in
फंक्शन परिभाषाएँ	function	Arrow functions (=>)
मॉड्यूल्स	None	import, export