Zero Values — Interview Questions¶

// Verification:
var i int       // 0
var s string    // ""
var b bool      // false
var f float64   // 0.0
var p *int      // nil
var sl []int    // nil
var m map[string]int // nil

// Package scope — only var works:
var packageLevel int  // OK
// packageLevel := 0  // COMPILE ERROR: syntax error

// Function scope — both work:
func main() {
    var a int  // a = 0
    b := 0     // b = 0, same type and value
    _ = a
    _ = b
}

type Address struct {
    Street  string
    City    string
    Zip     string
    Country string
    Active  bool
    Code    int
}

var a Address
// a.Street  = ""
// a.City    = ""
// a.Zip     = ""
// a.Country = ""
// a.Active  = false
// a.Code    = 0

// Verify zero value:
fmt.Println(a == Address{})  // true

type Person struct {
    Name    string
    Age     int
    Address Address  // nested struct — all fields zeroed
}

var p Person
fmt.Println(p.Address.City)  // ""

var m map[string]int  // nil map

// SAFE reads:
val := m["missing"]         // val = 0, no panic
val, ok := m["missing"]     // val = 0, ok = false, no panic
for k, v := range m { ... } // 0 iterations, safe
fmt.Println(len(m))         // 0, safe

// PANIC:
m["key"] = 1  // panic: assignment to entry in nil map

// Safe pattern:
if m == nil {
    m = make(map[string]int)
}
m["key"] = 1  // now safe

var s []int  // nil slice
fmt.Println(s == nil)  // true
fmt.Println(len(s))    // 0

s = append(s, 1, 2, 3)
fmt.Println(s)         // [1 2 3]
fmt.Println(s == nil)  // false (now has backing array)

// Also safe:
for _, v := range s { _ = v }  // normal iteration

// Collect results without pre-allocating:
var results []string  // nil slice — "no results yet"
for _, item := range items {
    if item.Valid {
        results = append(results, item.Name)
    }
}
// results is nil if nothing matched, or a slice with data
return results

var nilSlice []int      // nil == true, len = 0, cap = 0
emptySlice := []int{}  // nil == false, len = 0, cap = 0

import "encoding/json"

type Response struct {
    Items []string `json:"items"`
}

n, _ := json.Marshal(Response{Items: nil})       // {"items":null}
e, _ := json.Marshal(Response{Items: []string{}}) // {"items":[]}

// Go: always safe
var values [10]int
for _, v := range values {
    fmt.Println(v)  // always 0
}

// sync.Mutex zero value is "unlocked" — immediately usable:
var mu sync.Mutex
mu.Lock()    // works!
mu.Unlock()  // works!

