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/.