Collections of Golang

Overview

I have discussed data type and other basic stuff on the previous blog. Pleas check that blog by clicking on this link . in this blog i am going to talk about the topic below

Array
Slice
Map
Structs

Array

An array is a fixed size collection of similar data type . In golang you can declare array in two way implicate and explicate. in explicate initialization you need to initialize array as bellow.

     var <name> [<size>] <type>

in implicate initialization you need to initialize array as bellow.

     <name> := [<size>]<type>{}

for implicate initialization you don't have to say size of the array if your not sure of the size. compiler will automatically increase the size as you go on farther.

Code :

    
    var i int
    package main
    import ( "fmt" )

    func main() {
        var arr [3]int 
        arrSecond := [3]int{15,45,85}
        arrthird := []int{15,45,85}

        arr[0] = 15
        arr[1] = 12
        arr[2] = 13

        fmt.Println(arr,arrSecond,arrthird)	
    }

Out Put :

    [15 12 13] [15 45 85] [15 45 85]

Slice

Slice is a variable-length sequence which stores elements of a similar type, you are not allowed to store different type of elements in the same slice. slice is built on top of an array. A slice does not store any data, it just describes a section of an underlying array. Changing the elements of a slice modifies the corresponding elements of its underlying array. Other slices that share the same underlying array will see those changes.

On other words slice divide an array and make a new array and it works link a pointer. If you change on slice the change will reflect on the array it was made from.

if you want to make a slice on array named 'arr' then a you need to do as below.

     <slice name> := <array name>[<starting point>:<ending point>]

Code :

    package main
    import ("fmt")

    func main() {
    
        arr := []int{32,12,45,62,43}

        slice1 := arr[:]
        slice2 := arr[1:]
        slice3 := arr[:2]
        slice4 := arr[1:2]

        fmt.Println(slice1,slice2,slice3,slice4)

        slice1[0] = 3
        fmt.Println(arr)
        

    }

Out Put :

        [32 12 45 62 43] [12 45 62 43] [32 12] [12]
        [3 12 45 62 43]

Note: as you can see I have changed on 'slice[0]' but printed 'arr' and can see the change what i have made in 'slice[0]' in 'arr' .

Map

Map is a collection where we can associate key to the value.you can initialise map as below

    <name> := map[<key type>]<value type>{<value>}

Code :

  
    package main
    import ("fmt")

    func main() {
        m := map[string]int{"foo":21}
        fmt.Println(m,m["foo"])

        delete(m,"foo")
        fmt.Println(m)
    }

Out Put :

        map[foo:21] 21
        map[]

Struct

struct is the only collection type that allows us to associate disparate data type together. In array, slice and map we cannot associate different type of data but in struct we can. The only limitation that we have with struct that is the field that we make available are fixed in compile time.

you cannot define and initialize struct in one line. first you need initialize struct and make an object to initialize the struct.

	type < name of struct > struct {
            < key name > < value type >
        }
        
        var < variable name > < name of struct >
		
        < variable name >.< key name > = < value >

Code :

      
      type user struct {
	ID int
	firstName string
	lastName string
      }

      var u user

      u.ID = 1
      u.firstName = "hello"
      u.lastName = "world !!!"

      fmt.Println(u)

      fmt.Println(u.ID)
      fmt.Println(u.firstName)
      fmt.Println(u.lastName)

Out Put :

        {1 hello world !!!}
        1
        hello
        world !!!

Previous Blog	Next Blog
Primitive data type of Golang	Functions of Golang

Other blog on this series :

Learning GoLang

Search This Blog