Go
Arrays

परिचय

वाक्य - विन्यास

• var variableName [5] ArrayType // आकार 5 की एक सरणी की घोषणा।
• var variableName [2] [३] ArrayType = {{Value1, Value2}, Value3}, {Value4, Value5, Value6}} // एक बहुआयामी सरणी की घोषणा
• चर नाम: = [...] ArrayType {Value1, Value2}, Value3} // आकार 3 की एक सरणी घोषित करें (कंपाइलर आकार को परिभाषित करने के लिए सरणी तत्वों की गणना करेगा)
• arrayName [2] // इंडेक्स द्वारा मान प्राप्त करना।
• arrayName [5] = 0 // इंडेक्स पर मान सेट करना।
• arrayName [0] // ऐरे का पहला मूल्य
• arrayName [len (arrayName) -1] // ऐरे का अंतिम मान

सरणियाँ बनाना

जाने में सरणी एक ही प्रकार के तत्वों का एक संग्रह है।
सरणियों का प्रतिनिधित्व करने के लिए मूल अंकन चर नाम के साथ [] का उपयोग करना है।

की तरह एक नई सरणी दिखता बनाना var array = [size]Type , की जगह size एक संख्या से (उदाहरण के लिए 42 निर्दिष्ट करने के लिए यह 42 तत्वों की सूची हो जाएगा), और जगह Type के लिए तत्वों सरणी कर सकते हैं के प्रकार से ( उदाहरण int या string )

नीचे एक कोड उदाहरण है जिसमें गो में एक सरणी बनाने का अलग तरीका दिखाया गया है।

// Creating arrays of 6 elements of type int,
// and put elements 1, 2, 3, 4, 5 and 6 inside it, in this exact order:
var array1 [6]int = [6]int {1, 2, 3, 4, 5, 6} // classical way
var array2 = [6]int {1, 2, 3, 4, 5, 6} // a less verbose way
var array3 = [...]int {1, 2, 3, 4, 5, 6} // the compiler will count the array elements by itself

fmt.Println("array1:", array1) // > [1 2 3 4 5 6]
fmt.Println("array2:", array2) // > [1 2 3 4 5 6]
fmt.Println("array3:", array3) // > [1 2 3 4 5 6]


// Creating arrays with default values inside:
zeros := [8]int{}               // Create a list of 8 int filled with 0
ptrs := [8]*int{}               // a list of int pointers, filled with 8 nil references ( <nil> )
emptystr := [8]string{}         // a list of string filled with 8 times ""

fmt.Println("zeroes:", zeros)      // > [0 0 0 0 0 0 0 0]
fmt.Println("ptrs:", ptrs)         // > [<nil> <nil> <nil> <nil> <nil> <nil> <nil> <nil>]
fmt.Println("emptystr:", emptystr) // > [       ]  
// values are empty strings, separated by spaces,
// so we can just see separating spaces


// Arrays are also working with a personalized type
type Data struct {
    Number int
    Text   string
}

// Creating an array with 8 'Data' elements
// All the 8 elements will be like {0, ""} (Number = 0, Text = "")
structs := [8]Data{}  

fmt.Println("structs:", structs) // > [{0 } {0 } {0 } {0 } {0 } {0 } {0 } {0 }] 
// prints {0 } because Number are 0 and Text are empty; separated by a space

इसे खेल के मैदान पर खेलें

बहुआयामी सरणी

बहुआयामी सरणियों को मूल रूप से एरे होता है जिसमें तत्वों के रूप में अन्य सरणियां होती हैं।
इसे [sizeDim1][sizeDim2]..[sizeLastDim]type की तरह sizeDim गया है, जो कि sizeDim की लंबाई के अनुरूप संख्या के अनुसार sizeDim को प्रतिस्थापित sizeDim है, और बहुआयामी सरणी में डेटा के type द्वारा type किया जाता है।

उदाहरण के लिए, [2][3]int प्रकार के तत्वों के २ उप सरणियों से बना एक सरणी का प्रतिनिधित्व करता है ।
यह मूल रूप से 2 लाइनों और 3 कॉलम के मैट्रिक्स का प्रतिनिधित्व हो सकता है।

