Variables, Types & Zero Values

Variables in TypeScript vs Go

In TypeScript you have let for mutable variables, const for immutable bindings, and type inference via :. You’re also comfortable with values starting as undefined before assignment.

Go has similar mechanisms but with cleaner rules and one concept TypeScript has no direct answer for: zero values.

Variable declaration

Go offers two styles. The short declaration := (only inside functions) infers the type from the right-hand side — just like let x = in TypeScript. The long form var is used at package level or when you need to declare without an immediate value.

// TypeScript
let count: number = 0;
let name = "Alice";   // inferred as string
const MAX = 100;

// Go
var count int = 0
name := "Alice"   // inferred as string
const MAX = 100

Type inference with :=

The := operator is Go’s workhorse for local variables. It declares AND assigns in one step — no let, no type annotation needed when the type is obvious.

let score = 42;        // number
let ratio = 3.14;      // number
let label = "hello";   // string
let active = true;     // boolean

score := 42          // int
ratio := 3.14        // float64
label := "hello"     // string
active := true       // bool

Constants

Go constants work like TypeScript const — immutable, evaluated at compile time. Go also has iota for auto-incrementing enum-like sequences (covered later).

const PI = 3.14159;
const APP_NAME = "MyApp";

const PI = 3.14159
const AppName = "MyApp"

Try it

Open in Playground

package main

import "fmt"

func main() {
  // Short declaration
  name := "Gopher"
  age := 3

  // Long form (package-level style)
  var score int = 100

  const greeting = "Hello"

  fmt.Printf("%s, %s! Age: %d, Score: %d\n", greeting, name, age, score)
}

🟦 Zero Values — No undefined in Go

In TypeScript, a declared-but-unassigned variable is undefined. In Go, every type has a zero value — the default it gets when declared without assignment. There is no undefined, no null for value types.

Go type	Zero value
`int`, `float64`	`0`, `0.0`
`string`	`""` (empty string)
`bool`	`false`
pointer, slice, map, channel, func	`nil`

var x int     // x == 0
var s string  // s == ""
var b bool    // b == false

This makes Go programs predictable — you never accidentally operate on undefined.