Arrays, Slices & Maps

Collections: from JS arrays to Go slices

In JavaScript/TypeScript, arrays are dynamic by default and objects serve as maps. Go separates these concerns: fixed-size arrays, dynamic slices (the one you’ll use daily), and maps.

Arrays vs Slices

Go arrays have a fixed size baked into the type. You’ll rarely use them directly. Slices are the dynamic, flexible version — backed by an array but with a length and capacity that grow as needed.

// TypeScript — always dynamic
const nums: number[] = [1, 2, 3];
nums.push(4);
console.log(nums.length);   // 4

// Go — slice (dynamic)
nums := []int{1, 2, 3}
nums = append(nums, 4)
fmt.Println(len(nums))  // 4

Slice operations

const letters = ["a", "b", "c", "d"];

// slice (non-mutating)
letters.slice(1, 3)  // ["b", "c"]

// length
letters.length       // 4

letters := []string{"a", "b", "c", "d"}

// slice expression
letters[1:3]         // ["b", "c"]

// length
len(letters)         // 4

Maps

Go maps are like TypeScript Record<K,V> or Map<K,V>. Keys can be any comparable type.

// TypeScript
const scores: Record<string, number> = {
    alice: 95,
    bob: 87,
};
scores["carol"] = 91;
delete scores["bob"];
console.log(scores["alice"]);

// Go
scores := map[string]int{
    "alice": 95,
    "bob":   87,
}
scores["carol"] = 91
delete(scores, "bob")
fmt.Println(scores["alice"])

Try it

Open in Playground

package main

import (
  "fmt"
  "sort"
)

func main() {
  // Slice
  fruits := []string{"banana", "apple", "cherry"}
  fruits = append(fruits, "date")
  sort.Strings(fruits)
  fmt.Println("Fruits:", fruits)

  // Map
  count := map[string]int{}
  words := []string{"go", "is", "fun", "go", "is", "great", "go"}
  for _, w := range words {
    count[w]++
  }
  fmt.Println("Word counts:", count)
}

🟦 Checking map key existence

In TypeScript, accessing a missing key returns undefined. In Go, accessing a missing map key returns the zero value for the value type. To distinguish “key present with zero value” from “key absent”, use the two-value form:

scores := map[string]int{"alice": 0}

val := scores["bob"]         // val == 0, but is bob in the map?
val, ok := scores["alice"]   // val == 0, ok == true  (present!)
val, ok  = scores["bob"]     // val == 0, ok == false (absent)

The ok idiom is idiomatic Go — you’ll also see it with type assertions and channel receives.

🟦 make() for pre-allocated slices and maps

When you know the size ahead of time, pre-allocate with make to avoid repeated reallocations:

// slice of 10 ints, all zero
s := make([]int, 10)

// map pre-allocated for ~100 entries
m := make(map[string]int, 100)