S06L02 - फंक्शन्स पैरामीटर्स और आर्गुमेंट्स

html

JavaScript में Function Parameters और Arguments को समझना
सामग्री तालिका

परिचय .......................................... 1
Function Parameters बनाम Arguments ... 3
JavaScript में Default Parameters ...... 7
Undefined Parameters को संभालना ........ 12
Parameters और Arguments के उपयोग के लिए सर्वोत्तम प्रथाएँ ....... 17
निष्कर्ष ............................................. 22
अतिरिक्त संसाधन .......................... 24

परिचय
JavaScript प्रोग्रामिंग के क्षेत्र में, function parameters और arguments को समझना मूलभूत है। Functions JavaScript अनुप्रयोगों के building blocks हैं, जो developers को reusable और efficient code लिखने में सक्षम बनाते हैं। यह eBook function parameters और arguments की intricacies में गोता लगाता है, उनके roles, differences, और best practices को elucidate करता है। चाहे आप beginner हों या basic knowledge वाले developer, यह guide आपके projects में इन concepts की समझ और application को बढ़ाएगा।
Parameters और Arguments का महत्व
Parameters और arguments functions को ऑपरेट करने और data के साथ interact करने के लिए आवश्यक हैं। ये functions को input स्वीकार करने, उसे process करने, और परिणाम लौटाने की अनुमति देते हैं, जिससे आपका code dynamic और versatile बनता है। इन concepts में महारत हासिल करने से आपका codebases अधिक readable, maintainable, और efficient बनता है।
Pros and Cons
Pros:

Reusability: Functions विभिन्न inputs के साथ पुन: प्रयोग किए जा सकते हैं।
Modularity: Code को manageable हिस्सों में organize किया जाता है।
Maintainability: अपडेट करना और debug करना आसान होता है।

Cons:

Complexity: Mismanagement से bugs और undefined behaviors हो सकते हैं।
Overhead: अत्यधिक parameters के उपयोग से functions बोझिल हो सकते हैं।

Parameters और Arguments का उपयोग कब और कहाँ करें
Functions को varying inputs के आधार पर operations perform करने की आवश्यकता होने पर parameters और arguments का उपयोग करना चाहिए। ये विशेष रूप से scenarios में उपयोगी हैं जो data manipulation, user input handling, और dynamic responses की आवश्यकता होती हैं।
Comparison Table: Parameters vs. Arguments


विशेषता
Parameters
Arguments


परिभाषा
Functions की signatures में defined variables।
Functions को कॉल करते समय पास किए गए actual values।


उपयोग संदर्भ
Function definitions के भीतर उपयोग किए जाते हैं।
Functions को invoke/call करते समय उपयोग किए जाते हैं।


उदाहरण




		
		
			
			
Java
			
			function greet(name) {}
			
				
					
				
					1
				
						function greet(name) {}
					
				
			
		






		
		
			
			
Java
			
			greet("John");
			
				
					
				
					1
				
						greet("John");
					
				
			
		




लचीलापन
Default values हो सकते हैं।
Calls के आधार पर number और type में भिन्न हो सकते हैं।


Range और Size Comparison Table


विशेषता
JavaScript
अन्य भाषाएँ (जैसे Java, C++)


Parameter Flexibility
Highly flexible, allows undefined parameters.
Strict, often requires exact number of arguments.


Default Parameters
Supported using default values.
Limited support, often requires method overloading.


Argument Passing
Pass-by-value for primitives, pass-by-reference for objects.
Varies, commonly pass-by-value or reference based on type.


Function Parameters बनाम Arguments
परिभाषाएं और अंतर
Parameters functions की definition में listed variables होते हैं, जो उन values के लिए placeholders का काम करते हैं जिनपर function operate करेगा। Arguments, दूसरी ओर, actual values होते हैं जो function को invoke करते समय पास किए जाते हैं।
उदाहरण:




		
		
			
			
Java
			
			
function greet(name) { // 'name' एक parameter है
    console.log("Hello, " + name + "!");
}

greet("John"); // "John" एक argument है

			
				
					
				
					1
2
3
4
5
6
7
				
						 
function greet(name) { // 'name' एक parameter है
    console.log("Hello, " + name + "!");
}
 
greet("John"); // "John" एक argument है
 
					
				
			
		


