Primitives

Go provides a set of built-in primitive types. These types are the building blocks of Go programs. The most common primitive types are:

Scalar Types

• Signed integers: int, int8, int16, int32, int64
• Unsigned integers: uint, uint8, uint16, uint32, uint64
• Floating-point numbers: float32, float64
• Complex numbers: complex64, complex128
• Boolean: bool
• String: string
• Byte: byte (alias for uint8)
• Rune: rune (alias for int32, represents a Unicode code point)
• Pointer: *T (pointer to a value of type T)

package main

import "fmt"

func main() {
  // Signed integers
  var a int = 42
  var b int8 = 127
  var c int16 = 32767
  var d int32 = 2147483647
  var e int64 = 9223372036854775807

  fmt.Printf("Signed integers: %d, %d, %d, %d, %d\n", a, b, c, d, e)

  // Unsigned integers
  var f uint = 42
  var g uint8 = 255
  var h uint16 = 65535
  var i uint32 = 4294967295
  var j uint64 = 18446744073709551615

  fmt.Printf("Unsigned integers: %d, %d, %d, %d, %d\n", f, g, h, i, j)

  // Floating-point numbers
  var k float32 = 3.14
  var l float64 = 3.141592653589793

  fmt.Printf("Floating-point numbers: %f, %f\n", k, l)

  // Complex numbers
  var m complex64 = 1 + 2i
  var n complex128 = 1 + 2i

  fmt.Printf("Complex numbers: %v, %v\n", m, n)

  // Boolean
  var o bool = true
  var p bool = false

  fmt.Printf("Boolean: %t, %t\n", o, p)

  // String
  var q string = "Hello, 世界!"

  fmt.Printf("String: %s\n", q)

  // Byte
  var r byte = 'A'

  fmt.Printf("Byte: %c\n", r)

  // Rune
  var s rune = '世'
  var t rune = '𠜎'

  fmt.Printf("Rune: %c, %c\n", s, t)

  // Pointer
  var u *int = &a

  fmt.Printf("Pointer: %d\n", *u)
}

Compound Types

• Array: A fixed-size sequence of elements of the same type.
• Slice: A dynamically-sized sequence of elements of the same type.
• Map: A collection of key-value pairs.

package main

import "fmt"

func main() {
  // Array
  var arr [5]int = [5]int{1, 2, 3, 4, 5}
  fmt.Printf("Array: %v\n", arr)

  // Slice
  var slice []int = []int{1, 2, 3, 4, 5}
  fmt.Printf("Slice: %v\n", slice)

  // Map
  var m map[string]int = map[string]int{"one": 1, "two": 2, "three": 3}
  fmt.Printf("Map: %v\n", m)
}

When working with arrays or slices, you will need to use some functions to manipulate them. Here are some of the most common functions:

• len(): Returns the length of the array or slice.
• append(): Adds elements to the end of a slice.
• copy(): Copies elements from one slice to another.
• make(): Creates a slice with a specified length and capacity.
• delete(): Removes a key-value pair from a map.
• sort(): Sorts a slice in ascending order.

package main

import "fmt"

func main() {
  // Finding the length of an array or slice
  arr := [5]int{1, 2, 3, 4, 5}
  slice := []int{1, 2, 3, 4, 5}

  fmt.Printf("Length of array: %d\n", len(arr))
  fmt.Printf("Length of slice: %d\n", len(slice))

  // Appending elements to a slice
  // arr = append(arr[:], 6, 7, 8) // This will not work because arrays have a fixed size
  slice = append(slice, 6, 7, 8)

  fmt.Printf("Slice after appending: %v\n", slice)

  // Copying elements from one slice to another
  slice2 := make([]int, len(slice))
  copy(slice2, slice)

  fmt.Printf("Slice after copying: %v\n", slice2)

  // Creating a slice with a specified length and capacity
  slice3 := make([]int, 5, 10)

  fmt.Printf("Slice with length 5 and capacity 10: %v\n", slice3)

  // Deleting an element from a slice
  slice = append(slice[:2], slice[3:]...) // Remove the element at index 2

  fmt.Printf("Slice after deleting element at index 2: %v\n", slice)
}

If it's the first time you code, index 0 is the first element of the array or slice, and index 1 is the second element. The last element of the array or slice is len(array) - 1. You can also use negative indexes to access elements from the end of the array or slice. For example, array[-1] will give you the last element of the array.

Likewise, when you're working with a map, you're gonna need to use some functions to manipulate it. Here are some of the most common functions:

