Dart

In Dart, Object? and dynamic both accept any value, including null, but Object? keeps static checking: you test with is or cast with as before using String members. dynamic switches checking off, so calls compile and fail only at runtime.

Dart 3 switch statements never fall through from a non-empty case: its body runs and control leaves the switch, so no break is needed. Empty cases share the next body, and continue with a label jumps into another case.

In Dart, on Type picks which thrown objects a clause handles, catch (e, st) binds the object and its StackTrace, the first matching clause in source order wins, and finally runs whether or not anything was thrown.

Dart functions take required positional parameters first, then either optional positional ones in [ ] or named ones in { }, never both; optional ones need a constant default or a nullable type. Named parameters read clearly and can be skipped individually.

In Dart, / always returns a double, ~/ returns an int truncated toward zero (-7 ~/ 2 is -3), and % is Euclidean modulo whose result is never negative (-5 % 3 is 1); remainder() gives the sign-following remainder.

late lets a non-nullable variable be declared without an initializer and assigned later. Dart checks it at runtime instead, so reading it before any assignment throws a LateInitializationError rather than producing null.

In Dart, a?.b reads b only when a is non-null and otherwise yields null; a ?? b yields a unless it is null, evaluating b only then; a ??= b assigns b only when a is currently null.

In Dart, String can never hold null while String? holds a String or null, so members like length need a check first. Sound means the guarantee holds at run time: an expression whose static type is non-nullable never evaluates to null.

In Dart, the postfix ! casts a nullable expression to its non-nullable type; if the value is null it throws a TypeError, 'Null check operator used on a null value'. The compiler stops checking, so a wrong assumption becomes a runtime crash.

In Dart, a public field may be overridden by a getter and a non-final one reassigned between check and use, so flow analysis cannot promote it. Copy it into a local, or since Dart 3.2 make it private and final.

A factory constructor runs arbitrary code and then returns an instance it chooses: a cached object, a subtype, or one built via another constructor. It cannot use this or an initializer list, cannot return null, and cannot be called with super.

index is the value's zero-based position in the declaration and name is its source identifier as a String. The generated static values list holds every value in order; values.byName('x') finds one by name and throws ArgumentError when none matches.

Dart's List keeps identity equality: == is true only for the same list object, and every non-const literal creates a new one. Compare contents with Flutter's listEquals, package:collection's ListEquality, or a length check plus element loop.

An extension method adds a member to an existing type, including types you do not own, via extension Name on Type { ... }. It may declare methods, getters, setters, operators and static members, but no instance fields, constructors or abstract members.

extends makes a subclass that inherits the superclass's implementation, and a class has exactly one superclass. implements only adopts the implicit interface of each listed class, so the class must itself implement every instance member, fields included, but not constructors or statics.

Put type parameters in angle brackets after the name: class Page<T> { final List<T> items; } or R transform<R>(...). Callers pass Page<Order> or let inference pick the argument, and every use of T is then checked statically.

Reified means every generic object keeps its type arguments at run time, so is List<String> checks, x is T tests and <T>[] literals work. T still cannot be constructed or used to call static members.

a is List<dynamic> because nothing constrains it, b is List<num> because upward inference takes the upper bound of int and double, and c is List<int> because the declared type flows down into the literal.

A bound restricts type arguments to subtypes of the bound and lets generic code call the bound's members on T. T extends Object excludes nullable types. When an argument is omitted and nothing infers it, Dart instantiates to the bound.

jsonDecode creates a List<dynamic>, and reified generics mean it stays List<dynamic> whatever it contains, so as List<Map<String, dynamic>> fails. Treat it as List<dynamic> and convert each element, or use cast, List.from or whereType.

Declare a record return type such as ({double min, double max}) and return (min: lo, max: hi). The caller reads range.min and range.max, or $1 and $2 for positional fields, with each field keeping its static type.

A Dart 3 switch expression yields a value: cases are pattern => expression, comma-separated, _ is the only default, and it must be exhaustive. A switch statement runs statements and is exhaustiveness-checked only on types like enums, bool and sealed classes.

Write if (json case {'name': String city, 'main': {'temp': num temp}}). It checks that json is a map with those keys and value types, binds city and temp only on a full match, and otherwise runs the else branch.

Declare sealed class PaymentResult with one subclass per outcome in the same library, each holding its own data, then switch over it with one object pattern per subtype and no wildcard. The compiler proves coverage and flags every switch when an outcome is added.

Write a pattern variable declaration: var (city, temp) = latestReading(); for a positional record, final (:city, :temp) = ... for named fields, and var Forecast(:high, :low) = forecast; to read an object's getters into new locals.

A growable Dart List can add and remove elements; a fixed-length one only lets you overwrite them, and length changes throw UnsupportedError. List.filled and List.empty default to fixed-length, while literals, List.of and List.generate are growable.

A Dart Iterable is any sequence you can step through; a List adds indexing, a stored length and mutation. map, where and similar methods return a lazy Iterable that computes nothing until iterated, so you call toList() to get a List.

A collection if element adds its element only when the condition is true, and a spread ... inserts every element of another iterable in place, so a whole children list, conditional groups included, is one declarative literal instead of a mutable list.

final only stops the variable from being reassigned; the list object it points to stays growable. A list rejects writes only when the object itself is unmodifiable: a const literal, a List.unmodifiable copy or an UnmodifiableListView, and then writes throw UnsupportedError at runtime.

In a Dart map, [] returns a nullable value, so counting needs counts[w] = (counts[w] ?? 0) + 1. update(w, (n) => n + 1, ifAbsent: () => 1) does it in one call; putIfAbsent returns the stored value and suits get-or-create grouping.

onPressed expects a function to call later; _save() calls the method during build and passes its result, a void value the analyzer rejects. _save passes the method itself as a tear-off, and () => _save() passes an anonymous function that calls it.