इसलिए हम विशाल var values := [2017][12][31][24][60]int सरणी var values := [2017][12][31][24][60]int तरह बना सकते हैं var values := [2017][12][31][24][60]int उदाहरण के लिए var values := [2017][12][31][24][60]int यदि आपको वर्ष ० के बाद से प्रत्येक मिनट के लिए कोई संख्या संग्रहीत करने की आवश्यकता है।

इस तरह के एरे को एक्सेस करने के लिए, आखिरी उदाहरण के लिए, 2016-01-31 के मूल्य को 19:42 पर खोजकर, आप values[2016][0][30][19][42] को एक्सेस करेंगे values[2016][0][30][19][42] (क्योंकि एरे इंडेक्स) 0 से शुरू होता है और दिन और महीनों की तरह 1 पर नहीं)

कुछ उदाहरण निम्नलिखित हैं:

// Defining a 2d Array to represent a matrix like
// 1 2 3     So with 2 lines and 3 columns;
// 4 5 6     
var multiDimArray := [2/*lines*/][3/*columns*/]int{ [3]int{1, 2, 3}, [3]int{4, 5, 6} }

// That can be simplified like this:
var simplified := [2][3]int{{1, 2, 3}, {4, 5, 6}}

// What does it looks like ?
fmt.Println(multiDimArray)
// > [[1 2 3] [4 5 6]]

fmt.Println(multiDimArray[0]) 
// > [1 2 3]    (first line of the array)

fmt.Println(multiDimArray[0][1])
// > 2          (cell of line 0 (the first one), column 1 (the 2nd one))

// We can also define array with as much dimensions as we need
// here, initialized with all zeros
var multiDimArray := [2][4][3][2]string{} 

fmt.Println(multiDimArray);
// Yeah, many dimensions stores many data
// > [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]
//   [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]

// We can set some values in the array's cells
multiDimArray[0][0][0][0] := "All zero indexes"  // Setting the first value
multiDimArray[1][3][2][1] := "All indexes to max"  // Setting the value at extreme location

fmt.Println(multiDimArray);
// If we could see in 4 dimensions, maybe we could see the result as a simple format
    
// > [[[["All zero indexes" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]]
//   [[[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" ""]]]
//    [[["" ""] ["" ""]] [["" ""] ["" ""]] [["" ""] ["" "All indexes to max"]]]]

ऐरे इंडेक्स

सरणी में वांछित मान के स्थान को निर्दिष्ट करने वाले नंबर का उपयोग करके ऐरे मानों को एक्सेस किया जाना चाहिए। इस नंबर को इंडेक्स कहा जाता है।

इंडेक्स 0 से शुरू होता है और सरणी लंबाई -1 पर समाप्त होता है।

किसी मान तक पहुँचने के लिए, आपको कुछ इस तरह करना होगा: arrayName[index] , " arrayName[index] " को अपने सरणी में मान के रैंक के अनुरुप "index" की जगह दें।

उदाहरण के लिए:

var array = [6]int {1, 2, 3, 4, 5, 6}

fmt.Println(array[-42]) // invalid array index -1 (index must be non-negative)
fmt.Println(array[-1]) // invalid array index -1 (index must be non-negative)
fmt.Println(array[0]) // > 1
fmt.Println(array[1]) // > 2
fmt.Println(array[2]) // > 3
fmt.Println(array[3]) // > 4
fmt.Println(array[4]) // > 5
fmt.Println(array[5]) // > 6
fmt.Println(array[6]) // invalid array index 6 (out of bounds for 6-element array)
fmt.Println(array[42]) // invalid array index 42 (out of bounds for 6-element array)

सरणी में मान सेट या संशोधित करने के लिए, तरीका समान है।
उदाहरण:

var array = [6]int {1, 2, 3, 4, 5, 6}

fmt.Println(array) // > [1 2 3 4 5 6]

array[0] := 6
fmt.Println(array) // > [6 2 3 4 5 6]

array[1] := 5
fmt.Println(array) // > [6 5 3 4 5 6]

array[2] := 4
fmt.Println(array) // > [6 5 4 4 5 6]

array[3] := 3
fmt.Println(array) // > [6 5 4 3 5 6]

array[4] := 2
fmt.Println(array) // > [6 5 4 3 2 6]

array[5] := 1
fmt.Println(array) // > [6 5 4 3 2 1]