• len(): Returns the number of key-value pairs in the map.
• delete(): Removes a key-value pair from the map.
• make(): Creates a map with a specified key and value type.
• keys(): Returns a slice of the keys in the map.

package main

import (
 "fmt"
 "maps"
)

func main() {
  m := map[string]int{"one": 1, "two": 2, "three": 3}

  // Accessing a value by key
  fmt.Printf("Value for key 'two': %d\n", m["two"])

  // Finding the length of a map
  fmt.Printf("Length of map: %d\n", len(m))

  // Deleting a key-value pair from a map
  delete(m, "two")

  fmt.Printf("Map after deleting key 'two': %v\n", m)

  // Creating a map with a specified key and value type
  m2 := make(map[string]int)

  fmt.Printf("Empty map: %v\n", m2)

  // Adding key-value pairs to the map
  m2["one"] = 1
  m2["two"] = 2

  fmt.Printf("Map after adding key-value pairs: %v\n", m2)

  // Using keys functions
  for k := range maps.Keys(m2) {
      fmt.Printf("Key: %s\n", k)
  }
}

Pointer

For those of you who are new to programming, the concept of packages and pointers may seem a bit challenging. Pointers in Go allow you to reference a memory location instead of the actual value. Let's visualize this with a simple illustration:

         +-------+      +-------+
         |   a   |      |   p   |
         |       | <--- |       |
         |  42   |      |  &a   |
         +-------+      +-------+

In this example, a is a variable that holds the value 42, and p is a pointer that holds the address of a. When you dereference the pointer p, you can access the value stored in a. Notice that the syntax for dereferencing a pointer is *p, which means "get the value at the address stored in p. You can also use * notation to do value assignment to p. Vice versa, if you want to get the address of a variable, you can use the & operator. For example, &a will give you the address of a.

package main

import "fmt"

func main() {
  a := 42
  p := &a

  fmt.Printf("Value of a: %d\n", a)
  fmt.Printf("Address of a: %p\n", &a)
  fmt.Printf("Value of p: %p\n", p)
  fmt.Printf("Value pointed to by p: %d\n", *p)

  // Changing the value of a through the pointer
  *p = 100
  // fmt.Printf("New value of a: %d\n", a)
  // fmt.Printf("New value pointed to by p: %d\n", *p)
}

Nil

In Go, nil is a special value that represents the absence of a value. It can be assigned to pointers, slices, maps, channels, and interfaces. When you declare a variable without initializing it, it will have the zero value for its type. For example, an uninitialized pointer will be nil, an uninitialized slice will be nil, and an uninitialized map will be nil. The use of nil is important for error handling and checking if a variable has been initialized. For example, if you try to dereference a nil pointer, it will cause a runtime panic.

One thing to note is that the most of scalar types in Go have a default value. For example, the zero value of an int is 0, the zero value of a float64 is 0.0, and the zero value of a string is an empty string "". Which means scalar never comparable to nil. However, the zero value of a pointer is nil, which means it doesn't point to any memory location. This is different from other languages like C or C++, where uninitialized pointers can point to random memory locations.

To check if a pointer is nil, you can use the if statement:

package main

import "fmt"

func main() {
  var p *int
  fmt.Printf("Value of p: %p\n", p)

  // Checking if a pointer is nil
  if p == nil {
      fmt.Println("Pointer p is nil")
  }
}

Conversion

Sometime you may need to convert a value from one type to another or so-called type-casting. In Go, you can use the T(value) syntax to convert a value to type T. For example, you can convert an int to a float64 using float64(a), where a is an integer.

package main

import "fmt"

func main() {
  a := 42
  b := float64(a)
  fmt.Printf("Value of a: %d\n", a)
  fmt.Printf("Value of b: %f\n", b)
}

Reflect

In Go, the reflect package provides a way to inspect the type of a variable at runtime. This can be useful for debugging or when you need to work with types that are not known until runtime. The reflect package provides several functions and types for working with reflection, including TypeOf, ValueOf, and Kind.

package main

import (
  "fmt"
  "reflect"
)

func main() {
  a := 42
  b := "hello"

  fmt.Println("Type of a:", reflect.TypeOf(a))
  fmt.Println("Type of b:", reflect.TypeOf(b))

  fmt.Println("Kind of a:", reflect.TypeOf(a).Kind())
  fmt.Println("Kind of b:", reflect.TypeOf(b).Kind())

  fmt.Println("Value of a:", reflect.ValueOf(a))
  fmt.Println("Value of b:", reflect.ValueOf(b))
}