A Dart function type is a function header with its name replaced by the keyword Function: int Function(String) accepts one String and returns an int. It can annotate parameters, fields, variables, return types and type arguments.

A tear-off names a function, method or constructor without parentheses, producing a function object that calls it: print, int.parse, buffer.write, User.new. Prefer it over a lambda that only forwards arguments; keep the lambda when arguments must be adapted or the receiver re-read.

Name the shape once with typedef Validator = String? Function(String value);, write factory functions that return configured validators, and a combinator that takes a List<Validator> and returns one Validator reporting the first non-null error.

Plain Function is the supertype of every function type and carries no signature, so calls through it are dynamic: arguments go unchecked until run time and the result is dynamic. A precise type like bool Function(String) is checked at compile time.

A StreamController pairs an input side (add, addError, addStream, close) with the stream it feeds. The code that creates the controller owns it and must close it; listeners only cancel their own subscriptions.

An async Dart function always returns a Future<T> immediately; returning a value completes it and throwing completes it with an error. Inside, await suspends the function until a future completes, then resumes with its value or rethrows its error.

A default controller allows one listener and buffers events added before it subscribes or while it is paused. A broadcast controller allows many listeners, drops events added while nobody listens, and lets each subscription buffer its own pauses.

Each isolate's event loop empties the microtask queue before taking the next event. scheduleMicrotask, Future.microtask and callbacks on completed futures are microtasks; Future(), Timer.run, Future.delayed, I/O and port messages are events.

Start all three futures before awaiting any: Future.wait([a, b, c]) gives a List in argument order, and Dart 3's (a, b, c).wait gives a typed record. Awaiting one after another serialises the calls and sums their latencies.

Isolates share no mutable state, so they talk by messages: a ReceivePort receives them, and its sendPort getter gives a SendPort that any isolate can call send() on. Mutable objects arrive as copies; immutable ones such as strings are shared.

An async function still runs on the calling isolate's single thread; its synchronous work blocks that isolate's event loop until the next await. Another isolate has its own heap and event loop and can run the work in parallel on another core.

Between isolates sharing code, almost any object can be sent except native-resource holders (sockets, open files), ReceivePort, Finalizer and similar. spawnUri isolates accept only primitives, plain collections and ports. Closures fail when their captured context reaches something unsendable.

Isolate.run starts an isolate, runs one function, returns its result as a Future, rethrows its error, and exits. Isolate.spawn starts a long-lived worker from an entry point and a message, and you manage ports, results, errors and shutdown yourself.

An open ReceivePort or RawReceivePort keeps its isolate alive, so a forgotten port stops a worker, or a CLI program, from exiting. Close each port with close() or by cancelling its subscription; tell a worker to close its own port.

jsonDecode returns dynamic: objects become Map<String, dynamic>, arrays List<dynamic>, numbers int or double. Nothing is checked against your types, so you cast, convert lists with cast() or List.from, or validate with a pattern.

int.parse throws a FormatException when the text is not a valid integer; int.tryParse returns null instead. For user input such as a guest count, use tryParse, handle null, then range-check the value.

jsonEncode writes numbers, strings, booleans, null, lists and string-keyed maps directly; for anything else it calls toEncodable, which by default calls the object's toJson(). For pretty output use JsonEncoder.withIndent(' ').convert(settings).

A DateTime is anchored either in UTC or in the device's local zone, shown by isUtc. Store and send instants in UTC, convert with toLocal() only for display, and compare with isAtSameMomentAs or compareTo, since == also requires the same zone.

dart:io wraps operating-system files, processes and sockets that a browser does not expose, so on the web its APIs, including Platform.isAndroid, are unsupported and fail at runtime. Check kIsWeb first, use defaultTargetPlatform, or split code with conditional imports.

Run dart format -o none --set-exit-if-changed . in CI: it writes nothing and exits with code 1 if any file would change. Without flags, dart format rewrites files in place, wrapping to 80 columns and managing trailing commas.

build_runner build runs every applicable builder once and writes outputs such as .g.dart parts beside your sources; watch keeps running and rebuilds incrementally on each save; clean deletes the build cache so the next build is a full one.

test declares one case; group nests cases under a name prefix. setUp runs before each test, outer groups first; tearDown runs after each test, even a failing one, inner groups first; setUpAll and tearDownAll run once per group.

include: pulls in shared option files such as a lint set; linter: rules switches individual lints on or off; analyzer: errors: changes a diagnostic's severity or ignores it; analyzer: exclude: removes files matching globs from analysis.

JIT compiles Dart code while the VM runs it, which enables incremental recompilation, hot reload and rich debugging during development. AOT compiles to native machine code before shipping, giving consistent, short startup for production executables and apps.

In pub, ^1.2.0 allows >=1.2.0 <2.0.0, up to the next major, while ^0.13.6 allows >=0.13.6 <0.14.0, up to the next minor, because below 1.0 a minor bump may break. Written longhand, the range must be quoted.

Anything imported from lib/ or bin/ must be a regular dependency; packages used only by tests, examples or tooling go in dev_dependencies. Pub installs your own dev dependencies but ignores the dev dependencies of every package you depend on.

A leading underscore makes a name private to its library, meaning the file plus any part files, not to its class. Every declaration in that library can use it, while other libraries, including your own tests, cannot.

dart pub get keeps the versions already recorded in pubspec.lock and resolves only what is new or missing; dart pub upgrade ignores the lockfile and picks the newest versions the pubspec constraints allow, then writes a new lockfile.

Dart classes are implicit interfaces, so a new member breaks users who implements the class, and a new sealed subtype or enum value breaks their exhaustive switches. Marking a class final stops outside subtyping, so its members can grow in minor releases.