// Counter: zero value is "count = 0" — immediately usable
type Counter struct {
    mu    sync.Mutex  // zero = unlocked (usable zero value)
    value int64       // zero = count is 0 (correct default)
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int64 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

// User code:
var c Counter   // no New() needed!
c.Increment()
c.Increment()
fmt.Println(c.Value())  // 2

type MyError struct {
    Message string
}
func (e *MyError) Error() string { return e.Message }

// BUG: returns non-nil interface even when no error
func validateBug(s string) error {
    var err *MyError  // typed nil pointer
    if s == "" {
        err = &MyError{"empty string"}
    }
    return err  // PROBLEM: interface{(*MyError, nil)} is NOT nil!
}

// This will print "Error: <nil>" even for valid input:
if err := validateBug("hello"); err != nil {
    fmt.Println("Error:", err)  // This executes! Bug!
}

func validateGood(s string) error {
    if s == "" {
        return &MyError{"empty string"}  // return concrete error
    }
    return nil  // return UNTYPED nil — interface will be nil
}

if err := validateGood("hello"); err != nil {
    fmt.Println("Error:", err)  // correctly not reached
}

p := new(int)
fmt.Println(*p)          // 0
fmt.Println(p == nil)    // false (p is a valid pointer to 0)

// Equivalent to:
var x int
p := &x

type Config struct {
    Host string
    Port int
}

c := new(Config)
fmt.Println(c.Host)  // ""
fmt.Println(c.Port)  // 0

// Equivalent to:
var cfg Config
c := &cfg

type User struct {
    ID       int    `json:"id"`
    Name     string `json:"name"`
    Email    string `json:"email,omitempty"`   // omit if ""
    Score    int    `json:"score,omitempty"`   // omit if 0
    Active   bool   `json:"active"`            // included even if false
    Tags     []string `json:"tags,omitempty"`  // omit if nil/empty
}

u := User{ID: 1, Name: "Alice"}
b, _ := json.Marshal(u)
fmt.Println(string(b))
// {"id":1,"name":"Alice","active":false}
// Email and Score are omitted (omitempty, zero value)
// Active is included (no omitempty)

type Response struct {
    Count int `json:"count,omitempty"`
    // If count is legitimately 0, it will be omitted!
    // Can't tell "no count" from "count is 0"
}

// Solution: use pointer
type Response struct {
    Count *int `json:"count,omitempty"`
    // nil = not set (omitted)
    // &0  = count is 0 (included as 0)
}

// nil slice -> JSON null
// empty slice -> JSON []
// With omitempty:
// nil slice -> omitted
// empty slice -> included as []

var ch chan int  // nil channel

// Send on nil channel: blocks forever
// go func() { ch <- 1 }()  // goroutine blocked forever (goroutine leak!)

// Receive from nil channel: blocks forever
// val := <-ch  // blocks forever

// Close nil channel: PANIC
// close(ch)  // panic: close of nil channel

// nil channel in select: that case is NEVER selected
select {
case v := <-ch:   // never selected if ch is nil
    _ = v
default:
    fmt.Println("no message")  // this runs
}

// Safe usage pattern — use nil channel to disable select cases:
func merge(ch1, ch2 <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for ch1 != nil || ch2 != nil {
            select {
            case v, ok := <-ch1:
                if !ok { ch1 = nil; continue }  // disable this case
                out <- v
            case v, ok := <-ch2:
                if !ok { ch2 = nil; continue }  // disable this case
                out <- v
            }
        }
    }()
    return out
}

func makeError(fail bool) error {
    var e *MyError  // typed nil: (*MyError, nil)
    if fail {
        e = &MyError{"failed"}  // (*MyError, &MyError{})
    }
    return e  // returns interface with type info always set!
}

// reflection shows the truth:
err := makeError(false)
fmt.Println(err == nil)  // false
v := reflect.ValueOf(err)
fmt.Println(v.IsNil())   // true (the VALUE is nil)
fmt.Println(v.Type())    // *main.MyError (the TYPE is set)

func makeError(fail bool) error {
    if fail {
        return &MyError{"failed"}
    }
    return nil  // untyped nil — both words will be nil in the interface
}

// Example: GC-visible effects of zeroing
type Node struct {
    Next *Node
    Data int
}

// When node is GC'd:
// 1. GC runs sweep
// 2. Span marked needzero = 1
// 3. Next allocation from span: memclr called
// 4. Node.Next = nil (zero) — GC won't follow stale pointer

type Mutex struct {
    state int32   // 0 = unlocked, no waiters, not starving
    sema  uint32  // 0 = no goroutines blocked on semaphore
}

// Problem with int:
type SearchFilter struct {
    MinAge int  // 0 could mean "no minimum" OR "must be 0 years old"
}

// With *int:
type SearchFilter struct {
    MinAge *int  // nil = no filter, &0 = must be exactly 0
}

// Usage:
age := 18
filter := SearchFilter{MinAge: &age}

// Or with Go 1.18+ generic helpers:
func Ptr[T any](v T) *T { return &v }
filter := SearchFilter{MinAge: Ptr(18)}

type Counter struct {
    mu    sync.Mutex
    value int
}

c1 := Counter{}
c1.mu.Lock()

// BUG: copying a locked mutex
c2 := c1  // copies the mutex state!
// c2.mu might be in locked state but there's no goroutine holding it

c1.mu.Unlock()
// c2.mu is "locked" with no owner — deadlock territory!

// Option 1: use pointer to Counter
c1 := &Counter{}
c2 := c1  // both point to same Counter (and same mutex)

// Option 2: embed noCopy
type noCopy struct{}
func (*noCopy) Lock()   {}
func (*noCopy) Unlock() {}

type Counter struct {
    _     noCopy  // prevents vet warning from being suppressed
    mu    sync.Mutex
    value int
}

