Dart.CodeCompared.To/Go

The full Go equivalent is package main plus import "fmt" plus func main() { fmt.Println("Hello, World!") }. Printing lives in the fmt package rather than being built in, names are exported by capitalization (Println is public because it is capitalized), and Go's formatter uses tabs — the tooling, not the programmer, decides layout.

Go's := is the everyday short declaration — it declares and infers in one step, like Dart's var with inference. There is no final/const distinction for locals (Go's const is for compile-time constants only, covered later). Two Go rules bite immediately: an unused local variable is a compile error, and so is an unused import.

Go deliberately omits the ternary ?:, so Dart's cond ? a : b becomes a small if statement. It is more verbose, and intentionally so — the language favors one obvious way to write each thing. Note Go requires braces on every if and forbids parentheses around the condition.

Like Swift, Go does no implicit numeric conversion: float64(count) + 0.5 must convert, where Dart quietly promotes an int. There is no ~/ — / on two integers already truncates — and no num supertype. Go's numeric types are explicit about size (int, int64, float64, byte), and mixing them without a conversion will not compile.

A fallible Go function returns (value, error), and the caller inspects err immediately — the if err != nil you will write hundreds of times. Where Dart lets an exception propagate up the stack automatically, Go makes every failure explicit and local. The upside is that the control flow is visible; the cost is verbosity that the language considers a fair trade.

Any type with an Error() string method is an error — the same implicit-interface rule as everything else in Go. You wrap context around an error with fmt.Errorf("…: %w", err), then test the chain with errors.Is (matches a sentinel) or errors.As (extracts a concrete type). This replaces Dart's on FormatException catch type-based dispatch with value inspection.

Dart's finally becomes Go's defer: a deferred call runs when the surrounding function returns, no matter how. It is the idiomatic way to pair cleanup with acquisition — file, _ := os.Open(name); defer file.Close() — placing the cleanup right next to the setup. Multiple defers run in last-in, first-out order.

Go does have panic/recover, but they are not Dart's throw/catch — they are reserved for truly unrecoverable situations (programmer bugs, impossible states), not ordinary error flow. recover only works inside a defer. If you find yourself reaching for panic to signal a normal failure, Go's answer is: return an error instead.

Go has no class. Data lives in a struct, and methods are declared separately as functions with a receiver — func (r Rectangle) Area(). There is no constructor keyword and no this; the receiver name (r) is whatever you choose. Fields and methods are exported by capitalization, so Width and Area are public.

A value receiver (func (c Counter)) operates on a copy and cannot mutate the original; a pointer receiver (func (c *Counter)) can. Go conveniently auto-references counter.Increment() as (&counter).Increment() for you. This value/pointer split — invisible in Dart, where everything is already a reference — is the thing to stay conscious of when passing structs around.

Go has no inheritance. Instead you embed one struct in another, and the embedded type's methods are promoted so dog.Describe() works — composition that reads like inheritance but is not. There is no super, no overriding in the polymorphic sense, and no class hierarchy; behavior is shared by embedding structs and satisfying interfaces.

Go interfaces are satisfied implicitly: any type with the right methods conforms, with no implements declaration anywhere — structural, like TypeScript, but for method sets. This means you can define an interface after the types that satisfy it, and make types you do not own conform. Interfaces are kept small (often one method), and accepting an interface rather than a concrete type is the idiomatic way to decouple.

Go's any (an alias for the empty interface interface{}) is the closest thing to Dart's Object/dynamic — it holds any value. To get back to a concrete type you use a type assertion (item.(int), with a comma-ok form) or a type switch as above, which parallels Dart's type-pattern switch. Reaching for any is discouraged, though; Go prefers a specific interface or a generic (later).

There is no ? type, no ?., and no ?? — and crucially no compile-time protection. A nil pointer dereference compiles cleanly and panics at run time, which is exactly the class of bug Dart's null safety was built to eliminate. The discipline Go asks for is manual if x != nil guards; the zero-value design below softens how often you need them.

Every Go variable is usable immediately because it starts at its type's zero value — 0, "", false, nil, or a struct with all-zero fields. There is no "used before assigned" error like Dart's, because there is no uninitialized state. Well-chosen zero values (a ready-to-use sync.Mutex, an empty-but-usable bytes.Buffer) are a deliberate design goal in Go APIs.

Multiple return values are a built-in language feature in Go, not a tuple or record type — func divmod(a, b int) (int, int). It reads like Dart's record return and destructure, but the values are separate, and you must consume each one: assign an unwanted result to the blank identifier _. This is the mechanism behind the ubiquitous (value, error) pattern.

Go has no named arguments, no default parameter values, and no optional parameters — a stark contrast with Dart's rich parameter syntax. The idiomatic replacement is an options struct (as above), whose fields double as named, defaultable arguments via their zero values. For libraries, the "functional options" pattern (variadic ...Option functions) is the other common answer.

Go's variadic parameter numbers ...int collects trailing arguments into a slice, so callers write sumAll(1, 2, 3, 4) with no list literal — something Dart cannot express, since Dart has no varargs. Closures work as in Dart (functions are values that capture their environment), and you can spread an existing slice into a variadic call with sumAll(nums...).

A Dart List is a Go slice ([]int), the everyday growable sequence. The surprise is append: it may allocate a new backing array and returns the result, so you must write numbers = append(numbers, 4) — ignoring the return value is a classic Go bug. Length is the free function len(numbers), not a property.

A Go slice expression original[1:3] creates a view over the same backing array, not a copy, so writing through the sub-slice mutates the original — the opposite of Dart's sublist, which copies. This makes slicing cheap but aliasing-prone; when you need an independent copy, allocate one with make and copy(dst, src).

A Go map[string]int is Dart's Map, but a missing key returns the value type's zero value (0 here), not null — so you cannot tell "absent" from "present but zero" by the value alone. The comma-ok form, age, ok := ages["Grace"], gives you the presence flag Dart's containsKey provides. A nil map reads fine but panics on write, so create maps with make or a literal.

Go long resisted functional collection helpers, so the idiomatic transform is an explicit for/range loop rather than Dart's fluent where/map chain. Go 1.21+ added a slices package (and 1.23 iterators) with some helpers, but the loop remains the norm — the language prizes a visible, allocation-obvious transformation over a chained one.

Go has exactly one loop keyword: for. The three-part form is familiar, a condition-only for n > 0 is the while Go does not have, and a bare for { } loops forever. To iterate values you use for index, value := range collection, which covers slices, maps, strings, and channels — the workhorse you will reach for constantly.

Go's switch does not fall through by default — each case breaks on its own, so no break is needed (the explicit fallthrough keyword exists but is rare). Multiple values share a case with commas. A bare switch { case cond: … } with no subject acts as a clean if/else if ladder, and cases can be any type, not just constants.

Go's if can carry an init statement before the condition — if value, err := …; err == nil — and the variables it declares are scoped to the if/else only. This keeps a short-lived result (very often the (value, err) pair) from leaking into the surrounding scope, and it is one of Go's most-used idioms for tidy error handling.

Go has no enum type. The idiom is a named integer type plus a const block using iota, which auto-increments down the block (0, 1, 2, …). A String() method gives readable printing, standing in for Dart's .name. It is more manual than a Dart enum — there is no free values list and no exhaustiveness check — but it compiles to plain integers.

Where Dart marks async work with Future/async/await, Go writes ordinary synchronous functions and runs them concurrently with go. There is no coloring of functions and no await; you coordinate completion with a sync.WaitGroup (a counter) or channels. Each goroutine here writes its own slot, so no lock is needed — but because goroutines share memory, that safety is your responsibility, unlike Dart isolates.

A channel is a typed pipe that goroutines use to communicate and synchronize — send with ch <- v, receive with <-ch, and an unbuffered channel makes the sender wait for a receiver (a rendezvous). It is Go's motto in code: "share memory by communicating." Ranging over a channel drains it until it is closed, which loosely parallels consuming a Dart Stream — but the hand-off is a first-class language primitive, not a library type.

Because every goroutine touches the same total, the unguarded total += n would be a genuine data race — so the sync.Mutex is doing load-bearing work (Go's race detector, go run -race, will flag it if you forget). A Dart programmer coming from isolates must relearn that shared mutable state is possible and must be protected. Go's preferred alternative is often to pass ownership over a channel instead of locking.

Go gained generics in 1.18, and the shape is familiar: type parameters in square brackets, func FirstOr[T any](…), with any as the unconstrained bound. Constraints are expressed as interfaces — the built-in comparable, or constraints.Ordered for <, or any interface you define. Inference usually lets you omit the explicit [int]. Generics arrived late and are used sparingly; a concrete type or a plain interface is still often preferred.

Go has no string interpolation. You format with fmt.Printf (prints) or fmt.Sprintf (returns a string) using verbs — %s for strings, %d for integers, %v for anything, %q for a quoted string. It is closer to C's printf than to Dart's $name, and the compiler does not check that your verbs match the arguments (though go vet does).

A Go string is an immutable sequence of bytes holding UTF-8, so len(text) is a byte count — 5 for "café", because é takes two bytes — not a character count. To count characters you use utf8.RuneCountInString, and ranging over a string yields runes (Unicode code points) with their byte offsets. Dart's String is UTF-16 with its own surrogate-pair caveats, but the byte-vs-character gap here surprises most newcomers.

Go organizes code into packages (a directory of files that share a namespace), imported by path, where Dart imports individual files. Visibility is decided by capitalization: AreaOfCircle is exported because it starts with a capital letter, helper is package-private because it does not — replacing Dart's leading-underscore convention with a rule you can see at every call site. The Dart side references a second file, so its column is display-only.

Dart's pubspec.yaml plus dart pub get corresponds to a go.mod file plus the go tool (go get, go mod tidy). Import paths are URLs (github.com/…) resolved directly from source hosts rather than a central registry like pub.dev, and go mod tidy keeps go.mod in sync with the imports your code actually uses.