खोज…
वाक्य - विन्यास
- var x int // टाइप इंट के साथ वेरिएबल x घोषित करें
- var s string // घोषित स्ट्रिंग s टाइप प्रकार के साथ
- x = 4 // x मान परिभाषित करें
- s = "foo" // s मान परिभाषित करें
- y: = 5 // घोषित करें और y को int के प्रकार को परिभाषित करें
- f: = 4.5 // घोषित करें और अपने प्रकार के फ्लोट64 में f को परिभाषित करें
- b: = "bar" // घोषित करें और परिभाषित करें b अपने स्ट्रिंग के प्रकार को संदर्भित करता है
मूल चर घोषणा
गो एक वैधानिक रूप से टाइप की जाने वाली भाषा है, जिसका अर्थ है कि आपको आमतौर पर आपके द्वारा उपयोग किए जा रहे प्रकारों की घोषणा करनी होगी।
// Basic variable declaration. Declares a variable of type specified on the right.
// The variable is initialized to the zero value of the respective type.
var x int
var s string
var p Person // Assuming type Person struct {}
// Assignment of a value to a variable
x = 3
// Short declaration using := infers the type
y := 4
u := int64(100) // declare variable of type int64 and init with 100
var u2 int64 = 100 // declare variable of type int64 and init with 100
एकाधिक चर असाइनमेंट
गो में, आप एक ही समय में कई चर घोषित कर सकते हैं।
// You can declare multiple variables of the same type in one line
var a, b, c string
var d, e string = "Hello", "world!"
// You can also use short declaration to assign multiple variables
x, y, z := 1, 2, 3
foo, bar := 4, "stack" // `foo` is type `int`, `bar` is type `string`
यदि कोई फ़ंक्शन कई मान लौटाता है, तो आप फ़ंक्शन के रिटर्न मान के आधार पर चर भी मान निर्दिष्ट कर सकते हैं।
func multipleReturn() (int, int) {
return 1, 2
}
x, y := multipleReturn() // x = 1, y = 2
func multipleReturn2() (a int, b int) {
a = 3
b = 4
return
}
w, z := multipleReturn2() // w = 3, z = 4
खाली पहचानकर्ता
जब कोई अनुपयोगी हो, तो बेहतर कोड लिखने के लिए प्रोत्साहित करने के लिए गो एक त्रुटि को फेंक देगा। हालाँकि, कुछ स्थितियाँ ऐसी होती हैं जब आपको वास्तव में किसी वैरिएबल में संग्रहीत मूल्य का उपयोग करने की आवश्यकता नहीं होती है। उन मामलों में, आप असाइन किए गए मान को असाइन करने और छोड़ने के लिए "रिक्त पहचानकर्ता" _ का उपयोग करते हैं।
एक रिक्त पहचानकर्ता को किसी भी प्रकार का मान दिया जा सकता है, और बहुधा उन कार्यों में उपयोग किया जाता है जो कई मान लौटाते हैं।
मल्टीपल रिटर्न वैल्यू
func SumProduct(a, b int) (int, int) {
return a+b, a*b
}
func main() {
// I only want the sum, but not the product
sum, _ := SumProduct(1,2) // the product gets discarded
fmt.Println(sum) // prints 3
}
range का उपयोग करना
func main() {
pets := []string{"dog", "cat", "fish"}
// Range returns both the current index and value
// but sometimes you may only want to use the value
for _, pet := range pets {
fmt.Println(pet)
}
}
एक चर के प्रकार की जाँच करना
कुछ स्थितियाँ ऐसी होती हैं जहाँ आप सुनिश्चित नहीं होंगे कि किसी फ़ंक्शन से लौटे जाने पर वैरिएबल किस प्रकार का है। आप हमेशा वेरिएबल के प्रकार की जांच कर सकते हैं var.(type) यदि आप निश्चित नहीं हैं कि आप किस प्रकार के हैं:
x := someFunction() // Some value of an unknown type is stored in x now
switch x := x.(type) {
case bool:
fmt.Printf("boolean %t\n", x) // x has type bool
case int:
fmt.Printf("integer %d\n", x) // x has type int
case string:
fmt.Printf("pointer to boolean %s\n", x) // x has type string
default:
fmt.Printf("unexpected type %T\n", x) // %T prints whatever type x is
}