ऊपर के उदाहरण में, name greet function के भीतर एक parameter है, जबकि "John" function call के दौरान प्रदान किया गया argument है।
Interchangeability
हालांकि parameters और arguments को आम बातचीत में अक्सर परस्पर उपयोग किया जाता है, ये functions operations में विशिष्ट भूमिकाएँ निभाते हैं। इस अंतर को समझना स्पष्ट और प्रभावी code लिखने के लिए महत्वपूर्ण है।
Multiple Parameters को संभालना
Functions multiple parameters स्वीकार कर सकते हैं, जिससे वे अधिक जटिल operations perform कर सकते हैं।
उदाहरण:




		
		
			
			
Java
			
			
function introduce(name, topic, experience) {
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}

introduce("John", "JavaScript", "fun");

			
				
					
				
					1
2
3
4
5
6
7
				
						 
function introduce(name, topic, experience) {
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}
 
introduce("John", "JavaScript", "fun");
 
					
				
			
		


Default Parameters बनाम Undefined Parameters
JavaScript functions को default parameter values रखने की अनुमति देता है, जिससे function operate करता है भले ही कुछ arguments प्रदान न किए गए हों।
Default Parameters Example:




		
		
			
			
Java
			
			
function greet(name = "Guest") {
    console.log("Hello, " + name + "!");
}

greet(); // Outputs: Hello, Guest!
greet("John"); // Outputs: Hello, John!

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
function greet(name = "Guest") {
    console.log("Hello, " + name + "!");
}
 
greet(); // Outputs: Hello, Guest!
greet("John"); // Outputs: Hello, John!
 
					
				
			
		


Handling Undefined Parameters:
अगर arguments प्रदान नहीं किए गए हैं, तो बिना default values वाले parameters undefined होंगे, जिससे unexpected behaviors हो सकते हैं।
उदाहरण:




		
		
			
			
Java
			
			
function greet(name) {
    console.log("Hello, " + name + "!");
}

greet(); // Outputs: Hello, undefined!

			
				
					
				
					1
2
3
4
5
6
7
				
						 
function greet(name) {
    console.log("Hello, " + name + "!");
}
 
greet(); // Outputs: Hello, undefined!
 
					
				
			
		


JavaScript में Default Parameters
Default Values सेट करना
Default parameters functions को default values के साथ initialize करने का तरीका प्रदान करते हैं अगर function call के दौरान कोई arguments पास नहीं किए गए हों।
उदाहरण:




		
		
			
			
Java
			
			
function greet(name = "Chand", topic = "JavaScript", experience = "fun") {
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}

greet(); // Outputs: This is Chand, we are learning JavaScript, and it’s fun.
greet("Ashley"); // Outputs: This is Ashley, we are learning JavaScript, and it’s fun.

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
function greet(name = "Chand", topic = "JavaScript", experience = "fun") {
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}
 
greet(); // Outputs: This is Chand, we are learning JavaScript, and it’s fun.
greet("Ashley"); // Outputs: This is Ashley, we are learning JavaScript, and it’s fun.
 
					
				
			
		


Default Parameters के लाभ

अपरिभाषित मूल्यों को रोकता है: सुनिश्चित करता है कि parameters के पास meaningful default values हों।
Functionality को बढ़ाता है: functions को अधिक flexible और robust बनाता है।
Function Calls को सरल बनाता है: हर बार सभी arguments पास करने की आवश्यकता को कम करता है।

उदाहरण परिदृश्य
एक function को consider करें जो एक user को introduce करता है। Default parameters के साथ, function default values प्रदान कर सकता है अगर कुछ जानकारी गायब हो।
उदाहरण:




		
		
			
			
Java
			
			
function introduceUser(name = "Andy", topic = "React", experience = "great") {
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}

introduceUser("John", "Vue"); // Outputs: This is John, we are learning Vue, and it’s great.
introduceUser(); // Outputs: This is Andy, we are learning React, and it’s great.

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
function introduceUser(name = "Andy", topic = "React", experience = "great") {
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}
 
introduceUser("John", "Vue"); // Outputs: This is John, we are learning Vue, and it’s great.
introduceUser(); // Outputs: This is Andy, we are learning React, and it’s great.
 
					
				
			
		


Comments के साथ Code Implementation




		
		
			
			
Java
			
			
// Default parameters वाले function
function introduceUser(name = "Andy", topic = "React", experience = "great") {
    // Introduction संदेश प्रदर्शित करें
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}

// सभी arguments के साथ function call करना
introduceUser("John", "Vue", "amazing");
// Output: This is John, we are learning Vue, and it’s amazing.