// Go:
func method() {
    var x int  // ALWAYS 0
    fmt.Println(x)  // OK: prints 0
}

s := make([]int, 5, 10)

// All visible elements are zero:
fmt.Println(s)          // [0 0 0 0 0]
fmt.Println(len(s))     // 5
fmt.Println(cap(s))     // 10

// Elements 5-9 exist in backing array but are not accessible:
// s[5]  // PANIC: index out of range

// append uses the pre-allocated capacity:
s = append(s, 99)
fmt.Println(s)     // [0 0 0 0 0 99]
fmt.Println(len(s)) // 6
fmt.Println(cap(s)) // 10 (no reallocation)

// The "hidden" elements 0-9 were all zeroed by make:
// When we appended, element 5 was already 0, then set to 99

import "reflect"

func isZero(v interface{}) bool {
    return reflect.ValueOf(v).IsZero()
}

// Usage:
fmt.Println(isZero(0))           // true
fmt.Println(isZero(""))          // true
fmt.Println(isZero(false))       // true
fmt.Println(isZero((*int)(nil))) // true
fmt.Println(isZero([]int(nil)))  // true
fmt.Println(isZero([]int{}))     // true (empty slice is also "zero" for IsZero)

// Structs:
type Point struct{ X, Y float64 }
fmt.Println(isZero(Point{}))         // true
fmt.Println(isZero(Point{X: 1.0}))  // false

// IsZero for slices:
reflect.ValueOf([]int(nil)).IsZero()  // true
reflect.ValueOf([]int{}).IsZero()     // true (!)
// Both nil and empty slice are "zero" — different from == nil check

func example(cond bool) int {
    var x int  // compiler may or may not emit MOVQ $0
    if cond {
        x = 5
    }
    return x  // if !cond, x must be 0 — so zeroing is required
}

func example2() int {
    var x int  // compiler CAN elide zeroing
    x = compute()  // definitely assigned before use
    return x
}

// Safe: zero value is always visible
var x int
// Any goroutine can safely read x before it's written
// (result is guaranteed to be 0)

// Unsafe: concurrent write and read (even setting to zero)
var x int
go func() { x = 0 }()  // write
fmt.Println(x)           // read — DATA RACE!

// Example: Database connection pool
// Zero value is NOT usable — needs connection string, pool size, etc.
type DB struct {
    pool *connectionPool  // nil = unusable
    dsn  string          // "" = unusable
}

// This type REQUIRES a constructor:
func Open(dsn string, maxConns int) (*DB, error) {
    // validate dsn, create pool, etc.
    return &DB{dsn: dsn, pool: newPool(maxConns)}, nil
}

// Document this clearly:
// DB is a database handle. Use Open to create a DB.
// The zero value of DB is not usable.

// Simplified bytes.Buffer:
type Buffer struct {
    buf      []byte // nil at zero value
    off      int    // 0 at zero value
    lastRead readOp  // 0 = opInvalid at zero value
}

func (b *Buffer) WriteString(s string) (n int, err error) {
    b.lastRead = opInvalid
    m, ok := b.tryGrowByReslice(len(s))
    if !ok {
        m = b.grow(len(s))  // allocates if buf is nil
    }
    return copy(b.buf[m:], s), nil
}

func (b *Buffer) grow(n int) int {
    // If buf is nil (zero value), this is the first write
    if b.buf == nil && n <= smallBufferSize {
        b.buf = make([]byte, n, smallBufferSize)
        return 0
    }
    // ... otherwise grow existing buffer
}

// Get zero value of a generic type:
func Zero[T any]() T {
    var zero T
    return zero  // always returns zero value of T
}

// Build optional type:
type Result[T any] struct {
    value T
    err   error
    valid bool
}

func OK[T any](v T) Result[T] {
    return Result[T]{value: v, valid: true}
}

func Err[T any](err error) Result[T] {
    return Result[T]{err: err}  // value is zero value of T
}

func (r Result[T]) Unwrap() (T, error) {
    return r.value, r.err
}

// Check if generic value is zero:
func IsZero[T comparable](v T) bool {
    var zero T
    return v == zero
}

fmt.Println(IsZero(0))      // true
fmt.Println(IsZero(""))     // true
fmt.Println(IsZero(false))  // true
fmt.Println(IsZero(42))     // false