TypeScript.CodeCompared.To/Go

Go is compiled and statically typed ahead of time, where TypeScript transpiles to JavaScript. Printing goes through the fmt package rather than a global console; a real program also declares package main and a func main() entry point.

Go has no string interpolation. Printf uses C-style verbs — %s for strings, %d for integers, %v for any value — and you must add the trailing \n yourself, unlike Println.

Go's := infers the type and declares in one step, like an untyped let. The explicit form is var count int = 3. There is no const/let mutability split — every variable is reassignable, and an unused local variable is a compile error.

A declared-but-unassigned variable in Go is never undefined — it takes its type's zero value: 0 for numbers, "" for strings, false for booleans, nil for pointers and slices. This removes a whole category of undefined bugs.

Go never converts between types implicitly — not even int to float64. Numbers and strings cross over through the strconv package, and Atoi returns a value and an error, which you discard here with the blank identifier _.

Strings in Go are immutable byte sequences with no methods of their own — operations live as functions in the strings package. Note that len counts bytes, not characters, so a multi-byte UTF-8 rune counts as more than one.

To work with characters rather than bytes, convert a string to []rune — a rune is a Unicode code point (an int32). This is the Go counterpart to spreading a string into an array of code-point strings in TypeScript.

Where TypeScript has one number, Go has a family of sized integer and float types — int8 through int64, uint8, float32, float64. You pick the width, and overflow wraps rather than losing precision silently.

Division of two integers in Go truncates toward zero — 7 / 2 is 3, not 3.5. To get a float result, at least one operand must be a float, as in 7.0 / 2.0.

Go's growable list is the slice, []int. It has no push method; instead append returns a (possibly relocated) slice that you reassign. Every element must share the declared type — no mixed-type arrays.

The slice expression items[1:3] is half-open, like slice(1, 3), but it returns a view that shares the underlying array rather than a copy. Go has no negative indexing, so the last element is items[len(items)-1].

Go slices have no map/filter/reduce methods — you write an explicit for...range loop. The range form yields an index and a value; _ discards the index. This verbosity is a deliberate Go preference for explicitness.

A Go map[string]int is a typed hash map — both key and value types are fixed at declaration. Unlike a TypeScript object, it is not an open struct; it is purely a dynamic key/value store.

Indexing a missing key returns the zero value, so you cannot tell "absent" from "present but zero" by the value alone. The "comma ok" idiom — value, ok := m[key] — gives a second boolean telling you whether the key existed.

Go's if can declare a variable scoped to the statement before the condition. Parentheses around the condition are forbidden and the braces are mandatory — there is no single-line braceless if.

Go has a single loop keyword, for. The three-clause form is familiar; drop the init and post clauses and it becomes a while; drop everything for an infinite loop. There is no separate while or do...while.

Go's switch does not fall through by default, so no break is needed, and one case can list several values. You can also write a tagless switch { case cond: } as a clean replacement for an if/else if chain.

The type comes after each parameter name, and consecutive same-typed parameters share one annotation (a, b int). The return type follows the parameter list. An explicit return is always required.

Go functions return multiple values natively — no tuple type or array wrapper. This is the foundation of Go's idiomatic error handling, where a function returns (result, error) as two separate values.

A deferred call runs when the surrounding function returns, no matter how — the Go answer to finally. Deferred calls run in last-in-first-out order, which keeps resource cleanup right next to the acquisition that needs it.

A Go struct is the equivalent of a TypeScript interface used as a record, but it is a concrete value type, not just a shape. A capitalized field name (X) is exported (public); a lowercase one is package-private.

Go has no classes. A method is a plain function with a receiver in parentheses before its name — (p Point) binds p like this. Methods live outside the type definition, decoupling data from behavior.

To mutate the receiver, a method takes a pointer receiver (c *Counter); a value receiver would mutate a copy. Go makes the value-vs-reference distinction explicit, where JavaScript objects are always shared references.

Go interfaces are satisfied implicitly: Dog has a Speak() string method, so it is a Speaker with no implements clause. This is structural typing like TypeScript's, but enforced by the compiler at the point of use.

The empty interface any (an alias for interface{}) holds a value of any type, like TypeScript's unknown. A type switch — switch value.(type) — recovers the concrete type at runtime, the Go counterpart of narrowing with typeof.

Go has no exceptions for ordinary failures. A function returns an error value alongside its result, and the caller checks if err != nil. The explicit %w verb wraps an underlying error so it can be unwrapped later.

panic and recover resemble throw/catch, but Go reserves them for truly unrecoverable bugs, not routine errors. recover only works inside a deferred function — the idiom that stops a panic from crashing the program.

The go keyword starts a goroutine — a lightweight thread scheduled by the Go runtime, far cheaper than an OS thread. Unlike await, the call returns immediately; a sync.WaitGroup blocks until all the spawned goroutines finish.

Channels are typed pipes that goroutines use to communicate and synchronize: results <- 42 sends, <-results receives and blocks until a value arrives. Go's motto is "share memory by communicating," replacing shared-state locking with message passing.

Go added generics in 1.18 with square-bracket type parameters, much like TypeScript. The constraint any means "any type"; more specific constraints such as comparable or a custom interface limit what operations the body may use.

A constraint is an interface listing the permitted types with a union. The ~int tilde means "any type whose underlying type is int," so named types qualify too. This is stricter and more explicit than TypeScript's extends constraint.