// कुछ arguments गायब रखते हुए function call करना
introduceUser("John", "Vue");
// Output: This is John, we are learning Vue, and it’s great.

// बिना किसी argument के function call करना
introduceUser();
// Output: This is Andy, we are learning React, and it’s great.

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
// Default parameters वाले function
function introduceUser(name = "Andy", topic = "React", experience = "great") {
    // Introduction संदेश प्रदर्शित करें
    console.log(`This is ${name}, we are learning ${topic}, and it’s ${experience}.`);
}
 
// सभी arguments के साथ function call करना
introduceUser("John", "Vue", "amazing");
// Output: This is John, we are learning Vue, and it’s amazing.
 
// कुछ arguments गायब रखते हुए function call करना
introduceUser("John", "Vue");
// Output: This is John, we are learning Vue, and it’s great.
 
// बिना किसी argument के function call करना
introduceUser();
// Output: This is Andy, we are learning React, and it’s great.
 
					
				
			
		


Step-by-Step Explanation

Function Definition:

introduceUser को तीन parameters के साथ define किया गया है: name, topic, और experience।
प्रत्येक parameter के पास default value है: "Andy", "React", और "great" क्रमशः।


Function Calls:

जब सभी arguments प्रदान किए जाते हैं, function उन्हें message निर्माण के लिए उपयोग करता है।
अगर कुछ arguments गायब होते हैं, function default values का उपयोग करता है।
अगर कोई argument प्रदान नहीं किया जाता है, तो सभी parameters अपनी default values ले लेते हैं।



Handling Undefined Parameters
Undefined Values की समस्या
जब एक function को सभी आवश्यक arguments के बिना कॉल किया जाता है, तो गायब parameters undefined होते हैं। अगर इसे ठीक से संभाला नहीं गया, तो runtime errors या unexpected behaviors हो सकते हैं।
उदाहरण:




		
		
			
			
Java
			
			
function displayInfo(name, age) {
    console.log(`${name} is ${age} years old.`);
}

displayInfo("John"); // Outputs: John is undefined years old.

			
				
					
				
					1
2
3
4
5
6
7
				
						 
function displayInfo(name, age) {
    console.log(`${name} is ${age} years old.`);
}
 
displayInfo("John"); // Outputs: John is undefined years old.
 
					
				
			
		


Undefined Parameters के खिलाफ Functions को Safe करना
undefined parameters से उत्पन्न समस्याओं को रोकने के लिए, आप default parameters, conditional checks, या parameter destructuring का उपयोग कर सकते हैं।
Default Parameters का उपयोग करना
जैसा कि पहले चर्चा की गई है, default parameters undefined values को संभालने का एक straightforward तरीका प्रदान करते हैं।
उदाहरण:




		
		
			
			
Java
			
			
function displayInfo(name = "Unknown", age = "N/A") {
    console.log(`${name} is ${age} years old.`);
}

displayInfo("John"); // Outputs: John is N/A years old.
displayInfo(); // Outputs: Unknown is N/A years old.

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
function displayInfo(name = "Unknown", age = "N/A") {
    console.log(`${name} is ${age} years old.`);
}
 
displayInfo("John"); // Outputs: John is N/A years old.
displayInfo(); // Outputs: Unknown is N/A years old.
 
					
				
			
		


Functions के अंदर Conditional Checks
आप यह भी जांच सकते हैं कि कोई parameter undefined है या नहीं और function body के भीतर default value assign कर सकते हैं।
उदाहरण:




		
		
			
			
Java
			
			
function displayInfo(name, age) {
    name = name || "Unknown";
    age = age || "N/A";
    console.log(`${name} is ${age} years old.`);
}

displayInfo("John"); // Outputs: John is N/A years old.
displayInfo(); // Outputs: Unknown is N/A years old.

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						 
function displayInfo(name, age) {
    name = name || "Unknown";
    age = age || "N/A";
    console.log(`${name} is ${age} years old.`);
}
 
displayInfo("John"); // Outputs: John is N/A years old.
displayInfo(); // Outputs: Unknown is N/A years old.
 
					
				
			
		


Defaults के साथ Parameter Destructuring
उन functions के लिए जो objects को parameters के रूप में स्वीकार करते हैं, destructuring के साथ default values clean approach प्रदान करती हैं।
उदाहरण:




		
		
			
			
