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)
}

Iterators — Go’s answer to generators and `for…of` (Go 1.23+)

Since Go 1.23 a for range loop can iterate over a function of type iter.Seq[T] (or iter.Seq2[K, V]). That is Go’s version of a JS generator: values are produced lazily, one per yield, and the loop body is the consumer. The slices and maps packages ship iterator-based helpers (slices.Values, maps.Keys, slices.Collect, slices.Sorted).

// TypeScript: generator + for…of
function* evens(limit: number) {
  for (let n = 0; n <= limit; n += 2) yield n;
}
for (const n of evens(6)) console.log(n); // 0 2 4 6

const keys = [...new Map([["a", 1], ["b", 2]]).keys()];

// Go 1.23+: a func(yield func(T) bool) is an iterator
func evens(limit int) iter.Seq[int] {
    return func(yield func(int) bool) {
        for n := 0; n <= limit; n += 2 {
            if !yield(n) { return } // consumer broke out of the loop
        }
    }
}
for n := range evens(6) { fmt.Println(n) } // 0 2 4 6

// stdlib helpers return iterators; Collect/Sorted turn them back into slices
keys := slices.Sorted(maps.Keys(map[string]int{"a": 1, "b": 2})) // [a b]

The yield callback returning false is how break reaches the producer — there is no generator object to .return(). Unlike JS generators, Go iterators are plain functions, so they inline well and cost no allocation for the common cases. You can also for i := range 10 over an int since Go 1.22.

🟦 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)