Go ऑपरेटर्स

1 गोलैंग ऑपरेटर्स का अवलोकन

गो भाषा में, ऑपरेटर्स का उपयोग कार्यकोड के संचालन करने के लिए किया जाता है, जिसमें अंकगणितीय कार्य, सांबंधिक तुलनात्मक, तार्किक प्रक्रियाएँ, और अन्य शामिल हैं। विभिन्न ऑपरेटर्स का अलग-अलग कार्यान्वयन और उपयोग स्थितियों के साथ मेल खाता है। इन ऑपरेटर्स को समझना और महारत प्राप्त करना प्रभावी प्रोग्रामिंग के लिए आधार है।

2 अंकगणितीय ऑपरेटर्स

गो भाषा में, एक सेट के अंकगणितीय ऑपरेटर्स उपलब्ध कराए गए हैं:

• जोड़ (+): जोड़ने का ऑपरेशन
• घटाव (-): घटाव का ऑपरेशन
• गुणा (*) : गुणन का ऑपरेशन
• भाग (/): भाग का ऑपरेशन
• शेष (%): मॉड्यूलो ऑपरेशन

उदाहरण:

package main

import "fmt"

func main() {
    // जोड़ का ऑपरेशन
    sum := 10 + 5
    fmt.Println("10 + 5 =", sum) // आउटपुट 15

    // घटाव का ऑपरेशन
    diff := 10 - 5
    fmt.Println("10 - 5 =", diff) // आउटपुट 5

    // गुणन का ऑपरेशन
    prod := 10 * 5
    fmt.Println("10 * 5 =", prod) // आउटपुट 50

    // भाग का ऑपरेशन
    quot := 10 / 5
    fmt.Println("10 / 5 =", quot) // आउटपुट 2

    // मॉड्यूलो का ऑपरेशन
    rem := 10 % 5
    fmt.Println("10 % 5 =", rem) // आउटपुट 0
}

3 तार्किक ऑपरेटर्स

गो भाषा में तार्किक ऑपरेटर्स का उपयोग कई स्थितियों को जोड़ने के लिए किया जाता है (सामान्यत: बूलियन मानों के लिए उपयोग किया जाता है)। इसमें तीन प्रकार होते हैं: AND (&&), OR (||), और NOT (!)।

3.1 AND (&&)

जब सभी स्थितियाँ सही होती हैं, "AND" ऑपरेशन का परिणाम सही होता है।

उदाहरण:

package main

import "fmt"

func main() {
    fmt.Println(true && true)   // आउटपुट true
    fmt.Println(true && false)  // आउटपुट false
    fmt.Println(false && false) // आउटपुट false
    // परिणाम सही होता है केवल जब सभी स्थितियाँ सही होती हैं
}

3.2 OR (||)

अगर कम से कम एक स्थिति सही होती है, तो "OR" ऑपरेशन का परिणाम सही होता है।

उदाहरण:

package main

import "fmt"

func main() {
    fmt.Println(true || true)   // आउटपुट true
    fmt.Println(true || false)  // आउटपुट true
    fmt.Println(false || false) // आउटपुट false
    // परिणाम सही होता है यदि कम से कम एक स्थिति सही होती है
}

3.3 NOT (!)

एक स्थिति के बूलियन मान को उलटने के लिए प्रयोग किया जाता है।

उदाहरण:

package main

import "fmt"

func main() {
    fmt.Println(!true)  // आउटपुट false
    fmt.Println(!false) // आउटपुट true
    // बूलियन मान को उलटता है
}

4 तुलना ऑपरेटर्स

गो भाषा में, तुलना ऑपरेटर्स का उपयोग दो चरों या मानों की तुलना करने के लिए किया जाता है:

• बराबर (==)
• बराबर नहीं (!=)
• अधिक (>)
• कम (<)
• अधिक या बराबर (>=)
• कम या बराबर (<=)

तुलना ऑपरेशन का परिणाम बूलियन मान होता है: true या false।

5 बिटवाइज ऑपरेटर्स

गो में, बिटवाइज ऑपरेटर्स हमें डाटा के बाइनरी बिटों को सीधे प्रबंधित करने की अनुमति देते हैं:

• बिटवाइज AND (&)
• बिटवाइज OR (|)
• बिटवाइज XOR (^)
• बिटवाइज बाएं शिफ्ट (<<)
• बिटवाइज दाएं शिफ्ट (>>)

बिटवाइज ऑपरेटर्स मुख्य रूप से कम स्तरीय प्रोग्रामिंग, सीधे हार्डवेयर कार्यों, एन्क्रिप्शन, और अन्य परिदृश्यों में प्रयोग होते हैं।

6 असाइनमेंट ऑपरेटर्स

असाइनमेंट ऑपरेटर का उपयोग मानों को मूल्य देने के लिए किया जाता है। गो भाषा में, असाइनमेंट ऑपरेटर्स के कई रूप होते हैं:

• सरल असाइनमेंट (=)
• जोड़ असाइनमेंट (+=)
• घटाव असाइनमेंट (-=)
• गुणा असाइनमेंट (*=)
• भाग असाइनमेंट (/=)
• मॉड्यूलस असाइनमेंट (%=)

ये ऑपरेटर्स कोड को और संक्षेपित बनाते हैं। उदाहरण के लिए, x += 1 बराबर है x = x + 1।

7 विशेष ऑपरेटर्स

7.1 इंक्रीमेंट (++) और डिक्रीमेंट (--) ऑपरेटर्स

इंक्रीमेंट ऑपरेटर (++) और डिक्रीमेंट ऑपरेटर (--) का उपयोग किसी चर के मान से 1 जोड़ने और 1 घटाने के लिए किया जाता है, विशेष रूप से। ये गो भाषा में एक्सप्रेशन पर नहीं, बल्कि सीधे चर पर कार्य कर सकने वाले एकमात्र ऑपरेटर हैं।

package main

import "fmt"

func main() {
    x := 1
    x++
    fmt.Println("x++ =", x) // आउटपुट 2

    y := 10
    y--
    fmt.Println("y-- =", y) // आउटपुट 9
}

गो भाषा में ध्यान दें, x++ या x-- किसी भी अभिव्यक्ति का हिस्सा नहीं हो सकता। उदाहरण के लिए, z := x++ यह अनुमति नहीं है।

7.2 प्रकार परिवर्तन

गो भाषा स्थापित रूप से प्रकारबद्ध है, जिसका मतलब है कि एक बार एक चर घोषित किया गया है, उसका प्रकार बदला नहीं जा सकता है। इसलिए, कभी-कभी किसी भी प्रकार की एक चर को दूसरे प्रकार के रूप में परिवर्तित करना आवश्यक होता है। गो में स्वचालित प्रकार परिवर्तन नहीं है; स्पष्ट प्रकार परिवर्तन की आवश्यकता है।

उदाहरण:

package main

import (
	"fmt"
)

func main() {
	var i int = 42
	fmt.Println(float64(i)) // int को float64 में कनवर्ट करें

	var f float64 = 3.14
	fmt.Println(int(f)) // float64 को int में कनवर्ट करें, दशमलव भाग को छोड़ दिया जाएगा
}

प्रकार परिवर्तन करते समय, यह महत्वपूर्ण है कि परिवर्तन प्रक्रिया के दौरान डेटा सुरक्षित हो, जैसे कि एक फ्लोटिंग-प्वाइंट संख्या को पूर्णांक में परिवर्तित करते समय संकेतों की हानि का संभावनात्मक होना।