Go Basics - 3. Primitives in Go

Go Basics - 3. Primitives in Go Hero Image

In this article, we are going to explore some of the primitives of the Go programming language.

Bool type

Booleans are in just about every single programming language, and Go is no exception. They represent the value of either true or false.

package main

import (
    "fmt"
)

func main() {
  var b bool = true
    fmt.Printf("%v, %T", b, b)
}

/*
  The result of the code above is:
  true, bool
*/
package main

import (
    "fmt"
)

func main() {
  var b bool = false
    fmt.Printf("%v, %T", b, b)
}

/*
  The result of the code above is:
  false, bool
*/

An interesting thing to note is that booleans are given a zero value when they are initialized. This means that the bool type is given the value of false unless otherwise specified.

package main

import (
    "fmt"
)

func main() {
  var b bool
    fmt.Printf("%v, %T", b, b)
}

/*
  The result of the code above is:
  false, bool
*/

Numeric Types

Golang has several different numeric types. The first one we are going to learn about is the int type.

package main

import (
    "fmt"
)

func main() {
  i := 14
    fmt.Printf("%v, %T", i, i)
}

/*
  The result of the code above is:
  14, int
*/

There are 4 different signed integer types in the language, each representing a specific range of numbers.

Int TypeMinimumMaximum
int8-128127
int16-32,76832,767
int32-2,147,483,6482,147,483,647
int64-9,223,372,036,854,775,8089,223,372,036,854,775,807

There are 4 different unsigned integer types in the language, each representing a specific range of numbers.

Int TypeMinimumMaximum
uint80255
uint16065,535
uint3204,294,967,295
uint64018,446,744,073,709,551,615

Let's now look at some basic mathematical operations we can perform upon these numbers.

package main

import (
    "fmt"
)

func main() {
  a := 10
  b := 2
    fmt.Println(a + b) // addition
    fmt.Println(a - b) // subtraction
    fmt.Println(a * b) // multiplication
    fmt.Println(a / b) // division
    fmt.Println(a % b) // remainder (sometimes called modulus in other languages)
}

/*
  The result of the code above is:
  12
  8
  20
  5
  0
*/

Floating point numbers or decimals

Float TypeMinimumMaximum
float321.401298464324817070923729583289916131280e-453.40282346638528859811704183484516925440e+38
float644.940656458412465441765687928682213723651e-3241.797693134862315708145274237317043567981e+308
package main

import (
    "fmt"
)

func main() {
  i := 3.14 // defaults to a float64 type
    fmt.Printf("%v, %T", i, i)
}

/*
  The result of the code above is:
  3.14, float64
*/

Basic mathematical operations with floats:

package main

import (
    "fmt"
)

func main() {
  a := 3.14
  b := 2.5
    fmt.Println(a + b) // addition
    fmt.Println(a - b) // subtraction
    fmt.Println(a * b) // multiplication
    fmt.Println(a / b) // division
}

/*
  The result of the code above is:
  5.640000000000001
  0.6400000000000001
  7.8500000000000005
  1.256
*/

The remainder operator % is only available on integer types, not floats.

String Type

package main

import (
    "fmt"
)

func main() {
  s := "Hello, World!"
  fmt.Printf("%v, %T", s, s)
}

/*
  The result of the code above is:
  Hello, World!, string
*/

Strings in Go are collections of bytes. You can access individual characters in a string just like you would access items in an array.

package main

import (
    "fmt"
)

func main() {
  s := "Hello, World!"
  fmt.Printf("%v, %T", s[3], s[3])
}

/*
  The result of the code above is:
  108, uint8
*/

Strings are concatenated with the + operator.

package main

import (
    "fmt"
)

func main() {
  s := "Hello"
  w := ", World!"
  fmt.Println(s + w)
}

/*
  The result of the code above is:
  Hello, World!
*/

You can also convert a string to a collection of bytes, known as a slice in Go.

package main

import (
    "fmt"
)

func main() {
  s := "Hello, World!"
  b := []byte(s)
  fmt.Printf("%v, %T", b, b)
}

/*
  The result of the code above is:
  [72 101 108 108 111 44 32 87 111 114 108 100 33], []uint8
*/

Rune Type

The difference between a string and a rune is that a string represents any UTF-8 character and a rune represents any UTF-32 character or an int32 type.

A string is declared with "" double quotes while a rune is declared with '' single quotes

package main

import (
    "fmt"
)

func main() {
  r := 't'
  fmt.Printf("%v, %T", r, r)
}

/*
  The result of the code above is:
  116, int32
*/

Wrap Up

In this article, we learned about the following primitives in Go.

  • Boolean Type
  • Integers (signed & unsigned)
  • Arithmetic Operations
  • Floating point numbers (32bit & 64bit)
  • Strings
  • Runes

Additional Resources