Go Data Types, Structs, Slices

In the last article, we saw some of the very basic constructs of Go. Here, I am gonna go over basic data types and a few aggregated data structures available in Go.

Basic Types in Go

Below are some of the basic types in Go. Go has Zero values, which means it will assign a default value if nothing is initialized to the variables getting declared. Below is a list of some of the types.

I have tried declaring and using all the different types to check the zero values and tried initializing them as well.

package main

import "fmt"

func main() {
    var bZeroValue bool
    var b bool = true
    var sZeroValue string
    var s string = "test" 
    var iZeroValue int
    var i int = -5
    var uZeroValue uint
    var u uint = 5
    var fZeroValue float32
    var f float32 = 3.14
    var cZeroValue complex64
    var c complex64 = (3 + 4i) 
    fmt.Printf("Type: %T Value: %v\n", bZeroValue, bZeroValue)
    fmt.Printf("Type: %T Value: %v\n", b, b)
    fmt.Printf("Type: %T Value: %v\n", sZeroValue, sZeroValue)
    fmt.Printf("Type: %T Value: %v\n", s, s)
    fmt.Printf("Type: %T Value: %v\n", iZeroValue, iZeroValue)
    fmt.Printf("Type: %T Value: %v\n", i, i)
    fmt.Printf("Type: %T Value: %v\n", uZeroValue, uZeroValue)
    fmt.Printf("Type: %T Value: %v\n", u, u)
    fmt.Printf("Type: %T Value: %v\n", fZeroValue, fZeroValue)
    fmt.Printf("Type: %T Value: %v\n", f, f)
    fmt.Printf("Type: %T Value: %v\n", cZeroValue, cZeroValue)
    fmt.Printf("Type: %T Value: %v\n", c, c)
}

The output shows us the Zero Values and how each value is initialized and used.

Type: bool Value: false
Type: bool Value: true
Type: string Value: 
Type: string Value: test
Type: int Value: 0
Type: int Value: -5
Type: uint Value: 0
Type: uint Value: 5
Type: float32 Value: 0
Type: float32 Value: 3.14
Type: complex64 Value: (0+0i)
Type: complex64 Value: (3+4i)

Go Pointers

Go also has pointers. It holds a memory address the same as C or C++. The type T is the pointer of type T. Zero value of the pointer is nil. We use the *& operator** to generate a pointer.

i := 5
var p *int = &i

We can access value from the pointer using . This is called **dereferencing*.

fmt.Println(*p)

Go Structs

Structs are also similar to C, they are used to form a collection of typed fields. Typically we can use it to model and maintain the state of an object if we are thinking in OOPS terms.

Below is a short example

type Anime struct {
    name string
    year int
}

func main(){
    onePiece := Anime("One Piece", 1999)
    fmt.Println(onePiece.name, "was first aired on", onePiece.year)
}

We access the struct fields using the dot operator.

Go Arrays

Arrays in Go is a collection of the same type of values. The type of values, as well as the length, can't be changed after declaration.

nos := [3]int {1, 2, 3}
fmt.Println(nos)

But, unlike C, and C++ where arrays are pointers, in Go it is the values. The implication of this difference is 2 fold,

• It copies the values when we assign the array to a new variable
• When passing to a function, it passes a copy, not a pointer.

Go Slice

Slice looks and does the same things, but is far more flexible. It can be extended using the built-in append function. Another key difference is that the slice uses a reference. Also, all Go functions use slices rather than arrays.

A simple snippet using slice and extending it with append.

no := []int{1, 2, 3, 4}
no = append(no, 5)
fmt.Println(no)

I hope this would help you understand some of the basic types in Go. I hope to make a detailed article on Slice and its internal working in a future article with some examples. In the next article, I will tackle Go routines with the help of a small project.

Happy Coding!

Leave a ❤️ and comment and let me know what you think.
Do you enjoy what you’ve read so far? Consider checking out the article in my site https://vigneshm.me/posts/go_types/.