Types in Go

3 min readJun 23, 2022


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 mainimport "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.


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}

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)

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 at https://vigneshm.me/posts/go_types/.