JavaScript ऑपरेटर्स: सम्पूर्ण मार्गदर्शिका
प्रैक्टिकल उदाहरणों और विस्तृत व्याख्या के साथ हिंदी में सीखें
JavaScript ऑपरेटर्स क्या हैं?
JavaScript operators वे विशेष प्रतीक हैं जो वेरिएबल्स और मानों पर संचालन करते हैं। ये javascript operators in hindi में समझने के लिए निम्नलिखित प्रमुख प्रकारों में विभाजित किए जा सकते हैं:
- अंकगणितीय ऑपरेटर्स - गणितीय गणनाएँ करने के लिए
- तुलना ऑपरेटर्स - मानों की तुलना करने के लिए
- लॉजिकल ऑपरेटर्स - तार्किक संचालन के लिए
- असाइनमेंट ऑपरेटर्स - वेरिएबल्स को मान निर्दिष्ट करने के लिए
// javascript operators examples
let sum = 10 + 5; // अंकगणितीय
let isAdult = age >= 18; // तुलना
let isValid = true && false; // लॉजिकल
let x = 10; // असाइनमेंट
let sum = 10 + 5; // अंकगणितीय
let isAdult = age >= 18; // तुलना
let isValid = true && false; // लॉजिकल
let x = 10; // असाइनमेंट
जावास्क्रिप्ट ऑपरेटर्स की विशेषता: ये ऑपरेटर एकल (unary), द्वैध (binary) या त्रिगुण (ternary) हो सकते हैं, जो उनके द्वारा लिए गए ऑपरेंड्स की संख्या पर निर्भर करता है।
1. अंकगणितीय ऑपरेटर्स
javascript operators types में सबसे मूलभूत हैं अंकगणितीय ऑपरेटर्स जो गणितीय संचालन करते हैं:
| ऑपरेटर | नाम | उदाहरण | परिणाम |
|---|---|---|---|
| + | जोड़ | 10 + 5 |
15 |
| - | घटाव | 10 - 5 |
5 |
| * | गुणा | 10 * 5 |
50 |
| / | भाग | 10 / 5 |
2 |
| % | भाग शेष | 10 % 3 |
1 |
| ** | घात | 2 ** 3 |
8 |
| ++ | इंक्रीमेंट | x++ |
x को 1 बढ़ाएँ |
| -- | डिक्रीमेंट | x-- |
x को 1 घटाएँ |
// javascript operators program उदाहरण
// अंकगणितीय ऑपरेटर्स के उदाहरण
let a = 10, b = 3;
console.log(a + b); // 13
console.log(a - b); // 7
console.log(a * b); // 30
console.log(a / b); // 3.333...
console.log(a % b); // 1
console.log(a ** b); // 1000
// इंक्रीमेंट/डिक्रीमेंट ऑपरेटर्स
let count = 5;
count++; // 6 (पोस्टफिक्स)
++count; // 7 (प्रीफिक्स)
count--; // 6
// अंकगणितीय ऑपरेटर्स के उदाहरण
let a = 10, b = 3;
console.log(a + b); // 13
console.log(a - b); // 7
console.log(a * b); // 30
console.log(a / b); // 3.333...
console.log(a % b); // 1
console.log(a ** b); // 1000
// इंक्रीमेंट/डिक्रीमेंट ऑपरेटर्स
let count = 5;
count++; // 6 (पोस्टफिक्स)
++count; // 7 (प्रीफिक्स)
count--; // 6
ध्यान दें: + ऑपरेटर स्ट्रिंग कॉन्केटेनेशन भी करता है। जब एक ऑपरेंड स्ट्रिंग हो, तो दूसरा भी स्ट्रिंग में कन्वर्ट हो जाता है।
console.log("5" + 3); // "53" (संख्या 3 स्ट्रिंग में कन्वर्ट हो गई)
2. तुलना ऑपरेटर्स
javascript operators list में तुलना ऑपरेटर्स बहुत उपयोगी हैं जो मानों की तुलना करके बूलियन (true/false) रिजल्ट देते हैं:
| ऑपरेटर | विवरण | उदाहरण | परिणाम |
|---|---|---|---|
| == | बराबर (वैल्यू) | 5 == '5' |
true |
| === | सख्त बराबर (वैल्यू और टाइप) | 5 === '5' |
false |
| != | बराबर नहीं | 5 != '5' |
false |
| !== | सख्त बराबर नहीं | 5 !== '5' |
true |
| > | बड़ा | 5 > 3 |
true |
| < | छोटा | 5 < 3 |
false |
| >= | बड़ा या बराबर | 5 >= 5 |
true |
| <= | छोटा या बराबर | 5 <= 3 |
false |
// तुलना ऑपरेटर्स के उदाहरण
let age = 25;
console.log(age > 18); // true
console.log(age === 25); // true
console.log(age == '25'); // true (टाइप कन्वर्जन)
console.log(age !== '25'); // true
console.log(age <= 30); // true
// पासवर्ड वैलिडेशन
let password = "secure123";
if(password.length >= 8) {
console.log("मजबूत पासवर्ड");
}
let age = 25;
console.log(age > 18); // true
console.log(age === 25); // true
console.log(age == '25'); // true (टाइप कन्वर्जन)
console.log(age !== '25'); // true
console.log(age <= 30); // true
// पासवर्ड वैलिडेशन
let password = "secure123";
if(password.length >= 8) {
console.log("मजबूत पासवर्ड");
}
बेस्ट प्रैक्टिस: हमेशा सख्त तुलना ऑपरेटर्स (=== और !==) का उपयोग करें क्योंकि ये टाइप कन्वर्जन से बचते हैं और अधिक प्रिडिक्टेबल रिजल्ट्स देते हैं।
3. लॉजिकल ऑपरेटर्स
javascript operators precedence में लॉजिकल ऑपरेटर्स महत्वपूर्ण हैं जो बूलियन लॉजिक लागू करते हैं:
| ऑपरेटर | विवरण | उदाहरण | परिणाम |
|---|---|---|---|
| && | AND (और) - दोनों सच होने पर सच | true && false |
false |
| || | OR (या) - कोई एक सच होने पर सच | true || false |
true |
| ! | NOT (नहीं) - सच को झूठ और झूठ को सच बनाता है | !true |
false |
// लॉजिकल ऑपरेटर्स प्रैक्टिस
let isLoggedIn = true;
let isAdmin = false;
if(isLoggedIn && isAdmin) {
console.log("एडमिन डैशबोर्ड");
} else if(isLoggedIn || isAdmin) {
console.log("यूजर डैशबोर्ड");
}
// NOT ऑपरेटर उदाहरण
let isGuest = !isLoggedIn;
console.log(isGuest); // false
let isLoggedIn = true;
let isAdmin = false;
if(isLoggedIn && isAdmin) {
console.log("एडमिन डैशबोर्ड");
} else if(isLoggedIn || isAdmin) {
console.log("यूजर डैशबोर्ड");
}
// NOT ऑपरेटर उदाहरण
let isGuest = !isLoggedIn;
console.log(isGuest); // false
टर्नरी ऑपरेटर (Ternary Operator)
एकमात्र त्रिगुण ऑपरेटर जो शर्त के आधार पर मान निर्दिष्ट करता है:
// सिंटैक्स:
condition ? exprIfTrue : exprIfFalse
let age = 20;
let status = age >= 18 ? "वयस्क" : "नाबालिग";
console.log(status); // "वयस्क"
// नेस्टेड टर्नरी उदाहरण
let marks = 85;
let grade = marks >= 90 ? 'A' :
marks >= 80 ? 'B' :
marks >= 70 ? 'C' : 'D';
console.log(grade); // 'B'
condition ? exprIfTrue : exprIfFalse
let age = 20;
let status = age >= 18 ? "वयस्क" : "नाबालिग";
console.log(status); // "वयस्क"
// नेस्टेड टर्नरी उदाहरण
let marks = 85;
let grade = marks >= 90 ? 'A' :
marks >= 80 ? 'B' :
marks >= 70 ? 'C' : 'D';
console.log(grade); // 'B'
सावधानी: जटिल नेस्टेड टर्नरी ऑपरेटर्स से बचें क्योंकि वे कोड को पढ़ने में मुश्किल बना सकते हैं। सरल शर्तों के लिए ही टर्नरी ऑपरेटर का उपयोग करें।
टाइप ऑपरेटर्स (Type Operators)
वेरिएबल के टाइप को चेक करने के लिए:
| ऑपरेटर | विवरण | उदाहरण |
|---|---|---|
| typeof | वेरिएबल का डेटा टाइप रिटर्न करता है | typeof "hello" // "string" |
| instanceof | चेक करता है कि ऑब्जेक्ट किसी क्लास का इंस्टेंस है या नहीं | arr instanceof Array // true |
// टाइप ऑपरेटर्स के उदाहरण
console.log(typeof "Hello"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"
console.log(typeof {}); // "object"
console.log(typeof []); // "object"
console.log(typeof null); // "object" (यह एक बग है)
let arr = [1, 2, 3];
console.log(arr instanceof Array); // true
console.log(typeof "Hello"); // "string"
console.log(typeof 42); // "number"
console.log(typeof true); // "boolean"
console.log(typeof {}); // "object"
console.log(typeof []); // "object"
console.log(typeof null); // "object" (यह एक बग है)
let arr = [1, 2, 3];
console.log(arr instanceof Array); // true
4. असाइनमेंट ऑपरेटर्स
javascript operators program में वेरिएबल्स को मान निर्दिष्ट करने के लिए असाइनमेंट ऑपरेटर्स का उपयोग होता है:
| ऑपरेटर | उदाहरण | समतुल्य |
|---|---|---|
| = | x = 5 |
x = 5 |
| += | x += 5 |
x = x + 5 |
| -= | x -= 5 |
x = x - 5 |
| *= | x *= 5 |
x = x * 5 |
| /= | x /= 5 |
x = x / 5 |
| %= | x %= 5 |
x = x % 5 |
| **= | x **= 3 |
x = x ** 3 |
// असाइनमेंट ऑपरेटर्स उदाहरण
let total = 10;
total += 5; // 15
total *= 2; // 30
total /= 3; // 10
total %= 3; // 1
// ES6 नए ऑपरेटर्स
let num = 2;
num **= 3; // 8 (घात असाइनमेंट)
let total = 10;
total += 5; // 15
total *= 2; // 30
total /= 3; // 10
total %= 3; // 1
// ES6 नए ऑपरेटर्स
let num = 2;
num **= 3; // 8 (घात असाइनमेंट)
ऑपरेटर प्रीसीडेंस
javascript operators precedence संचालन के क्रम को निर्धारित करता है जब एक एक्सप्रेशन में कई ऑपरेटर्स होते हैं:
// प्रीसीडेंस उदाहरण
let result1 = 10 + 5 * 2; // 20 (गुणा पहले)
let result2 = (10 + 5) * 2; // 30 (कोष्ठक पहले)
// जटिल उदाहरण
let a = 5, b = 10, c = 15;
let finalResult = a * b + c / a - b % a;
// 5*10 + 15/5 - 10%5
// 50 + 3 - 0 = 53
let result1 = 10 + 5 * 2; // 20 (गुणा पहले)
let result2 = (10 + 5) * 2; // 30 (कोष्ठक पहले)
// जटिल उदाहरण
let a = 5, b = 10, c = 15;
let finalResult = a * b + c / a - b % a;
// 5*10 + 15/5 - 10%5
// 50 + 3 - 0 = 53
सुझाव: कोड की स्पष्टता के लिए कोष्ठकों का उपयोग करें, भले ही प्रीसीडेंस नियमों को जानते हों। यह कोड को अधिक पठनीय और मेंटेन करने योग्य बनाता है।
JavaScript ऑपरेटर्स प्रैक्टिस
javascript operators questions
- निम्नलिखित का आउटपुट क्या होगा?
console.log(5 + "5" * 2);उत्तर: "510" नहीं, बल्कि 15 होगा क्योंकि गुणा (*) ऑपरेटर की प्रीसीडेंस अधिक है।
"5" * 2पहले 10 देगा (स्ट्रिंग को नंबर में कन्वर्ट करेगा), फिर 5 + 10 = 15 - सख्त तुलना (===) और सामान्य तुलना (==) में क्या अंतर है?
उत्तर:
-==केवल वैल्यू की तुलना करता है और टाइप कन्वर्जन करता है
-===वैल्यू और डेटा टाइप दोनों की तुलना करता है, कोई टाइप कन्वर्जन नहीं
उदाहरण:5 == '5' // trueलेकिन5 === '5' // false - निम्नलिखित कोड का आउटपुट क्या होगा?
let x = 5; console.log(x++ + ++x);उत्तर: 12
-x++पहले x की वर्तमान वैल्यू (5) रिटर्न करता है, फिर इंक्रीमेंट करता है (x=6)
-++xपहले इंक्रीमेंट करता है (x=7), फिर वैल्यू रिटर्न करता है
- इसलिए 5 + 7 = 12 - लॉजिकल AND (&&) और OR (||) ऑपरेटर्स में क्या अंतर है?
उत्तर:
- && (AND): दोनों कंडीशन्स सच होनी चाहिए
- || (OR): कोई एक कंडीशन सच होनी चाहिए
उदाहरण:
true && false // false
true || false // true - टर्नरी ऑपरेटर का उपयोग करके एक प्रोग्राम लिखें जो संख्या को धनात्मक, ऋणात्मक या शून्य बताए।
// समाधान let number = -7; let type = number > 0 ? "धनात्मक" : number < 0 ? "ऋणात्मक" : "शून्य"; console.log(type); // "ऋणात्मक"
निष्कर्ष
इस गाइड में हमने javascript operators in hindi में विस्तार से सीखा। ये ऑपरेटर्स javascript operators program लिखने का मूल आधार हैं।
महत्वपूर्ण सुझाव:
- हमेशा सख्त तुलना ऑपरेटर्स (===, !==) का उपयोग करें
- कोड की स्पष्टता के लिए कोष्ठकों का प्रयोग करें
- कॉम्प्लेक्स लॉजिक के लिए टर्नरी ऑपरेटर से बचें
- अधिक अभ्यास के लिए javascript operators questions हल करें
JavaScript ऑपरेटर्स को अच्छी तरह समझने से आप बेहतर और एफिशिएंट कोड लिख पाएंगे। अभ्यास जारी रखें और अधिक JavaScript प्रोग्राम्स सीखें!