Java
			
			
function displayInfo({ name = "Unknown", age = "N/A" } = {}) {
    console.log(`${name} is ${age} years old.`);
}

displayInfo({ name: "John" }); // Outputs: John is N/A years old.
displayInfo(); // Outputs: Unknown is N/A years old.

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
function displayInfo({ name = "Unknown", age = "N/A" } = {}) {
    console.log(`${name} is ${age} years old.`);
}
 
displayInfo({ name: "John" }); // Outputs: John is N/A years old.
displayInfo(); // Outputs: Unknown is N/A years old.
 
					
				
			
		


Practical Application
undefined parameters को संभालना real-world applications में crucial है जहाँ functions variable amounts of data प्राप्त कर सकते हैं। Robust parameter handling आपकी applications की reliability और user experience को बढ़ाता है।
Parameters और Arguments के उपयोग के लिए सर्वोत्तम प्रथाएँ
1. Meaningful Parameter Names का उपयोग करें
Parameters के लिए descriptive names चुनें ताकि आपका code अधिक readable और maintainable हो सके।
उदाहरण:




		
		
			
			
Java
			
			
function calculateTotal(price, quantity) { ... }

			
				
					
				
					1
2
3
				
						 
function calculateTotal(price, quantity) { ... }
 
					
				
			
		


2. Default Parameters का लाभ उठाएं
Missing arguments को gracefully संभालने और fallback values प्रदान करने के लिए default parameters का उपयोग करें।
उदाहरण:




		
		
			
			
Java
			
			
function greet(name = "Guest") { ... }

			
				
					
				
					1
2
3
				
						 
function greet(name = "Guest") { ... }
 
					
				
			
		


3. Excessive Parameters से बचें
Parameters की संख्या को सीमित रखें ताकि functions simple और focused रहें। अगर एक function को कई parameters की आवश्यकता हो, तो संबंधित data को group करने के लिए objects का उपयोग करने पर विचार करें।
उदाहरण:




		
		
			
			
Java
			
			
function createUser({ name, age, email }) { ... }

			
				
					
				
					1
2
3
				
						 
function createUser({ name, age, email }) { ... }
 
					
				
			
		


4. Parameters Validate करें
Parameters को अपेक्षित criteria, जैसे type और value ranges, को ensure करें ताकि errors से बचा जा सके और data integrity बनी रहे।
उदाहरण:




		
		
			
			
Java
			
			
function setAge(age) {
    if (typeof age !== 'number' || age &lt; 0) {
        throw new Error("Invalid age provided.");
    }
    // Valid age के साथ आगे बढ़ें
}

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
function setAge(age) {
    if (typeof age !== 'number' || age &lt; 0) {
        throw new Error("Invalid age provided.");
    }
    // Valid age के साथ आगे बढ़ें
}
 
					
				
			
		


5. Function Parameters को Document करें
अपने functions के लिए स्पष्ट documentation प्रदान करें, प्रत्येक parameter के उद्देश्य और अपेक्षित values को specify करते हुए।
उदाहरण:




		
		
			
			
Java
			
			
/**
 * Calculates the total price.
 * @param {number} price - The price of a single item.
 * @param {number} quantity - The number of items.
 * @returns {number} - The total price.
 */
function calculateTotal(price, quantity) { ... }

			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						 
/**
 * Calculates the total price.
 * @param {number} price - The price of a single item.
 * @param {number} quantity - The number of items.
 * @returns {number} - The total price.
 */
function calculateTotal(price, quantity) { ... }
 
					
				
			
		


6. Variable Arguments के लिए Rest Parameters का उपयोग करें
जब एक function को अनिश्चित संख्या में arguments स्वीकार करने की आवश्यकता हो, तो उन्हें efficiently संभालने के लिए rest parameters का उपयोग करें।
उदाहरण:




		
		
			
			
Java
			
			
function sum(...numbers) {
    return numbers.reduce((total, num) => total + num, 0);
}

sum(1, 2, 3, 4); // Outputs: 10

			
				
					
				
					1
2
3
4
5
6
7
				
						 
function sum(...numbers) {
    return numbers.reduce((total, num) => total + num, 0);
}
 
sum(1, 2, 3, 4); // Outputs: 10
 
					
				
			
		


7. Parameter Order को Maintain करें
Function calls में parameters का order उनकी definition से मेल खाना सुनिश्चित करें ताकि unintended behaviors से बचा जा सके।
उदाहरण:




		
		
			
			
Java
			
			
function registerUser(username, email, password) { ... }

