Dart Reference

var declares a mutable variable with type inference — the type is inferred at compile time but the value can be reassigned. final declares a runtime-immutable variable: it can only be set once, but its value can be determined at runtime. const declares a compile-time constant: the value must be known at compile time and is deeply immutable. For example, const pi = 3.14159 is evaluated at compile time, while final startTime = DateTime.now() is set once at runtime when the line executes.

Dart's sound null safety means variables cannot be null unless you explicitly declare them as nullable with a ? suffix (String? name). The null-aware conditional accessor (?.) calls a method or property only if the object is not null: name?.length returns null if name is null rather than throwing. The null coalescing operator (??) provides a default: name ?? "Guest" returns "Guest" if name is null. The ??= assignment sets a value only if the variable is null. The ! operator asserts a nullable value is non-null — it throws if the value is actually null.

A Future represents a single asynchronous value that will be available at some point in the future — like a HTTP response or a file read. A Stream represents a sequence of asynchronous events over time — like socket messages, user events, or an async generator. You await a Future to get its value. You listen to or await for a Stream to process each event. Use async* with yield to create a Stream generator, and await for to consume it.

A mixin is a way to reuse code across multiple class hierarchies without inheritance. Defined with the mixin keyword, a mixin adds methods and properties to a class using the with keyword. For example, mixin Swimmer adds a swim() method that can be added to any class: class Duck with Swimmer. Unlike inheritance, you can apply multiple mixins to a single class. Use mixins when you want to share behavior (like logging, serialization, or animation) across unrelated classes.

A factory constructor is a special constructor that does not always create a new instance — it can return an existing one from a cache. This is the standard way to implement singleton-like patterns or instance caching in Dart. For example, the Logger class uses a static map as a cache and returns an existing Logger instance if one already exists for the given name. Factory constructors are declared with the factory keyword and must return an instance of the class type.

Dart provides powerful collection literals. The spread operator (...) inserts all elements of one collection into another: [0, ...list, 3]. The null-aware spread (...?) handles nullable collections safely. Collection-if adds elements conditionally: [if (isLoggedIn) dashboardRoute]. Collection-for generates elements from an iterable: [for (var item in items) item.toUpperCase()]. These operators allow you to build complex collections declaratively in a single expression without temporary variables.

StreamController gives you manual control over a Stream — you can add events (controller.add(value)), add errors (controller.addError()), and close the stream (controller.close()). You expose controller.stream as a public property and drive it from elsewhere in your code. This is useful when you need to bridge non-async APIs (like callbacks or event listeners) into Dart streams, or when you need to multicast events to multiple listeners using StreamController.broadcast().

The extends keyword in a generic parameter adds a type constraint. For example, T max<T extends Comparable<T>>(T a, T b) requires that T implements Comparable<T>, which gives you access to the compareTo() method inside the function. Without the constraint, you cannot call any methods specific to a type on the generic parameter. Constraints allow you to write reusable, type-safe utility functions that work with any type satisfying the constraint.