Go.CodeCompared.To/Dart

Dart requires an explicit void main() function as the program entry point, just like Go's func main(). The print() function is the standard way to write a line to stdout — the equivalent of fmt.Println. Dart uses single or double quotes for strings; the style convention is single quotes.

Dart supports both JIT (just-in-time, for development) and AOT (ahead-of-time, for production) compilation, similar to how Go's go run is for development and go build produces a binary. Dart AOT-compiled binaries are self-contained native executables like Go binaries. Dart also compiles to JavaScript (for web targets) and to Arm/x86 machine code — a flexibility Go does not offer.

Dart has no Printf or format verbs. String interpolation ($variable or ${expression}) combined with methods like toStringAsFixed(), padLeft(), and padRight() replaces most fmt.Printf use cases. For complex padding, padLeft(width, character) fills with a given character.

Dart uses the same // and /* ... */ comment syntax as Go. It adds a third form, /// Doc comment, which is the standard for documenting public APIs and is processed by dart doc into HTML documentation (analogous to godoc comments in Go, which use ordinary // lines immediately before declarations).

Dart splits what Go calls const into two keywords: const for values known at compile time (like Go's const) and final for values set once at runtime and never reassigned (Go has no direct equivalent). Go's short declaration := maps to Dart's var with a type-inferred initializer. Dart types appear before the name, in the C-style tradition Go also follows.

Dart's primitive types map cleanly to Go's: int (arbitrary precision on native, 64-bit on the VM), double (64-bit IEEE 754, replaces Go's float64), bool, and String. Note that Dart has a single int type (no int32, int64, uint8, etc.) and a single double — there is no float32.

Dart uses method-style conversions (number.toDouble(), number.toString()) rather than Go's C-style cast syntax (float64(number)). Parsing strings uses static methods: int.parse() and double.parse() — which throw FormatException on failure rather than returning a second value like Go's strconv.Atoi(). Use int.tryParse() to get null instead of an exception.

Dart's dynamic is the rough equivalent of Go's interface{} (now any): a variable that can hold any type. However, Dart also offers Object? as a safer alternative — like dynamic but with compile-time checks that prevent calling unknown methods. The is operator narrows the type within a conditional block, similar to a Go type assertion.

Dart 3 introduced Records ((int, int)) as the equivalent of Go's multiple return values. Records are anonymous value types: return (minimum, maximum) creates one, and destructuring with final (minimum, maximum) = ... unpacks it. Records can also have named fields: ({int min, int max}). Before Dart 3, you had to return a List or a custom class.

In Go, nil is a valid value for pointers, interfaces, slices, maps, channels, and functions — and a nil dereference causes a runtime panic. In Dart, null safety is enforced at compile time: a String can never hold null, only String? can. The compiler tracks nullability through every expression and prevents unguarded use of a nullable value.

Where Go uses pointer types (*int) to express "optional" fields, Dart uses int? — the ? suffix makes any type nullable. There is no pointer dereference: if you check config.port != null, Dart automatically promotes the type to non-nullable int inside the if block. Struct fields that may be absent are much cleaner to express in Dart.

Dart's null-aware operators replace the boilerplate if x == nil guards that appear throughout Go code: ?? provides a fallback value (like Go's common if x == nil { x = default } pattern), ?. short-circuits to null instead of panicking (Go has no equivalent), and ??= is a conditional assignment. The ! operator asserts non-null and panics if wrong — similar to a forced nil dereference in Go.

Dart's late keyword declares a non-nullable variable that will be set before it is first read, with the check deferred to runtime. This avoids the Go pattern of using a pointer solely to express "not yet initialized" — the field is still String, not String?. If a late variable is read before assignment, Dart throws a LateInitializationError.

Go allows only double-quoted strings; Dart allows both single and double quotes interchangeably (the Dart style guide prefers single quotes). Dart's raw strings are prefixed with r — r'C:\Users\alice' — which behaves exactly like Go's backtick raw strings: backslashes are literal and no escape sequences are processed.

Dart has native string interpolation: $variable for simple names, ${expression} for any Dart expression. This replaces Go's fmt.Sprintf for the common case of building strings. No format verbs are used — if you need precise numeric formatting, call methods like toStringAsFixed(2) inside ${}.

Dart supports triple-quoted strings ("""...""" or '''...''') for multiline content — strings that span multiple lines without any special escaping. Unlike Go's backtick strings, triple-quoted Dart strings still support interpolation and escape sequences. The opening triple-quote is typically followed by a newline, and the content starts on the next line.

In Go, most string operations live in the strings package as free functions: strings.ToUpper(s), strings.Contains(s, substr). In Dart, they are methods on the String type itself: message.toUpperCase(), message.contains('World'). This means a Dart import is rarely needed for basic string work — the core library is always available.

Dart's List<T> is the equivalent of Go's slice. Both use zero-based indexing and a length property. The key difference is that Dart has no slice syntax — instead of numbers[1:4], you call numbers.sublist(1, 4). Dart lists are also growable by default (no separate append step needed), while Go's slices require make or append to extend.

Dart's List has a rich method API that replaces many patterns that require manual index arithmetic in Go. Appending uses add() and addAll() instead of append. Removing an element by index is a single removeAt(2) call — there is no equivalent of Go's slice-splice idiom (items[:i] + items[i+1:]...). Sorting calls the in-place sort() method instead of importing a package.

Go has no built-in set type — Go idiom is to use a map[T]struct{} and check key presence. Dart has a first-class Set<T> with literals ({'a', 'b'}), automatic deduplication, and built-in operations like intersection(), union(), and difference(). Note: an empty {} is inferred as Map, not Set; use <String>{} for an empty set.

Go has no built-in higher-order list functions — filtering and mapping require manual for loops and append. Dart's Iterable API provides where(), map(), fold(), any(), every(), and more as first-class operations with concise anonymous function syntax. Note that map() returns a lazy Iterable, not a List; call .toList() to materialize it.

Dart map literals use the same curly-brace syntax as Go map literals, but without the map[K]V type prefix. The key difference in lookup: Go returns a zero value and a bool (value, ok := m[key]), while Dart returns the value or null for a missing key. Since keys can legitimately map to null, use containsKey() to distinguish "key absent" from "key maps to null".

Dart's Map uses method calls where Go uses built-in syntax: inventory.remove(key) instead of Go's delete(map, key); length is inventory.length rather than len(inventory). The putIfAbsent() and update() methods condense the common Go pattern of reading a value, checking existence, then writing — into a single call.

Go iterates maps with for key, value := range m; the iteration order is intentionally random. Dart iterates with for (final entry in map.entries) and the order reflects insertion order (Dart's Map is insertion-ordered since Dart 2). Dart provides entries, keys, and values as views on the map, plus forEach() as a functional alternative.

Dart's if/else syntax is identical to Go's, including the requirement for braces. One difference: Go allows a short initialization statement in the condition (if err := doSomething(); err != nil), while Dart does not support that form. Dart does support if expressions (introduced in Dart 3.3): final label = if (score >= 90) 'A' else 'B'.

Dart's C-style for loop and while loop work identically to Go's equivalents (Go's for with one condition is its while loop). Dart adds a do-while loop, which Go famously omits. The example collects values into a list and prints with join() to keep the output on one line without needing dart:io's stdout.write().

Go's for index, value := range slice always provides both index and value, with _ to discard either. Dart's for (final item in collection) provides only the value — there is no built-in two-argument form. To get the index, use a C-style loop, collection.asMap().forEach(), or the indexed getter (for (final (index, item) in fruits.indexed) in Dart 3.3+).

Dart 3 introduced switch expressions that return a value directly, similar to Rust's match arms. The || operator combines multiple patterns in one arm (replacing Go's comma-separated case list). The wildcard _ serves as the default. Unlike Go, Dart switch cases do not fall through by default — there is no need for break, and there is no fallthrough keyword.

Dart function syntax places the return type before the function name (like C and Go) and uses void for functions that return nothing. Unlike Go, Dart puts the type before each parameter name rather than after it — int add(int first, int second) vs Go's func add(first int, second int) int. Adjacent parameters of the same type cannot be grouped: you must write int first, int second, not first, second int.

Dart supports named parameters by wrapping them in curly braces in the function signature. Named parameters are optional by default; add required to make them mandatory. Callers pass them by name in any order. This is one of Dart's biggest ergonomic improvements over Go, where large function signatures with similar-typed parameters are fragile (callers can silently swap arguments of the same type).

Dart offers two kinds of optional parameters: named (with { }) and positional (with [ ]). Positional optional parameters must appear after all required parameters, and callers omit them from the right. Go has no built-in default parameter values; the closest idiom is a sentinel value (pass 0 for int, "" for string) or an options struct.

Dart's arrow syntax (=> expression) defines a function that evaluates the expression and returns it — exactly one expression, no return keyword. It is the equivalent of Ruby's endless method (def double(n) = n * 2), and serves the same brevity purpose as Go's single-line function bodies. The arrow is commonly used with callbacks and collection methods.

Both Go and Dart treat functions as first-class values. Dart's function type syntax is int Function(int) (return type first, then the Function keyword with parameter types in parens), compared to Go's func(int) int. In practice, both communities use type inference to avoid writing the type in most local variables, letting the compiler infer it from the initializer.

Closures work identically in Go and Dart: an inner function captures variables from its enclosing scope by reference, and the captured state persists across calls. The syntax differs (func() int { ... } vs () { ... }) but the semantics are the same. Dart closures that have no parameters can use the short form () { ... }; with arrow syntax a zero-parameter closure is () => expression.

Go's standard library has no generic Filter or Map for slices — you write the loop yourself. (Go 1.23+ adds slices and iter packages with some helpers, but they are not yet universally used.) Dart's Iterable API provides where(), map(), reduce(), and fold() as built-in operations, making functional pipelines idiomatic.

Go has no classes — data is held in structs and methods are defined separately with a receiver. Dart is a pure OOP language: fields and methods are declared inside the class block, and all values are objects (there are no primitive types separate from the type system). Dart's this.name initializing constructor shorthand eliminates the common boilerplate of assigning each parameter to a field.

Go uses constructor functions by convention (NewPoint(), NewOrigin()). Dart builds multiple constructors directly into the class using named constructors (Point.origin(), Point.fromMap()). The initializer list (: x = 0, y = 0) sets fields before the constructor body runs, which is required for final fields. The @override annotation on toString() has no Go equivalent — Go has no inheritance and no interface annotations.

Go favors composition via struct embedding — a struct that embeds another type "inherits" its methods, but there is no subtype relationship and no polymorphism in the OOP sense. Dart uses classical inheritance with extends: a Circle is a subtype of Shape, method overriding is declared with @override, and a Shape variable can hold any subclass. This enables polymorphic dispatch, which Go achieves only through interfaces.

Go uses conventional methods (Fahrenheit() with a call site of temp.Fahrenheit()) for computed properties. Dart has first-class get and set keywords that turn methods into properties: the getter is invoked as temp.fahrenheit (no parentheses), and the setter is invoked as temp.fahrenheit = 32. This allows computed properties to be interchangeable with stored fields at the call site.

Go has no struct-level static members; class-wide shared state is expressed as package-level variables. Dart has static fields and methods that belong to the class, not any instance. Static members are accessed via the class name (Counter.totalCreated), not via an instance — just like Go accesses package-level variables via the package name (package.Variable).

Go interfaces are implicitly satisfied — a type implements an interface just by having the right methods, with no declaration at the definition site. Dart requires an explicit implements Shape declaration. Dart uses abstract class to define interfaces (Dart 3 also adds the interface keyword for pure interface types). Unlike Go, Dart's abstract class can contain concrete methods with a body alongside abstract ones.

Both Go and Dart support implementing multiple interfaces. Go embeds interfaces to compose them: type ReadWriter interface { Reader; Writer }. Dart does the same with an abstract class: abstract class ReadWriter implements Reader, Writer {}. A concrete class then implements the combined interface. The key difference is that Go's interface is implicit (any type with the right methods satisfies it), while Dart requires the implements declaration.

Go uses struct embedding to compose behavior — embedding a struct adds its fields and methods to the outer struct. Dart has a first-class mixin keyword for the same purpose: a mixin defines reusable methods that a class can with in. Mixins are distinct from inheritance (extends) because they compose horizontally rather than forming a subtype relationship. A class can mix in multiple mixins (with Logger, Timestamper).

Go uses a type switch (switch x := value.(type)) to branch on the concrete type behind an interface. Dart uses is and as: the is operator checks the type and automatically promotes the variable to that type within the branch (no explicit cast needed). Dart 3 also supports sealed class hierarchies with exhaustive switch expressions, giving compile-time guarantees that all cases are handled.

Both languages have generics, but the syntax differs: Go uses square brackets ([T any], [T comparable]), while Dart uses angle brackets (<T>). Type parameters in both languages are inferred at call sites when possible. Dart's constraint system is simpler than Go's — Dart relies on extending a bound class (<T extends Comparable<T>>) rather than Go's interface-based type sets.

Generic classes use the same angle-bracket syntax as generic functions. One conceptual difference: where Go's generic Pop uses a second bool return to signal "empty stack", Dart throws an exception (StateError). There is no zero-value trick in Dart for an empty generic (var zero T), because Dart's null safety means you would need T? and return null instead.

Go constrains type parameters with interfaces as type sets (constraints.Ordered allows >). Dart uses extends to constrain a type parameter to a class or interface: T extends Comparable<T> requires the type to implement the compareTo() method. The result is that Dart calls a method (first.compareTo(second)) where Go uses an operator (first > second).

This is the most fundamental difference between Go and Dart. Go requires explicit error propagation — every fallible function returns (value, error) and the caller must check the error every time. Dart uses exceptions: a function either returns a value or throws; the caller wraps a block with try/catch to handle failures. The Go style makes all error paths visible at every call site; the Dart style concentrates error handling at a chosen boundary.

Dart's on ExceptionType catch (exception) syntax catches a specific type, similar to how Go checks errors.Is(err, target) or a type assertion. The bare catch (exception) with no on clause catches any type. The finally block always runs, mirroring Go's defer — but defer runs deferred functions in LIFO order at function exit, while finally runs only within its try block.

Custom error types in Go implement the error interface by providing an Error() string method. Custom exceptions in Dart implement the Exception interface (or extend Error for programming errors) and override toString(). The Dart on ValidationException clause replaces Go's errors.As(err, &target) pattern for type-checking errors.

In Go, every function in a call chain must explicitly pass errors up with fmt.Errorf(...%w, err), adding context at each level. In Dart, exceptions propagate automatically up the call stack until a catch clause handles them — intermediate functions need no error-handling code at all. The Go approach makes all error paths explicit in the source; the Dart approach makes the happy path cleaner at the cost of sometimes surprising exception propagation.

Go's concurrency model uses goroutines (lightweight threads managed by the Go runtime) and channels (typed message queues). Dart uses a cooperative async model: a Future<T> is a promise of a single value, and async/await suspends a function until the value is available. Dart's event loop is single-threaded — there is no true parallelism within a single Isolate. Use Future.wait() to run multiple futures concurrently (interleaved on the event loop, not in parallel).

Dart's async/await makes asynchronous code read like sequential synchronous code. An async function always returns a Future; await suspends the function until the Future completes. Error handling in async code uses the same try/catch as synchronous code — no special goroutine or channel mechanics. The pattern is closely analogous to JavaScript's async/await, which is no coincidence — Dart and JavaScript share the same event-loop concurrency model.

Go channels are typed communication pipes between goroutines: a goroutine sends on one end, another receives on the other, and the channel buffers values. Dart Streams are asynchronous sequences of values: an async* function yields values one at a time, and the consumer iterates with await for. Streams support the same functional transforms as lists (map(), where(), take()), making them composable pipelines. Unlike Go channels, Streams are single-subscription by default.

Go goroutines share memory with a lock-based synchronization model (sync.WaitGroup, sync.Mutex). Dart Isolates are fully isolated — they have no shared memory and communicate only by passing messages through ports. This eliminates data races by design, at the cost of copying data between Isolates. For I/O-bound work (most async code), async/await on a single Isolate is sufficient. Use Isolate.run() for CPU-bound work that would otherwise block the event loop.