// Correct
registerUser("john_doe", "john@example.com", "securePassword");

// Incorrect
registerUser("securePassword", "john_doe", "john@example.com"); // Leads to errors

			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						 
function registerUser(username, email, password) { ... }
 
// Correct
registerUser("john_doe", "[email protected]", "securePassword");
 
// Incorrect
registerUser("securePassword", "john_doe", "[email protected]"); // Leads to errors
 
					
				
			
		


8. Enhanced Readability के लिए Destructuring का उपयोग करें
Function parameters में objects को destructure करें ताकि code clarity बढ़े और complexity कम हो।
उदाहरण:




		
		
			
			
Java
			
			
function displayUser({ name, email }) {
    console.log(`Name: ${name}, Email: ${email}`);
}

const user = { name: "John", email: "john@example.com" };
displayUser(user);

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
function displayUser({ name, email }) {
    console.log(`Name: ${name}, Email: ${email}`);
}
 
const user = { name: "John", email: "[email protected]" };
displayUser(user);
 
					
				
			
		


9. Parameter Validation Libraries Implement करें
बड़े प्रोजेक्ट्स के लिए, Joi या Yup जैसी libraries का उपयोग करने पर विचार करें ताकि function parameters को validate किया जा सके, जिससे consistency और reliability सुनिश्चित हो सके।
Joi के साथ उदाहरण:




		
		
			
			
Java
			
			
const Joi = require('joi');

const schema = Joi.object({
    name: Joi.string().min(3).required(),
    age: Joi.number().integer().min(0)
});

function createUser(data) {
    const { error, value } = schema.validate(data);
    if (error) {
        throw new Error(error.details[0].message);
    }
    // Validated data के साथ आगे बढ़ें
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						 
const Joi = require('joi');
 
const schema = Joi.object({
    name: Joi.string().min(3).required(),
    age: Joi.number().integer().min(0)
});
 
function createUser(data) {
    const { error, value } = schema.validate(data);
    if (error) {
        throw new Error(error.details[0].message);
    }
    // Validated data के साथ आगे बढ़ें
}
 
					
				
			
		


10. जब आवश्यक हो तो Refactor करें
Parameters के उपयोग को optimize करने, performance और maintainability बढ़ाने के लिए नियमित रूप से functions की समीक्षा करें और refactor करें।
उदाहरण:
Refactoring से पहले:




		
		
			
			
Java
			
			
function updateProfile(name, email, phone, address, city, state, zip) { ... }

			
				
					
				
					1
2
3
				
						 
function updateProfile(name, email, phone, address, city, state, zip) { ... }
 
					
				
			
		


Refactoring के बाद:




		
		
			
			
Java
			
			
function updateProfile({ name, email, phone, address, city, state, zip }) { ... }

			
				
					
				
					1
2
3
				
						 
function updateProfile({ name, email, phone, address, city, state, zip }) { ... }
 
					
				
			
		


निष्कर्ष
Function parameters और arguments में महारत हासिल करना efficient और maintainable JavaScript code लिखने के लिए महत्वपूर्ण है। Parameters और arguments के बीच के अंतर को समझने, default values का उपयोग करने, undefined parameters को संभालने, और best practices का पालन करने से developers versatile और robust functions बना सकते हैं। इस eBook ने foundational concepts, practical implementations, और advanced techniques को शामिल किया है ताकि आपकी JavaScript यात्रा को सशक्त किया जा सके। इन strategies को अपनाएं ताकि आपकी coding proficiency बढ़े और resilient applications बनाए जा सकें।
SEO Keywords: JavaScript function parameters, JavaScript arguments, default parameters, handling undefined parameters, function best practices, JavaScript programming, beginner JavaScript, JavaScript tutorial, function syntax, JavaScript coding tips
अतिरिक्त संसाधन

MDN Web Docs: Functions
JavaScript Info: Functions
Eloquent JavaScript: Functions
You Don't Know JS: Scope & Closures
JavaScript Tutorial on W3Schools

This article is AI generated.
विशेषता	JavaScript	अन्य भाषाएँ (जैसे Java, C++)
Parameter Flexibility	Highly flexible, allows undefined parameters.	Strict, often requires exact number of arguments.
Default Parameters	Supported using default values.	Limited support, often requires method overloading.
Argument Passing	Pass-by-value for primitives, pass-by-reference for objects.	Varies, commonly pass-by-value or reference based on type.