Dart Cheat Sheet

A cheatsheet for Dart 3 syntax, type system, async and the most-used standard libraries — covering ~80% of daily work.

Dart Dart 3

Dart SDK · OO · Generic · Functional · Async-first · Static (sound null safety)

Recommended Learning Path

Start with dart create/run and the pubspec layout → grasp variables, types and control flow → dig into functions, strings and collections → understand classes, mixin and error handling → write concurrent code with isolates and async/await → then learn networking, time, processes, regex, and build & test as needed. The FAQ chapter is your go-to for avoiding pitfalls later.

1.Hello World & Runtime

Minimal program, dart create/run, and project structure.

Minimal program

Every Dart program starts from a void main() entry function. dart run executes it, and print outputs to stdout.

void main() {

print('Hello, world!');

}

// How to run:

// dart run hello.dart

// Or compile first, then execute:

// dart compile exe hello.dart -o hello

// main must be named main to be the entry point

// Return type void means no value is returned

Create & run

dart create scaffolds a standard project; dart run executes the entry file directly. Use JIT for fast iteration during development and AOT for efficient release builds.

// Create a console project:

// dart create -t console myapp

// Create a Flutter project:

// flutter create myapp

// Enter the project directory:

// cd myapp

// Run the entry file:

// dart run

// Run a specific file:

// dart run bin/main.dart

// Compile to an executable:

// dart compile exe bin/main.dart

// Static analysis:

// dart analyze

Project structure

pubspec.yaml declares the package name, dependencies and SDK constraint. Code lives in lib/ and bin/, tests in test/.

// pubspec.yaml example:

// name: myapp

// environment:

// sdk: '>=3.0.0 <4.0.0'

// dependencies:

// http: ^1.1.0

// Directory conventions:

// lib/main.dart library code

// bin/main.dart executable entry

// test/ unit tests

// Install dependencies:

// dart pub get

Print output

print writes to stdout and appends a newline. Use $ to interpolate a variable, ${expr} for expressions.

void main() {

print('Hello, Dart!');

final name = 'Rex';

print('Hi, $name'); // variable interpolation

final age = 5;

print('Age is ${age + 1}'); // expression interpolation

print('Pi = ${3.14159.toStringAsFixed(2)}');

}

// stdout.write does not add a newline

// stderr.writeln writes to the error stream

Command-line arguments

main can accept a List<String> args parameter. args[0] is the first positional argument; the program name is not included.

void main(List<String> args) {

print('参数个数: ${args.length}');

for (final arg in args) {

print('参数: $arg');

}

// Run:

// dart run hello.dart a b c

// args == ['a', 'b', 'c']

// The program name itself is not in args

// Use Platform.script when you need the program path

Async main function

main may return Future<void>; the program waits for all awaits to finish before exiting — useful for time-consuming work.

Future<void> main() async {

print('开始');

await Future.delayed(Duration(seconds: 1));

print('一秒后执行');

}

// Future.delayed simulates a long-running task

// await blocks until the Future completes

// Returning Future<void> makes the runtime wait

// Without awaiting, the program may exit early

Comments

Use // for single-line, /// for documentation (used by dart doc), and /* */ for block comments. Comments don't affect execution.

// Single-line comment

/// Doc comment: used by dart doc to generate API docs

/* Block comment: can be closed on one line */

void main() {

// End-of-line comment

print('OK'); // explain what this line does

}

// Doc comments go before the declaration

// Use dart doc to generate HTML documentation

Top-level members

Dart allows top-level functions and variables (outside any class). import libraries to use their public API; top-level variables are visible across the file.

import 'dart:math';

// Top-level variable:

final appName = 'demo';

// Top-level function:

int square(int x) => x * x;

void main() {

print(appName);

print(square(4));

print(max(1, 9));

}

// Top-level members are visible library-wide

// Prefer final for variables to avoid global mutability

// Private members start with an underscore: _helper

// Put imports at the very top of the file

2.Variables & Constants

Variable declarations, final/const, null safety, and destructuring.

var and final

var declares a variable that can be reassigned but its inferred type is fixed. final declares a variable that can only be assigned once.

void main() {

var counter = 0; // inferred as int

counter = 1; // can be reassigned

final name = 'Rex'; // can be assigned only once

// name = 'New'; // error: final cannot change

final now = DateTime.now(); // determined at runtime

print('$counter $name $now');

}

// Once var infers a type, it is fixed

// A different type is an error: counter = 'x'

// final only constrains the number of assignments

// The object's internals can still be modified

const constants

const is a compile-time constant; the value must be known at compile time. const values are canonicalized — identical literals share one instance.

void main() {

const pi = 3.14159;

const greeting = 'Hello';

const list = [1, 2, 3]; // compile-time list

const double factor = 0.5;

print('$pi $greeting $list $factor');

}

// A const value must be known at compile time

// DateTime.now() cannot be used with const

// A const constructor creates a compile-time constant

// Prefer const to improve performance

Explicit types

You can annotate variables with explicit types. Static types help the compiler — annotate public APIs explicitly.

void main() {

int count = 42;

double ratio = 3.14;

String name = 'Dart';

bool enabled = true;

List<int> nums = <int>[1, 2, 3];

print('$count $ratio $name $enabled $nums');

}

// The type goes before the variable name

// Explicit types make the intent clearer

// Local variables can use var and rely on inference

// Prefer writing types for parameters and return values

Nullable variables

Under sound null safety, types are non-nullable by default. Append ? to allow null; null-check or use ?? for a default value.

void main() {

String? maybe = null; // nullable

String name = maybe ?? '匿名'; // null-coalescing default

if (maybe != null) {

print('有值: $maybe');

}

print(name);

}

// String? can be assigned null

// String cannot be assigned null (compile error)

// ?? uses the right side when the left is null

// After a null check Dart applies type promotion

late lazy initialization

late defers initialization until first access. late final allows only one assignment — perfect for fields that depend on runtime values.

class Config {

late final String apiKey = loadKey();

}

String loadKey() => 'abc-123';

void main() {

final config = Config();

print(config.apiKey); // loaded on first access

}

// late lets you skip assigning at declaration

// It must be assigned before first use or it throws

// late final guarantees it is initialized only once

// Common for singletons and lazily loaded config

Destructuring assignment

Dart 3 supports records and pattern destructuring — bind multiple values at once. The pattern must match the shape.

void main() {

final (x, y) = (10, 20);

final (name: n, age: a) = (name: 'Rex', age: 5);

final [first, second, ...] = [1, 2, 3];

print('$x $y $n $a $first $second');

}

// Ignore extra elements with _:

// final [_, second2] = [1, 2];

// Without a rest element the list pattern length must match

// It also works for map keys and values

// for (final MapEntry(k: k, v: v) in entries)

Scope & shadowing

A variable is visible within its block; inner scopes may shadow outer ones. Top-level variables are visible across the library.

final top = '全局';

void main() {

final inner = '函数内';

if (true) {

final block = '块内';

print(block);

print(inner); // outer scope is visible

print(top); // global is visible

}

// print(block); // error: out of scope

}

// Block scope matches the curly braces

// An inner scope can shadow an outer name

// Redeclaring in the same scope is an error

// Avoid deep shadowing to keep code readable

dynamic and Object

dynamic bypasses static checks; the type is resolved at runtime. Object is the root of the type hierarchy and requires explicit casts.

void main() {

dynamic d = 42;

d = '变成字符串'; // any type at runtime

Object obj = 42;

// obj.length; // error: Object has no such member

if (obj is String) {

print(obj.length); // accessible after promotion

}

print(d);

}

// dynamic skips static checking, use it sparingly

// Object is the supertype of all classes

// An is check triggers type promotion

// Prefer explicit types or generics

3.Data Types

Built-in types, collection types, records, and enums.

Numeric types

int is an integer; double is a double-precision float; num is their supertype. An int literal is assignable to double.

void main() {

int i = 42;

double d = 3.14;

num n = 42; // num can hold integers

double whole = 42; // int is assignable to double

print('$i $d $n $whole');

}

// int is 64-bit on native platforms

// double is 64-bit IEEE 754

// The result type depends on the operands

// Check the type with is: if (n is int)

String type

String is an immutable sequence of UTF-16 code units. Single and double quotes are equivalent; interpolation and multiline literals are supported.

void main() {

String a = '单引号';

String b = "双引号"; // equivalent

String multi = '''第一行

第二行''';

print('$a $b');

print(multi);

}

// Strings are immutable

// Modifying operations all return a new string

// One quote style can contain the other directly

// Escape with a backslash when you need the same quote

Boolean type

bool has only true and false. Conditional expressions must return bool — there is no implicit numeric conversion.

void main() {

bool ok = true;

bool done = false;

if (ok) print('成功');

final result = ok && !done;

print(result);

}

// && is logical AND, || is logical OR

// ! is logical NOT

// Ternary: ok ? '是' : '否'

// Dart has no truthy/falsy concept

List type

List is an ordered, growable collection supporting generics. Literal [a, b] creates a list, growable by default.

void main() {

List<int> nums = [1, 2, 3];

nums.add(4);

nums.remove(2);

final first = nums.first;

final len = nums.length;

print('$first $len $nums');

}

// List<String> restricts the element type via generics

// Index access nums[0] throws when out of range

// isEmpty / isNotEmpty check emptiness

// first / last get the first and last elements

Set and Map

Set is an unordered, unique-element collection; Map is a key-value collection. Both are generic and have literal syntax.

void main() {

Set<String> tags = {'a', 'b', 'a'}; // duplicates removed

tags.add('c');

Map<String, int> ages = {'alice': 30};

ages['bob'] = 25;

print(tags); // {a, b, c}

print(ages['bob']); // 25

print(ages['nobody']); // null

}

// Use contains to test Set membership

// Reading a missing Map key returns null

// Map iteration follows insertion order

// Set is ideal for dedup and membership tests

Record type

Dart 3 Records are unnamed, lightweight aggregates. They can have named fields and work with pattern destructuring.

void main() {

var point = (x: 1, y: 2); // named record

var pair = ('left', 3); // positional record

print(point.x);

print(pair.$1); // positional access

final (a, b) = ('first', 2);

print('$a $b');

}

// Records get == and hashCode automatically

// A record's type is its shape: (int, int)

// Good for returning multiple values instead of tiny classes

// Records are immutable

Enums

enum defines a fixed set of named constants. Enhanced enums (Dart 2.17+) can carry fields and methods.

enum Status { pending, approved, rejected }

enum Color {

red(255), green(0), blue(0);

const Color(this.value);

final int value;

}

void main() {

final s = Status.approved;

print(s.name); // approved

print(Color.red.value);

for (final c in Status.values) {

print(c.name);

}

// .name gives the enum member name

// .values iterates all members

// switch over an enum is exhaustive by default

// Enhanced enums can carry data and behaviour

Type conversion

int.parse / double.parse convert a string to a number, toString converts back, and as performs a runtime cast.

void main() {

int n = int.parse('42');

double d = double.parse('3.14');

String s = 42.toString();

Object obj = 'hello';

if (obj is String) {

final len = obj.length; // safe after promotion

print(len);

}

print('$n $d $s');

}

// parse throws FormatException on failure

// toStringAsFixed(2) keeps two decimal places

// A failed as cast throws TypeError

// Prefer is + type promotion over as

4.References & Null Safety

Object references, null safety, deep copies, and native memory.

Object references

Dart has no raw pointers — variables hold references to objects. Assignment copies the reference; multiple variables can point to the same object.

void main() {

final list1 = [1, 2, 3];

final list2 = list1; // copies the reference

list2.add(4);

print(list1); // [1, 2, 3, 4]

final copy = List.of(list1); // a real copy

copy.add(5);

print(list1); // unaffected

}

// Assigning a reference type shares the object

// List.of / [...list] make a shallow copy

// Primitive types are immutable value types

// Watch for side effects when sharing mutable objects

Null safety

Sound null safety restricts null to nullable types like String?. The compiler enforces non-null at compile time.

void main() {

String name = 'Rex'; // non-nullable

String? nickname; // nullable, defaults to null

nickname = '小雷';

if (nickname != null) {

print('$name 的昵称 $nickname');

}

print(nickname);

}

// Assigning null to a non-nullable type is a compile error

// After a null check the variable is promoted to non-null

// ?? supplies a default so you can skip the null check

// ?. is safe access: nickname?.length

Null-assertion !

Appending ! asserts that a nullable expression is non-null; it throws a null check error if violated. Use it only when you're sure.

void main() {

String? maybe = '有值';

final len = maybe!.length; // assert non-null

print(len);

String? empty;

final safe = empty?.length; // null

print(safe);

}

// ! bypasses the null-safety check

// A failed assertion throws a Null check error

// Prefer null checks and type promotion

// ?. returns null instead of throwing

Null-coalescing

?? yields the right-hand side when the left is null. ??= assigns only if the variable is currently null.

void main() {

String? user;

final name = user ?? '匿名'; // null-coalescing

user ??= '游客'; // assign only when null

int? count;

count ??= 0;

count++;

print('$name $user $count');

}

// ?? only cares whether the left side is null

// ??= is equivalent to count = count ?? 0

// Can be chained: a ?? b ?? c ?? '默认'

// ?? also gives collection defaults: list ?? []

late and const

final assigns once at runtime; const is a compile-time constant. late defers initialization — useful for expensive objects and circular dependencies.

void main() {

final now = DateTime.now(); // runtime

const pi = 3.14159; // compile time

late final big = createBig(); // on first access

print('$now $pi ${big.length}');

}

List<int> createBig() => List<int>.generate(100, (i) => i);

// final can be assigned in a constructor or at runtime

// A const value must be determinable at compile time

// late defers execution until first access

// Top-level and static variables are lazily initialized

References and equality

== defaults to reference comparison; identical() checks for the same instance. Use a helper for structural equality.

void main() {

final a = [1, 2];

final b = [1, 2];

print(a == b); // false: different objects

print(identical(a, b)); // false: different references

final c = a;

print(identical(a, c)); // true: same reference

print(a.length == b.length); // true

}

// Strings and numbers have value semantics, == compares content

// List/Map compare by reference by default

// Use listEquals (package:collection) for structural comparison

// Custom classes can override == and hashCode

Deep vs shallow copy

A shallow copy duplicates only the top level — nested objects are still shared. Deep copy repeats per layer; immutable collections are safe to share.

void main() {

final nested = [[1], [2]];

final shallow = List.of(nested); // shallow copy

shallow[0].add(9);

print(nested[0]); // [1, 9]

final deep = nested.map((e) => List.of(e)).toList();

deep[0].add(8);

print(nested[0]); // [1, 9] unchanged

}

// A shallow copy shares the nested objects

// A deep copy creates new objects at every level

// Map.of / Set.of work the same way

// Immutable collections avoid shared side effects

Native memory

dart:ffi exposes Pointer and calloc for native memory access — used for C interop. Pointer lifetimes are the developer's responsibility.

// dart:ffi provides native memory access:

// Pointer<Int32> represents a C int pointer

// Allocate and free:

// final p = calloc<Int32>(1); // package:ffi

// p.value = 42;

// calloc.free(p);

// Interoperate with C libraries:

// final lib = DynamicLibrary.open('libc.so')

// final fn = lib.lookupFunction(...)

// Strings use Pointer<Utf8>

// Native platforms only, not available on the Web

// Pointer lifetimes are the developer's responsibility

5.Control Flow

if, loops, switch, and pattern matching.

if / else

if/else if/else branches on a condition, which must be bool. Null-checks trigger type promotion.

void main() {

int score = 85;

if (score >= 90) {

print('优秀');

} else if (score >= 60) {

print('及格');

} else {

print('不及格');

}

// The condition must evaluate to bool

// Braces are optional but recommended

// Type promotion happens after a null check:

// if (name != null) print(name.length)

// Without else, an unmet condition is simply skipped

Ternary expression

cond ? then : else is a single-expression branch. Combine with ?? for null defaults.

void main() {

final n = 7;

final sign = n > 0 ? '正' : '非正';

String? maybe;

final label = maybe ?? '默认'; // null-coalescing

print(sign);

print(label);

}

// Both ternary branches should have the same type

// Nested ternaries hurt readability, use them sparingly

// ?? is dedicated to null defaults

// if/else is clearer for complex branching

for loop

Classic three-part for; for-in iterates an Iterable. Dart 3 supports pattern destructuring in the loop variable.

void main() {

for (var i = 0; i < 3; i++) {

print('i=$i');

}

final names = ['Rex', 'Ada'];

for (final name in names) {

print(name);

}

for (final (i, name) in names.indexed) {

print('$i: $name');

}

// i++ is equivalent to i = i + 1

// for-in iterates any Iterable and Map

// .indexed yields (index, value) records

// Be careful when modifying the collection being iterated

while loop

while checks then runs; do-while runs once then checks. Use them for loops of unknown iteration count.

void main() {

var n = 3;

while (n > 0) {

print('n=$n');

n--;

}

var count = 0;

do {

print('至少执行一次');

count++;

} while (count < 1);

}

// while never runs if the condition is false

// do-while runs at least once

// The condition must be a bool

// Remember to update the loop variable to avoid infinite loops

switch expression

Dart 3 switch expression returns a value. Each case has a pattern; use => to produce the result — no break needed.

void main() {

final status = 404;

final label = switch (status) {

200 => '成功',

404 => '未找到',

_ => '其他',

};

print(label);

}

// It must be exhaustive or end with _ as a fallback

// The expression form uses => instead of :

// Patterns are supported: switch (value) { int n => ... }

// More concise than an if chain and the result is assignable

switch statement

switch statements branch on cases — empty cases fall through, guards and patterns are supported. Each non-empty case must break.

void main() {

final day = 3;

switch (day) {

case 1:

case 2:

case 3:

print('工作日');

break;

default:

print('周末');

}

switch (day) {

case int n when n > 3:

print('大于 3');

break;

default:

print('其他');

}

// Empty cases fall through automatically

// Non-empty branches need break or return

// when adds an extra guard condition

// Pattern matching is more powerful than an if chain

Pattern matching

if-case and switch perform structural matching. Combine object patterns, record patterns and guards.

class Circle {

const Circle(this.radius);

final double radius;

}

void main() {

final shape = Circle(5);

if (shape case Circle(radius: final r)) {

print('半径 $r');

}

final value = (name: 'Rex', age: 5);

final msg = switch (value) {

(name: final n, age: 0) => '$n 刚出生',

(name: final n, age: final a) => '$n $a 岁',

_ => '未知',

};

print(msg);

}

// if-case enters the branch only when the match succeeds

// Object patterns destructure by field name

// Record patterns match by position or by name

// An exhaustive switch lets the compiler guarantee coverage

break and continue

break exits the loop; continue skips to the next iteration. Labels control jumps in nested loops.

void main() {

for (var i = 0; i < 5; i++) {

if (i == 1) continue; // skip i=1

if (i == 4) break; // exit the loop

print('i=$i'); // 0 2 3

}

outer:

for (var i = 0; i < 3; i++) {

for (var j = 0; j < 3; j++) {

if (j == 1) break outer; // exit the outer loop

print('$i,$j');

}

// continue skips only the rest of this iteration

// break ends the loop entirely

// A label goes before the loop and is referenced by name

// Labels are handy for breaking out of deep nesting

6.Functions & Lambdas

Function definitions, optional parameters, closures, and async functions.

Function definition

A function has a return type, name, parameters and body. Use void when there is no return value.

int add(int a, int b) {

return a + b;

}

void greet(String name) {

print('你好，$name');

}

void main() {

print(add(1, 2));

greet('Rex');

}

// The return type comes before the function name

// Parameters must have types

// Use void when there is no return value

// Functions are objects and can be assigned to variables

Arrow function

Single-expression bodies use => — the expression's value is returned. Great for pure functions and callbacks.

int square(int x) => x * x;

bool isEven(int n) => n % 2 == 0;

void main() {

print(square(4));

print(isEven(3));

final doubled = [1, 2, 3].map((n) => n * 2).toList();

print(doubled);

}

// The => body must be a single expression

// It is equivalent to { return expr; }

// Common in callbacks and higher-order functions

// void return: () => print('x')

Optional positional parameters

Square brackets [] mark optional positional parameters. Defaults (or null) are used when omitted — defaults must be compile-time constants.

String join(String a, [String b = '无', int times = 1]) {

return '$a $b 重复 $times 次';

}

void main() {

print(join('你好'));

print(join('你好', '世界'));

print(join('你好', '世界', 3));

}

// Parameters inside [] are optional and positional

// Write the default value after the parameter with =

// Without a default the type must be nullable

// Use ?? to supply a default for nullable optional parameters

Named parameters

Curly braces {} mark named parameters; pass them by name. Mark with required to force the caller to provide them.

String describe(String name,

{int age = 0, String? city, required bool married}) {

return '$name 年龄 $age 城市 $city 已婚 $married';

}

void main() {

final s = describe('Rex',

age: 5, city: '上海', married: false);

print(s);

}

// Named arguments are order-independent

// Omitted ones use the default value or are null

// required parameters must be passed explicitly

// Wrap long calls across lines for readability

Higher-order functions

Functions are first-class — pass them as arguments or return them. map / where / fold are the standard collection higher-order helpers.

void main() {

final nums = [1, 2, 3, 4];

final doubled = nums.map((n) => n * 2).toList();

final evens = nums.where((n) => n.isEven).toList();

final sum = nums.fold(0, (acc, n) => acc + n);

print('$doubled $evens $sum');

}

// map transforms element by element

// where filters by a condition

// fold accumulates into a single result

// The result is a lazy Iterable, use toList to materialize it

Closures

A closure captures the variables of its defining scope and can read and mutate them even after the outer function returns.

Function makeCounter() {

var count = 0;

return () => ++count;

}

void main() {

final counter = makeCounter();

print(counter()); // 1

print(counter()); // 2

final counter2 = makeCounter();

print(counter2()); // 1: independent state

}

// A closure captures its environment and state

// Each makeCounter call creates an independent closure

// Whether variables are shared or separate depends on where they live

// Often used to encapsulate state

Async functions

An async function returns a Future; inside, await pauses until the result is ready. await only works inside async functions.

Future<String> fetchData() async {

await Future.delayed(Duration(milliseconds: 100));

return '数据';

}

Future<void> main() async {

print('开始');

final data = await fetchData();

print(data);

}

// An async function implicitly returns Future<T>

// await suspends until the Future completes

// Errors propagate to the await site and can be caught with try/catch

// Forgetting await gives you the Future object itself

Generators

sync* yields a lazy Iterable; async* yields a Stream. yield emits one value; yield* delegates to another generator.

Iterable<int> countUp(int max) sync* {

for (var i = 0; i < max; i++) {

yield i;

}

Stream<int> streamCount(int max) async* {

for (var i = 0; i < max; i++) {

await Future.delayed(Duration(milliseconds: 10));

yield i;

}

void main() {

print(countUp(3).toList());

}

// sync* yields one at a time without holding memory

// async* pairs with await to produce a stream

// yield* expands a sub-sequence: yield* countUp(2)

// Generators run on demand, only on first access

7.Strings

Literals, interpolation, substrings, encoding, and formatting.

String literals

Single and double quotes both delimit strings. Escape with backslashes, or use a raw string with the r prefix.

void main() {

String s1 = '单引号';

String s2 = "双引号";

String esc = '换行符\n制表符\t';

String raw = r'不转义\n直接显示';

print('$s1 $s2');

print(esc);

print(raw);

}

// \n newline \t tab \\ backslash

// r'...' is a raw string that ignores escapes

// Ideal for regular expressions and Windows paths

// Use the other quote style inside to avoid escaping

String interpolation

Use $var (or ${expr}) to embed a value in a string. Any object's toString is called automatically.

void main() {

final name = 'Rex';

final age = 5;

print('$name 今年 $age 岁');

print('十年后 ${age + 10} 岁');

final list = [1, 2];

print('共 ${list.length} 个元素');

}

// $name inserts a variable directly

// ${...} inserts expressions and calls

// Objects are converted with toString automatically

// Clearer and more efficient than string concatenation

Multiline strings

Triple single quotes ''' start a multiline string — newlines and indentation are preserved.

void main() {

String poem = '''

床前明月光，

疑是地上霜。''';

print(poem);

String html = '''

<div>

</div>''';

print(html);

}

// Multi-line strings keep the actual line breaks

// Leading and trailing newlines are included

// They can be combined with interpolation

// Ideal for SQL, HTML and template text

Common methods

contains / startsWith test for substrings; replaceAll swaps text; toUpperCase / toLowerCase change case.

void main() {

final text = 'Hello Dart';

print(text.contains('Dart')); // true

print(text.startsWith('Hello')); // true

print(text.toLowerCase()); // hello dart

print(text.replaceAll('Dart', 'Flutter'));

print(text.replaceFirst('l', 'L')); // HeLlo Dart

print(text.length);

}

// String methods return a new string, the original is unchanged

// trim() removes leading and trailing whitespace

// isEmpty / isNotEmpty check emptiness

// Methods can be chained

Substrings & search

substring extracts a slice; indexOf locates a substring; split breaks on a delimiter into a list.

void main() {

final text = 'hello world';

print(text.substring(0, 5)); // hello

print(text.substring(6)); // world

print(text.indexOf('world')); // 6

print(text.indexOf('x')); // -1 not found

print(text.split(' ')); // [hello, world]

}

// substring takes start (inclusive) and end (exclusive)

// indexOf returns -1 when not found

// lastIndexOf searches from the end

// split results do not contain the separator itself

Characters & encoding

Dart strings are UTF-16. codeUnits gives code units; runes gives code points — use runes to handle emojis.

void main() {

final s = 'A中😀';

print(s.length); // 4 UTF-16 units

print(s.codeUnits); // list of code units

print(s.runes.toList()); // list of code points

print(String.fromCharCodes(s.runes));

}

// Chinese characters and emoji take several UTF-16 units

// length returns code units, not characters

// runes returns Unicode code points

// Use runes.length when you need the real character count

Efficient concatenation

Repeated + concatenation allocates many temporaries. StringBuffer accumulates and produces the string in one go.

void main() {

final buffer = StringBuffer();

for (var i = 0; i < 1000; i++) {

buffer.write('第 $i 行\n');

}

final result = buffer.toString();

print('${result.length} 个字符');

}

// write appends without a newline

// writeln appends and adds a newline

// toString produces the string in one go

// Far more efficient than concatenating with +

Formatting & parsing

toStringAsFixed sets decimal places; padLeft / padRight pad to a width; int.parse / double.parse parse numeric strings.

void main() {

final pi = 3.14159;

print(pi.toStringAsFixed(2)); // 3.14

print(7.toString().padLeft(3, '0')); // 007

final n = int.parse('42');

final d = double.parse('3.14');

print('$n $d');

}

// toStringAsFixed rounds the value

// padLeft/padRight pad with characters

// parse throws FormatException on failure

// Specify a radix: int.parse('ff', radix: 16)

8.Collections

Lists, maps, set operations, and sorting.

List operations

add appends, insert places at index, remove deletes by value, sort orders ascending. Default List is growable and mutable.

void main() {

final nums = [3, 1, 2];

nums.add(4); // [3, 1, 2, 4]

nums.insert(0, 0); // [0, 3, 1, 2, 4]

nums.remove(3); // remove the element 3

nums.sort(); // ascending

print(nums);

print(nums.reversed.toList());

}

// remove deletes the first equal element

// removeAt deletes by index

// contains checks for membership

// indexOf finds the first matching index

List higher-order

map transforms, where filters, reduce / fold aggregate, expand flattens. Most return a lazy Iterable.

void main() {

final nums = [1, 2, 3, 4];

final doubled = nums.map((n) => n * 2).toList();

final evens = nums.where((n) => n.isEven).toList();

final sum = nums.reduce((a, b) => a + b);

final flat = [[1, 2], [3]].expand((e) => e).toList();

print('$doubled $evens $sum $flat');

}

// map/where return a lazy Iterable

// A lazy sequence is only computed while iterating

// reduce requires a non-empty list

// fold is safer because it takes an initial value

Spread operator

... spreads a collection's elements into a literal. ...? safely skips a null source.

void main() {

final a = [1, 2];

final b = [3, 4];

final merged = [...a, ...b, 5]; // [1,2,3,4,5]

List<int>? maybe;

final safe = [...a, ...?maybe]; // null safe

final copy = [...a]; // shallow copy

print('$merged $safe $copy');

}

// The spread operator merges elements, not sub-lists

// ...? handles a null source automatically

// It also works in Map and Set literals

// Common for merging and copying collections

Collection if/for

Use if inside collection literals to include elements conditionally, for to generate many. Dart 3 also supports pattern destructuring here.

void main() {

final includeZero = true;

final nums = [

if (includeZero) 0,

for (var i = 2; i < 4; i++) i,

];

print(nums); // [1, 0, 2, 3]

final pairs = {

for (var i = 0; i < 3; i++) 'k$i': i,

};

print(pairs);

}

// if omits the element when the condition fails

// for produces multiple elements from its body

// The same works for Set and Map

// It makes data descriptions more declarative

Map operations

Iterate Map keys / values / entries. putIfAbsent fills lazily, update mutates, remove deletes.

void main() {

final ages = {'alice': 30, 'bob': 25};

ages['carol'] = 22; // insert

ages.update('bob', (v) => v + 1); // update

ages.putIfAbsent('dave', () => 40);

ages.remove('alice');

for (final entry in ages.entries) {

print('${entry.key}: ${entry.value}');

}

// Reading a missing key returns null

// putIfAbsent only computes when the key is missing

// entries gives you the key-value pairs

// containsKey tests whether a key exists

Set operations

Set enforces uniqueness. union / intersection / difference are set operations; toSet deduplicates a list.

void main() {

final a = {1, 2, 3};

final b = {3, 4, 5};

print(a.union(b)); // {1,2,3,4,5}

print(a.intersection(b)); // {3}

print(a.difference(b)); // {1,2}

final nums = [1, 1, 2, 3];

final unique = nums.toSet();

print(unique);

}

// A Set is unordered with unique elements

// contains checks membership efficiently

// Use a Set for dedup and membership checks

// Adding an existing element is a no-op

Sort & search

sort defaults to ascending; pass a comparator for custom order. indexOf does a linear search; contains checks membership.

void main() {

final names = ['bob', 'alice', 'carol'];

names.sort(); // alphabetical

print(names);

final people = [

('bob', 30),

('alice', 20),

];

people.sort((x, y) => x.$2.compareTo(y.$2));

print(people);

print(names.indexOf('bob'));

}

// The default order follows Comparable

// A comparator returns negative/zero/positive

// sort modifies the list in place

// Copy first if you need to keep the original order

Read-only collections

List.unmodifiable creates a read-only view — mutating throws UnsupportedError. List.of copies into a mutable list.

void main() {

final frozen = List.unmodifiable([1, 2, 3]);

// frozen.add(4); // throws UnsupportedError

final editable = List.of([1, 2, 3]); // mutable copy

editable.add(4);

print(editable);

final constList = const [1, 2, 3]; // compile-time constant

print(frozen.length);

}

// unmodifiable is read-only at runtime

// const is a compile-time constant and canonicalized

// Read-only is safer when passing to an API

// Map.unmodifiable / Set.unmodifiable work the same way

9.Memory & Performance

Garbage collection, const canonicalization, and buffer reuse.

Garbage collection

The Dart VM garbage-collects automatically — no manual free. Objects with no references become eligible for collection.

void main() {

// An object becomes collectable once it loses all references:

var data = List<int>.generate(10000, (i) => i);

data = [1, 2, 3]; // the old list is no longer referenced

print(data);

}

// Unreferenced objects are cleaned up by the GC automatically

// You neither need nor can delete manually

// Short-lived objects are usually nothing to worry about

// Flutter uses a generational GC

const canonicalization

const values are canonicalized — identical literals share one instance. Prefer const on hot paths.

void main() {

const a = [1, 2, 3];

const b = [1, 2, 3];

print(identical(a, b)); // true: same instance

final c = [1, 2, 3];

final d = [1, 2, 3];

print(identical(c, d)); // false

}

// Equal const values are canonicalized and shared

// Non-const literals create a new object each time

// Prefer const literals on hot paths

// Compile-time constants are never rebuilt

Lazy initialization

Top-level and static variables are lazily initialized on first access. late offers the same deferred semantics.

void main() {

print('开始');

print(cache); // first access triggers the computation

print(cache); // reuses the existing value

}

final cache = buildCache();

String buildCache() {

print('构建缓存中');

return 'heavy-data';

}

// A top-level variable initializes on first access

// Afterwards the same instance is reused

// late fields behave the same way

// Avoids unnecessary startup cost

List capacity

Growable lists resize as needed — repeated add reallocates. Pre-size when the count is known.

void main() {

final nums = <int>[];

for (var i = 0; i < 100; i++) {

nums.add(i); // grows automatically

}

final sized = List<int>.filled(100, 0);

final growable = List<int>.generate(100, (i) => i);

print('${nums.length} ${sized.length} ${growable.length}');

}

// The default list is growable and resizing has a cost

// filled initializes a fixed length

// generate builds elements with a function

// Bulk construction is faster than frequent appends

Buffer reuse

Uint8List and other typed-data buffers suit binary work. Reuse buffers and use StringBuffer to avoid repeated allocation.

import 'dart:typed_data';

void main() {

final bytes = Uint8List(4); // fixed size

bytes[0] = 255;

final buffer = StringBuffer();

for (var i = 0; i < 10; i++) {

buffer.write(i);

}

print('$bytes ${buffer.toString()}');

}

// Uint8List gives efficient byte-level access

// Use Uint8List instead of List<int> for large binaries

// Reusing one buffer reduces GC pressure

// Stream large data instead of loading it all at once

Weak references

Expando attaches data to an object without modifying it, using a weak key. WeakReference lets the object be collected.

void main() {

final tags = Expando<String>();

final obj = Object();

tags[obj] = '元数据'; // attach data

print(tags[obj]); // 元数据

final weak = WeakReference(obj);

print(weak.target == obj); // true

}

// Expando keys are weak references

// The attached data disappears once the object is collected

// Good for caches, debugging and framework extensions

// It does not take up a field on the object itself

Object lifecycle

Objects live in their isolate's heap. Isolates don't share mutable state — only copies or messages.

void main() {

// Each isolate has its own heap

final local = [1, 2, 3];

// What you send to another isolate is a copy:

// final result = await Isolate.run(() => local);

print(local);

}

// Isolates do not share memory

// Shared state requires message passing or ports

// Globally mutable objects are dangerous, use them sparingly

// Ideal for self-contained data-processing tasks

Native memory

Use dart:ffi for native memory during C interop. You must manually free — otherwise you leak.

import 'dart:ffi';

// Declare a pointer type:

// typedef NativeBuf = Pointer<Uint8>;

// Allocate native memory:

// final p = calloc<Uint8>(1024); // package:ffi

// Use p[i] to read and write bytes

// Free it:

// calloc.free(p);

// Forgetting to free causes a leak

// ffi is available on native platforms only

10.Object-Oriented

Classes, inheritance, mixins, and interfaces.

Classes & constructors

class declares an object blueprint. Constructors share the class name; this. params assign directly to fields.

class Animal {

String name;

int age;

Animal(this.name, this.age); // this-parameter assignment

void speak() {

print('$name 叫了一声');

}

void main() {

final dog = Animal('旺财', 3);

dog.speak();

print('${dog.name} ${dog.age} 岁');

}

// this.name assigns the constructor argument to the field

// Fields are non-nullable by default and must be initialized

// Methods can access instance fields

// Instantiation does not need the new keyword

Inheritance

extends inherits from a superclass; @override marks overrides; super calls parent members. Dart is single-inheritance.

class Animal {

Animal(this.name);

final String name;

String sound() => '...';

}

class Dog extends Animal {

Dog(String name) : super(name);

@override

String sound() => '汪汪';

}

void main() {

final dog = Dog('旺财');

print(dog.sound());

}

// A subclass inherits the parent's fields and methods

// @override marks an overriding member

// super(name) forwards arguments to the parent constructor

// A class can have only one superclass

mixin

A mixin is a reusable behavior fragment; use with to apply it. More flexible than inheritance and avoids the single-parent limit.

mixin Swimmer {

void swim() => print('游泳');

}

mixin Flyer {

void fly() => print('飞行');

}

class Duck with Swimmer, Flyer {}

void main() {

final duck = Duck();

duck.swim();

duck.fly();

}

// The with keyword applies multiple mixins

// A mixin cannot be instantiated on its own

// Restrict the superclass: mixin X on BaseClass {}

// Composing behaviour beats deep inheritance

Abstract class

An abstract class can't be instantiated — it defines a contract that subclasses must fulfill.

abstract class Shape {

double area();

}

class Circle extends Shape {

Circle(this.r);

final double r;

@override

double area() => 3.14159 * r * r;

}

void main() {

final c = Circle(2);

print(c.area().toStringAsFixed(2));

}

// An abstract method has no body

// An abstract class may contain concrete implementations

// implements can be used to implement the interface too

// Once unified you can use them through the parent type

Interfaces

Every class implicitly defines an interface — use implements to fulfill it. All members must be reimplemented.

class Greeter {

String greet(String name) => '你好，$name';

}

class EnglishGreeter implements Greeter {

@override

String greet(String name) => 'Hello, $name';

}

void main() {

final g = EnglishGreeter();

print(g.greet('Rex'));

}

// implements does not inherit the implementation

// Every member of the interface must be overridden

// A class can implement multiple interfaces

// Use implements to express a type contract

Accessors

get defines a read-only accessor; set defines a writable one. Accessors read and write like fields without parentheses.

class Rectangle {

Rectangle(this.width, this.height);

double width;

double height;

double get area => width * height;

set scale(double factor) {

width *= factor;

height *= factor;

}

void main() {

final r = Rectangle(2, 3);

print(r.area); // 6.0

r.scale = 2;

print(r.area); // 24.0

}

// get reads like a field

// set assigns like a field

// You can add validation logic inside get/set

// Use get for derived computed properties

Static members

static members belong to the class, not an instance. static methods can't access instance members.

class MathUtils {

static const pi = 3.14159;

static int square(int x) => x * x;

static int _counter = 0; // private static

static int get count => _counter;

}

void main() {

print(MathUtils.pi);

print(MathUtils.square(5));

}

// Access static members directly through the class name

// static cannot access instance fields

// Private members start with an underscore, visible within the library

// static constants are common for shared configuration

sealed class

sealed classes restrict subclasses to the same library, so exhaustive switches need no default. A Dart 3 feature.

sealed class Shape {}

class Circle extends Shape {}

class Square extends Shape {}

String describe(Shape shape) => switch (shape) {

Circle() => '圆',

Square() => '方',

};

void main() {

print(describe(Circle()));

print(describe(Square()));

}

// sealed subclasses must be declared in the same library

// An exhaustive switch needs no default

// Adding a new subclass triggers a compile warning

// Very safe when combined with pattern matching

11.Error Handling

try/catch, custom exceptions, and async errors.

try / catch

try wraps code that may throw; catch handles exceptions. catch (e) gets the exception object.

void main() {

try {

final n = int.parse('abc');

print(n);

} catch (e) {

print('解析失败: $e');

}

// catch (e) catches all exceptions

// after throw, remaining code in try is skipped

// uncaught exceptions crash the program

// catch (e, st) also gets stack trace st

on clause

on filters the caught exception type — pair with catch to read it. Stack handlers from top to bottom.

void main() {

try {

throw FormatException('格式错误');

} on FormatException catch (e) {

print('格式: ${e.message}');

} on ArgumentError {

print('参数错误');

} catch (e) {

print('其他: $e');

}

// `on Type` clause catches matching exceptions

// `on` clause without `catch` does not bind the exception object

// matching is in order; earlier clauses win

// fallback `catch` clause catches remaining exceptions

finally and rethrow

finally always runs, for cleanup. rethrow propagates the original error, preserving its stack.

void main() {

try {

outer();

} catch (e) {

print('最终处理: $e');

}

void outer() {

try {

throw Exception('原始错误');

} catch (e) {

print('中间捕获');

rethrow; // preserve stack and re-raise

} finally {

print('清理资源');

}

// finally always runs

// rethrow must be inside catch

// rethrow preserves the original stack

// commonly used to close resources and connections

Throw exceptions

throw raises an exception object. Anything can be thrown, but idiomatic code throws an Exception or Error subclass.

void main() {

try {

checkAge(-1);

} catch (e) {

print('拒绝: $e');

}

void checkAge(int age) {

if (age < 0) {

throw ArgumentError('年龄不能为负');

}

// throw interrupts current control flow

// an exception can be any object

// by convention use Exception or Error

// recommend throwing for invalid business conditions

Custom exceptions

Implement Exception for business errors. Override toString for friendly messages and carry structured fields.

class ValidationError implements Exception {

ValidationError(this.field, this.message);

final String field;

final String message;

@override

String toString() => '字段 $field 无效: $message';

}

void main() {

try {

throw ValidationError('email', '格式错误');

} on ValidationError catch (e) {

print(e.field); // email

print(e);

}

// implements Exception marks the class as an exception

// can carry structured fields

// `on` clause matches custom types precisely

// lets callers dispatch by type

Async errors

Exceptions thrown after await are catchable with try/catch. Unawaited Future errors are silently lost.

Future<void> load() async {

throw Exception('加载失败');

}

Future<void> main() async {

try {

await load();

} catch (e) {

print('异步捕获: $e');

}

// errors from unawaited futures are hard to catch

// use catchError for chained handling:

// load().catchError(print);

// unhandled errors may enter the zone

// recommend a unified error-handling strategy

Stream errors

Pass an onError callback when listening to a Stream. StreamController.addError injects an error into the stream.

import 'dart:async';

void main() {

final controller = StreamController<int>();

controller.stream.listen(

(data) => print('数据: $data'),

onError: (e) => print('流错误: $e'),

onDone: () => print('流结束'),

);

controller.add(1);

controller.addError('意外错误');

controller.close();

}

// addError injects an error into the stream

// onError callback handles stream errors

// onDone fires after the stream closes

// stream errors do not interrupt other data

Assertions

assert checks a condition in development; it throws AssertionError on failure. Stripped from release builds.

void main() {

final score = 85;

assert(score >= 0, '分数不能为负'); // passes

print('断言通过');

}

// false condition throws AssertionError

// second argument is the failure message

// release-mode `dart compile` strips asserts

// suited for invariants, not for user input

12.Files & I/O

File I/O, JSON, and standard input and output.

Read files

The File class from dart:io reads/writes files. readAsString loads an entire text file — import 'dart:io'.

import 'dart:io';

Future<void> main() async {

final text = await File('data.txt').readAsString();

print(text);

final exists = await File('data.txt').exists();

print(exists);

}

// readAsString reads the whole file into memory

// for large files use streaming reads

// missing path throws FileSystemException

// exists returns a bool indicating presence

Write files

writeAsString writes text; writeAsBytes writes binary. Pass mode: FileMode.append to append.

import 'dart:io';

Future<void> main() async {

await File('out.txt').writeAsString('Hello\n');

await File('out.txt').writeAsString('World\n',

mode: FileMode.append); // append

final content = await File('out.txt').readAsString();

print(content);

}

// default mode overwrites the existing file

// FileMode.append appends to the end

// FileMode.writeOnly opens write-only and overwrites

// writing Chinese text defaults to UTF-8 encoding

Read line by line

readAsLines splits a file into a list of lines. For large files, use openRead with LineSplitter to stream.

import 'dart:io';

import 'dart:convert';

Future<void> main() async {

final lines = await File('log.txt').readAsLines();

for (final line in lines) {

print(line);

}

final stream = File('big.log').openRead()

.transform(utf8.decoder)

.transform(const LineSplitter());

await for (final line in stream) {

print(line);

}

// readAsLines is good for small files

// for large files use openRead streaming

// LineSplitter splits by lines

// streaming avoids exhausting memory

JSON processing

dart:convert provides jsonEncode / jsonDecode for serialization. JSON numbers become int or double.

import 'dart:convert';

void main() {

final data = {'name': 'Rex', 'age': 5};

final encoded = jsonEncode(data);

print(encoded);

final decoded = jsonDecode(encoded) as Map<String, dynamic>;

print(decoded['name']);

}

// jsonDecode returns dynamic, cast as needed

// numbers parse as int or double

// unknown fields remain in the Map

// complex objects need manual mapping

Standard input/output

stdin.readLineSync reads a line synchronously; stdout.writeln writes a line. Ideal for CLI programs.

import 'dart:io';

void main() {

stdout.write('请输入姓名: ');

final name = stdin.readLineSync() ?? '';

stdout.writeln('你好，$name');

}

// readLineSync reads a line, returns String?

// at EOF returns null, supply a default

// stdout.write does not append a newline

// stderr.writeln writes to the error stream

Directory operations

Directory.list enumerates entries; create makes a directory; delete removes one. Returned entities are FileSystemEntity.

import 'dart:io';

Future<void> main() async {

await Directory('data/sub').create(recursive: true);

await for (final entity in Directory('.').list()) {

print('${entity.path} ${entity is Directory ? '目录' : '文件'}');

}

await Directory('data').delete(recursive: true);

}

// create recursive: creates nested directories

// list iterates directory contents lazily

// delete recursive: removes recursively

// entity handles files and directories uniformly

Binary bytes

readAsBytes reads binary; Uint8List models bytes; writeAsBytes writes them. Suitable for images, audio, etc.

import 'dart:io';

import 'dart:typed_data';

Future<void> main() async {

final bytes = await File('image.png').readAsBytes();

print('大小: ${bytes.length} 字节');

final copy = Uint8List.fromList(bytes);

await File('copy.png').writeAsBytes(copy);

print('已复制');

}

// readAsBytes returns Uint8List

// bytes are suited for non-text data

// fromList copies a byte sequence

// for large files use openWrite for streaming writes

Path operations

File / Directory expose the full .path. .absolute resolves the absolute path; .uri gives a file:// URI.

import 'dart:io';

void main() {

final file = File('a/b/data.txt');

print(file.path); // full path

print(file.absolute.path); // absolute path

print(file.uri); // file:// URI

print(Platform.pathSeparator);

}

// `path` returns the full path string

// `absolute` resolves to an absolute path

// `uri` converts to a file:// URI

// Windows and Unix use different separators

13.Common Pitfalls

The pitfalls you are most likely to hit in everyday Dart development, and how to write it correctly.

Misusing null-assertion

Bypassing null checks with ! often crashes at runtime. Prefer null-checks, ??, and type promotion.

// BAD: using `!` masks nullable design

String? name = 'Rex';

final len = name!.length; // depends on a runtime assert

print(len);

// GOOD: leverage type promotion

String? nick = '小雷';

if (nick != null) {

print(nick.length);

}

// GOOD: `??` provides a default value

print(name?.toUpperCase() ?? '未知');

Collection == comparison

List / Map == compares by reference, not contents. Use a helper for structural equality.

// BAD: `==` compares references

final a = [1, 2];

final b = [1, 2];

print(a == b); // false

// GOOD: compare contents, not references

print(a.join(',') == b.join(',')); // true

// GOOD: structural comparison recommended

// listEquals(a, b) from package:collection

// strings and numbers compare contents with `==` directly

const vs final

const requires a compile-time value; final accepts a runtime value. Writing const for runtime data fails compilation.

// BAD: runtime values cannot be const

// const now = DateTime.now(); // compile error

// GOOD: use `final` for runtime values

final now = DateTime.now();

// GOOD: use `const` for compile-time constants

const pi = 3.14159;

// const values are canonicalized and shared

// final only prevents reassignment

// collection elements can also be const

Lazy Iterable

map / where return lazy Iterables that recompute on iteration. Snapshot with toList when needed.

// BAD: a lazy Iterable recomputes on each iteration

final nums = [1, 2, 3];

final lazy = nums.where((n) => n.isOdd);

nums.add(5);

print(lazy.toList()); // [1, 3, 5] includes the new element

// GOOD: use `toList()` for a snapshot

final snapshot = nums.where((n) => n.isOdd).toList();

nums.add(7);

print(snapshot); // still [1, 3, 5]

// underlying changes do not affect materialized results

// a Stream can only be listened to once

Forgetting await

Calling an async function without await gives you a Future, not its result. Use Future.wait for parallelism.

// BAD: forgetting `await` yields a Future

Future<String> fetch() async => '数据';

Future<void> main() async {

final result = fetch(); // a Future, not a String

print(result);

// GOOD: only the awaited result is the value

final text = await fetch();

print(text);

// await multiple concurrently:

final all = await Future.wait([fetch(), fetch()]);

print(all);

}

Cascade returns receiver

The cascade .. returns the receiver, not the last expression's value. Don't cascade when you need the result.

class User {

String name = '';

int age = 0;

}

void main() {

// BAD: cascade returns the receiver

final result = [1, 2]..add(3);

print(result); // [1, 2, 3], not 3

// GOOD: cascade mutates in place and returns the same object

final user = User()

..name = 'Rex'

..age = 5;

print(user.name);

// use a regular call when you need the function's return value

print('abc'.toUpperCase());

}

Modifying during iteration

Adding or removing during iteration throws ConcurrentModificationError. Use removeWhere or collect first.

// BAD: mutating while iterating throws

final items = [1, 2, 3, 4];

// for (final n in items) { items.remove(n); }

// throws ConcurrentModificationError

// GOOD: `removeWhere` filters safely

final nums = [1, 2, 3, 4];

nums.removeWhere((n) => n.isEven);

print(nums); // [1, 3]

// GOOD: collect first, then process

final keep = <int>[];

for (final n in nums) {

if (n.isOdd) keep.add(n);

}

print(keep);

Strings by code units

length counts UTF-16 code units — Chinese and emoji take more than one. Iterate runes for real characters.

// BAD: counting chars with `length`

final s = '你好';

print(s.length); // 2 code units

// emoji case:

final emoji = '👍';

print(emoji.length); // 2! for a single glyph

// GOOD: count code points with `runes`

print(emoji.runes.length); // 1

// GOOD: iterate `runes` for per-glyph handling

for (final r in emoji.runes) {

print(String.fromCharCode(r));

}

14.Concurrency & Async

Isolates, Future, Stream, and the event loop.

Isolate concurrency

An isolate is Dart's concurrency unit — its own memory and event loop. Start with Isolate.run or Isolate.spawn.

import 'dart:isolate';

Future<void> main() async {

final result = await Isolate.run(() {

var sum = 0;

for (var i = 0; i < 100000; i++) {

sum += i;

}

return sum;

});

print('结果: $result');

}

// Isolate.run returns Future<result>

// isolated memory, no shared mutable state

// suited for CPU-bound work

// disposed automatically when finished

spawn & ports

Isolate.spawn starts an isolate with an entry function. SendPort sends, ReceivePort receives.

import 'dart:isolate';

void entry(SendPort sendPort) {

sendPort.send('来自新 isolate');

}

Future<void> main() async {

final receive = ReceivePort();

await Isolate.spawn(entry, receive.sendPort);

final msg = await receive.first;

print(msg);

receive.close();

}

// `spawn` entry must be a top-level function or static method

// messages are passed through ports

// `receive.first` awaits the first message

// remember to close the port when done

Future basics

Future represents a result that's available later. Future.value resolves immediately; await waits.

Future<int> addLater(int a, int b) async {

await Future.delayed(Duration(milliseconds: 10));

return a + b;

}

Future<void> main() async {

final future = Future.value(42);

print(await future);

final result = await addLater(1, 2);

print(result);

}

// `async` function returns a Future

// `await` suspends until the Future completes

// Future.delayed schedules a delay

// Future.value wraps an immediate result

async / await

async marks an async function; await pauses for the Future. await is only valid inside async.

Future<String> fetchUser() async {

await Future.delayed(Duration(milliseconds: 50));

return 'Rex';

}

Future<void> main() async {

print('开始加载');

final name = await fetchUser();

print('加载到: $name');

final results = await Future.wait([

fetchUser(),

]);

print(results);

}

// `await` pauses the current flow but does not block the main thread

// multiple awaits run sequentially by default

// Future.wait awaits multiple futures concurrently

// errors propagate to the `await` site and can be caught

Stream

A Stream is a sequence of async events. Use listen to subscribe, await for to iterate. Different from Future's single value.

import 'dart:async';

Stream<int> tick(int max) async* {

for (var i = 0; i < max; i++) {

await Future.delayed(Duration(milliseconds: 10));

yield i;

}

Future<void> main() async {

await for (final n in tick(3)) {

print('tick $n');

}

tick(2).listen((n) => print('listen $n'));

await Future.delayed(Duration(milliseconds: 100));

}

// `await for` consumes stream events sequentially

// `listen` registers a listener callback

// a stream emits once and cannot be replayed

// events arrive one at a time

StreamController

StreamController drives a stream manually — add pushes data, addError pushes errors, close ends it. broadcast enables multi-listeners.

import 'dart:async';

void main() {

final controller = StreamController<int>();

controller.stream.listen((n) => print('收到 $n'));

controller.add(1);

controller.add(2);

controller.close();

final broadcast = StreamController<int>.broadcast();

broadcast.stream.listen((n) => print('A $n'));

broadcast.stream.listen((n) => print('B $n'));

broadcast.add(5);

broadcast.close();

}

// by default the stream allows only one listener

// broadcast allows multiple listeners

// `add` pushes data into the stream

// remember to close the controller to free resources

Waiting for multiple Futures

Future.wait waits for all to complete; Future.any resolves with the first to finish.

Future<int> slow() async {

await Future.delayed(Duration(milliseconds: 30));

return 1;

}

Future<int> fast() async {

await Future.delayed(Duration(milliseconds: 10));

return 2;

}

Future<void> main() async {

final all = await Future.wait([slow(), fast()]);

print(all); // [1, 2]

final first = await Future.any([slow(), fast()]);

print(first); // 2

}

// `wait` returns the list when all succeed

// any failure propagates by default

// `any` returns the first to complete

// `eagerError` controls immediate failure

Completer

Completer gives you manual control over a Future's completion — handy for wrapping callback APIs in async/await.

import 'dart:async';

Future<String> fromCallback() {

final completer = Completer<String>();

Future.delayed(Duration(milliseconds: 20), () {

completer.complete('回调结果');

});

return completer.future;

}

Future<void> main() async {

final result = await fromCallback();

print(result);

}

// `complete` makes the Future succeed

// `completeError` makes the Future fail

// can only call complete once

// used to wrap third-party callbacks

15.Networking

HTTP requests, WebSocket, and TCP sockets.

HTTP client

Use dart:io's HttpClient for HTTP. getUrl returns a request; close it and read the body.

import 'dart:io';

import 'dart:convert';

Future<void> main() async {

final client = HttpClient();

final request = await client.getUrl(Uri.parse('https://example.com'));

final response = await request.close();

final body = await response.transform(utf8.decoder).join();

print('状态码: ${response.statusCode}');

print(body.substring(0, 50));

client.close();

}

// HttpClient is low-level and must be closed manually

// response body is a byte stream, decode with `utf8.decoder`

// statusCode 200 means success

// for simple scenarios prefer `package:http`

package:http

package:http wraps common requests. http.get / http.post return a Response whose body is a string.

import 'dart:convert';

import 'package:http/http.dart' as http;

Future<void> main() async {

final response = await http.get(

Uri.parse('https://example.com'),

);

print('状态码: ${response.statusCode}');

print(response.body.substring(0, 50));

final post = await http.post(

Uri.parse('https://example.com/api'),

headers: {'Content-Type': 'application/json'},

body: jsonEncode({'name': 'Rex'}),

);

print(post.statusCode);

}

// add `http` dependency to pubspec.yaml

// `Response.body` is already decoded as String

// `headers` passes request headers

// check `statusCode` for success

URI parsing

Uri.parse parses a URL; queryParameters reads the query string; Uri.http builds a request URL.

void main() {

final uri = Uri.parse('https://api.com/users?id=5&page=2');

print(uri.scheme); // https

print(uri.host); // api.com

print(uri.path); // /users

print(uri.queryParameters); // {id: 5, page: 2}

final built = Uri.http('api.com', '/users', {'id': '5'});

print(built);

}

// `queryParameters` are auto-decoded

// `Uri.https` uses TLS

// `queryParametersAll` handles duplicate keys

// `replace` can derive a new URI

JSON API

Call a JSON API and parse the response with jsonDecode. Combine package:http with Future.

import 'dart:convert';

import 'package:http/http.dart' as http;

Future<void> main() async {

final response = await http.get(

Uri.parse('https://api.example.com/users'),

);

if (response.statusCode == 200) {

final data = jsonDecode(response.body) as List;

for (final item in data) {

final user = item as Map<String, dynamic>;

print(user['name']);

}

// check the status code before parsing

// JSON arrays become List, objects become Map

// missing field returns null

// in real projects wrap with model classes

WebSocket

WebSocket is full-duplex. WebSocket.connect establishes the link; add sends; iterate to receive.

import 'dart:io';

Future<void> main() async {

final ws = await WebSocket.connect('wss://example.com/ws');

ws.add('你好');

await for (final message in ws) {

print('收到: $message');

if (message == 'bye') {

await ws.close();

}

// `connect` establishes the connection

// `add` sends a message

// receive messages via the stream

// `close` ends the connection gracefully

TCP socket

Socket.connect establishes a TCP connection. Write the request, stream the response. Good for low-level protocols.

import 'dart:io';

Future<void> main() async {

final socket = await Socket.connect('example.com', 80);

socket.write('GET / HTTP/1.0\r\n\r\n');

await for (final data in socket) {

final text = String.fromCharCodes(data);

if (text.contains('HTTP')) print(text);

}

socket.destroy();

}

// Socket provides a byte stream

// `write` sends the request content

// read response chunks as a stream

// `destroy` closes immediately

HTTP server

HttpServer.bind starts a local server, then await for iterates over requests. Great for dev tools.

import 'dart:io';

Future<void> main() async {

final server = await HttpServer.bind('localhost', 8080);

print('监听 8080 端口');

await for (final request in server) {

request.response.headers.set('Content-Type', 'text/plain; charset=utf-8');

request.response.write('你好，路径 ${request.uri.path}');

await request.response.close();

}

// `bind` binds address and port

// each request arrives through `await for`

// the `response` object writes the reply

// `close` ends this response

Timeouts & errors

Network calls may time out or fail. Use .timeout and catch each error type explicitly.

import 'dart:async';

import 'package:http/http.dart' as http;

Future<void> main() async {

try {

final response = await http

.get(Uri.parse('https://example.com'))

.timeout(const Duration(seconds: 5));

print(response.statusCode);

} on TimeoutException {

print('请求超时');

} catch (e) {

print('网络错误: $e');

}

// `timeout` throws TimeoutException after the deadline

// network errors are usually SocketException

// handle each error type separately

// in production add exponential-backoff retries

16.Time & Date

DateTime, Duration, formatting, and timestamps.

Current time

DateTime.now() returns the current local time. All fields are accessible, including milliseconds.

void main() {

final now = DateTime.now();

print('${now.year}-${now.month}-${now.day}');

print('${now.hour}:${now.minute}:${now.second}');

print(now.weekday); // Mon=1 Sun=7

print(now.millisecondsSinceEpoch);

}

// `now` returns local-time

// month/day start from 1

// weekday 1-7, with Monday = 1

// every field is `int`

Constructing time

DateTime(year, month, day, ...) constructs a time; DateTime.utc constructs UTC time.

void main() {

final birthday = DateTime(2020, 1, 15);

print(birthday);

final launch = DateTime(2026, 8, 2, 10, 30);

print(launch);

final utc = DateTime.utc(2026, 1, 1);

print(utc.isUtc); // true

}

// omitted parts default to 0 or 1

// invalid month/day values carry over automatically

// construct UTC with `DateTime.utc`

// compare with `isBefore`/`isAfter`

Duration

Duration represents a span of time — hours, minutes, seconds, microseconds. Supports arithmetic, comparison, and unit conversion.

void main() {

final halfHour = Duration(minutes: 30);

final fiveMin = Duration(minutes: 5);

print(halfHour.inSeconds); // 1800

print(halfHour + fiveMin); // 35 minutes

print(halfHour > fiveMin); // true

final d = Duration(days: 1, hours: 2);

print('${d.inHours} 小时'); // 26 hours

}

// `inSeconds`/`inMinutes`/etc. convert units

// supports `+ - * /` arithmetic

// supports comparison

// commonly use `Duration(milliseconds: n)` for delays

Formatting output

Dart has no built-in strftime — use padLeft to zero-pad, or the intl package's DateFormat.

void main() {

final now = DateTime.now();

final y = now.year.toString();

final m = now.month.toString().padLeft(2, '0');

final d = now.day.toString().padLeft(2, '0');

print('$y-$m-$d');

print(now.toIso8601String());

// `intl` package provides date formatting:

// import 'package:intl/intl.dart';

// print(DateFormat('yyyy-MM-dd').format(now));

}

// `padLeft` pads to the given width

// `toIso8601String` outputs ISO format

// `intl` supports localized date patterns

// for simple cases manual concatenation is enough

Parsing time

DateTime.parse reads an ISO-8601 string; toIso8601String produces one. Both ease data exchange.

void main() {

final parsed = DateTime.parse('2026-08-02 10:30:00');

print(parsed.year); // 2026

final iso = DateTime.parse('2026-08-02T10:30:00Z');

print(iso.isUtc); // true

final parts = '2026-08-02'.split('-');

final d = DateTime(

int.parse(parts[0]), int.parse(parts[1]), int.parse(parts[2]));

print(d.day);

}

// supports several ISO formats

// no timezone defaults to local time

// trailing `Z` means UTC

// invalid format throws FormatException

Time arithmetic

add / subtract shift time by a Duration; difference returns the Duration between two times.

void main() {

final start = DateTime(2026, 8, 2, 10);

final later = start.add(Duration(hours: 5));

print(later.hour); // 15

final earlier = start.subtract(const Duration(days: 1));

print(earlier.day); // 1

final diff = later.difference(start);

print(diff.inHours); // 5

}

// `add`/`subtract` return a new instance

// the original instance is immutable

// `difference` is always non-negative

// for direction-aware comparison use `isBefore`

Timestamps

Millisecond/microsecond timestamps store and order easily. fromMillisecondsSinceEpoch rebuilds a DateTime.

void main() {

final now = DateTime.now();

final ms = now.millisecondsSinceEpoch;

print(ms);

final back = DateTime.fromMillisecondsSinceEpoch(ms);

print(back.toIso8601String());

final day = DateTime(now.year, now.month, now.day);

print(day.millisecondsSinceEpoch);

}

// timestamp is milliseconds since 1970-01-01

// store as UTC to avoid timezone confusion

// `fromMicrosecondsSinceEpoch` works with microseconds

// the same timestamp yields equal reconstructed DateTimes

Timezone

DateTime defaults to local time. Use isUtc to test; toUtc / toLocal to convert. Persist in UTC.

void main() {

final now = DateTime.now();

print(now.isUtc); // false

final utc = now.toUtc();

print(utc.isUtc); // true

final local = utc.toLocal();

print(local == now); // same instant

}

// `toUtc`/`toLocal` convert without changing the instant

// DateTime does not carry an IANA timezone name

// for IANA timezones use `package:timezone`

// persist in UTC recommended

Stopwatch

Stopwatch measures elapsed time. start / stop / reset control it; elapsed returns a Duration.

void main() {

final watch = Stopwatch()..start();

var sum = 0;

for (var i = 0; i < 1000000; i++) {

sum += i;

}

watch.stop();

print('耗时 ${watch.elapsedMilliseconds} ms');

print('微秒 ${watch.elapsedMicroseconds}');

}

// `start` begins the timer

// `elapsed` returns a Duration

// `elapsedMilliseconds` gives milliseconds

// `reset` zeroes the watch and restarts

17.Processes & Environment

Child processes, environment variables, standard streams, and signals.

Run child process

Process.run executes a command and waits. result.stdout / stderr capture the output.

import 'dart:io';

Future<void> main() async {

final result = await Process.run('dart', ['--version']);

print('退出码: ${result.exitCode}');

print('输出: ${result.stdout}');

final ls = await Process.run(

Platform.isWindows ? 'cmd' : 'ls',

Platform.isWindows ? ['/c', 'dir'] : ['-la'],

);

print(ls.stdout);

}

// `run` waits for the process to exit and returns its result

// `stdout`/`stderr` are String or List<int>

// exitCode 0 means success

// for interactivity use `Process.start`

Streaming process

Process.start returns immediately — stream stdout and write stdin interactively. For long-running tasks.

import 'dart:io';

import 'dart:convert';

Future<void> main() async {

final process = await Process.start('dart', ['--version']);

process.stdout

.transform(utf8.decoder)

.transform(const LineSplitter())

.listen((line) => print('子进程输出: ${line.trim()}'));

final exitCode = await process.exitCode;

print('退出码: $exitCode');

}

// `start` does not wait for the process to exit

// `stdout` is a stream, listen in real time

// for interactivity write to `stdin`

// use `environment` to customize variables

Environment variables

Platform.environment is a read-only Map of env vars. Missing keys return null.

import 'dart:io';

void main() {

final env = Platform.environment;

final path = env['PATH'] ?? '未设置';

print('PATH: $path');

print('有 HOME: ${env.containsKey('HOME')}');

for (final entry in env.entries) {

if (entry.key.startsWith('FLUTTER')) {

print('${entry.key}=${entry.value}');

}

// `environment` is a read-only Map

// missing keys return null

// `containsKey` checks for presence

// pass `environment` when spawning to inject variables

Exit code

Set the process exit code via exitCode. 0 means success; non-zero signals failure categories to shells.

import 'dart:io';

void main(List<String> args) {

if (args.isEmpty) {

stderr.writeln('用法: app <参数>');

exitCode = 1;

return;

}

print('处理 ${args[0]}');

exitCode = 0; // success

}

// exitCode 0 means success

// non-zero indicates an error type

// `exit()` terminates the process immediately

// scripts rely on exit code to judge results

Args & script

args is the command-line argument list; Platform.script is the entry path; Directory.current is the cwd.

import 'dart:io';

void main(List<String> args) {

print('参数个数: ${args.length}');

for (var i = 0; i < args.length; i++) {

print('参数 $i: ${args[i]}');

}

print('脚本路径: ${Platform.script}');

print('当前目录: ${Directory.current.path}');

}

// `args` excludes the program name

// `Platform.script` is the entry script path

// `Directory.current` is the current working directory

// for complex args use the `args` package

Standard streams

stdout / stderr for output, stdin for input. flush forces a buffer write; stderr skips piped output.

import 'dart:io';

void main() {

stdout.write('请输入：');

stdout.flush();

final input = stdin.readLineSync() ?? '';

stdout.writeln('你输入了: $input');

if (input.isEmpty) {

stderr.writeln('警告：输入为空');

}

// `stdout.write` does not append a newline

// `flush` sends buffered output immediately

// `stderr` writes to the error stream

// when piped, stdout is redirected

Filesystem

File / Directory cover the filesystem — create, delete, rename, exists.

import 'dart:io';

Future<void> main() async {

final dir = Directory('data/sub');

await dir.create(recursive: true);

final file = File('data/note.txt');

await file.writeAsString('内容');

print(await file.exists()); // true

print(file.lengthSync()); // bytes

await file.rename('data/new.txt');

await Directory('data').delete(recursive: true);

}

// `create(recursive:)` creates nested directories

// `exists` checks for presence

// `lengthSync` reads size synchronously

// `rename` moves or renames a file

Signal handling

ProcessSignal responds to system signals (SIGINT / SIGTERM) — for graceful shutdown and cleanup.

import 'dart:io';

Future<void> main() async {

ProcessSignal.sigint.watch().listen((_) {

print('收到中断，清理退出');

exit(0);

});

print('运行中，按 Ctrl+C 退出');

await Future.delayed(Duration(seconds: 30));

}

// sigint is Ctrl+C

// sigterm is the default kill signal

// `watch` returns a stream of the signal

// call `exit` after handling

// on Windows only some signals are available

18.Regular Expressions

Matching, replacing, splitting, and grouping with RegExp.

Create & match

RegExp models a regular expression. hasMatch tests existence. The r prefix keeps the string raw.

void main() {

final digits = RegExp(r'\d+');

print(digits.hasMatch('abc123')); // true

print(digits.hasMatch('abc')); // false

final email = RegExp(r'^[\w.-]+@[\w-]+\.\w+$');

print(email.hasMatch('[email protected]'));

}

// `r` prefix marks a raw string

// \d digit, \w word char, \s whitespace

// ^ start, $ end of line

// `hasMatch` only checks existence

First match

firstMatch returns the first match. group extracts a capture; start / end give positions. null when there's no match.

void main() {

final re = RegExp(r'\d+');

final match = re.firstMatch('编号 42，编号 99');

if (match != null) {

print(match.group(0)); // 42

print(match.start); // match start

print(match.end); // match end

print(match.matched); // 42

}

// `firstMatch` returns the first match

// returns null when there is no match

// `group(0)` is the whole match

// `group(n)` is the nth capture group

All matches

allMatches returns an iterable of matches. Combine with patterns to extract all hits.

void main() {

final re = RegExp(r'\d+');

final matches = re.allMatches('a1 b22 c333');

final numbers = <String>[];

for (final m in matches) {

numbers.add(m.group(0)!);

}

print(numbers); // [1, 22, 333]

final list = RegExp(r'\d+')

.allMatches('a1 b22')

.map((m) => m.group(0)!)

.toList();

print(list);

}

// iterate each match object

// `group(0)` retrieves the whole match

// `map` chains extraction more concisely

// lazy iteration computes on demand

Replacement

replaceAll swaps every match; replaceFirst swaps just the first. Pass a callback for dynamic replacements.

void main() {

final re = RegExp(r'\d+');

print(re.replaceAll('a1b2', '#')); // a#b#

print(re.replaceFirst('a1b2', '#')); // a#b2

final result = re.replaceAllMapped('a1b2', (m) {

final n = int.parse(m.group(0)!);

return '${n + 1}';

});

print(result); // a2b3

}

// `replaceAll` replaces all occurrences

// `replaceFirst` replaces only the first

// callback form lets you compute per match

// the original is unchanged; returns a new string

Split

String.split accepts a RegExp — split on a pattern. The separator itself is dropped.

void main() {

final text = 'a, b, c';

final parts = text.split(RegExp(r',\s*'));

print(parts); // [a, b, c]

print('one two three'.split(RegExp(r'\s+')));

print(text.replaceAll(RegExp(r',\s*'), ' | '));

}

// `split` cuts at every match

// separators are not in the result

// for complex separators use regex

// for simple separators pass a string

Capture groups

Parentheses define capture groups. group(n) gets the nth; (?<name>...) names one for namedGroup.

void main() {

final re = RegExp(r'(\d{4})-(\d{2})-(\d{2})');

final m = re.firstMatch('日期 2026-08-02');

if (m != null) {

print(m.group(1)); // 2026

print(m.group(2)); // 08

print(m.group(3)); // 02

}

final named = RegExp(r'(?<year>\d{4})');

final nm = named.firstMatch('2026');

print(nm?.namedGroup('year'));

}

// `group(1)+` are capture groups

// non-capturing group `(?:...)` does not consume a number

// named groups improve readability

// `namedGroup` retrieves by name

Flags

Pass flags to the RegExp constructor — caseSensitive, multiLine, dotAll, unicode.

void main() {

final re = RegExp('dart', caseSensitive: false);

print(re.hasMatch('Hello DART')); // true

final multiline = RegExp('^a', multiLine: true);

print(multiline.hasMatch('x\na\nb')); // true

final dotAll = RegExp('a.b', dotAll: true);

print(dotAll.hasMatch('a\nb')); // true

}

// `caseSensitive: false` ignores letter case

// `multiLine` lets `^` match start of every line

// `dotAll` lets `.` match newlines

// `unicode: true` enables Unicode mode

Common patterns

Store common validators — email, phone, URL, IP — as reusable constants.

void main() {

final email = RegExp(r'^[\w.+-]+@[\w-]+\.\w+$');

final phone = RegExp(r'^1[3-9]\d{9}$');

final url = RegExp(r'^https?://\S+$');

final ip = RegExp(r'^\d{1,3}(\.\d{1,3}){3}$');

print(email.hasMatch('[email protected]'));

print(phone.hasMatch('13800138000'));

print(url.hasMatch('https://dart.dev'));

print(ip.hasMatch('192.168.1.1'));

}

// email: general validation

// phone: 11-digit China mobile

// URL: http/https

// IP: four dotted-decimal octets

19.Build & Debug

pub, static analysis, formatting, and testing.

pubspec configuration

pubspec.yaml is the package manifest — name, version, SDK constraint, dependencies. Run dart pub get to resolve.

// pubspec.yaml example:

// name: myapp

// description: 示例应用

// version: 1.0.0

// environment:

// sdk: '>=3.0.0 <4.0.0'

// dependencies:

// http: ^1.1.0

// dev_dependencies:

// test: ^1.24.0

// version constraint:

// ^1.1.0 means >=1.1.0 <2.0.0

// install dependencies:

// dart pub get

pub commands

Manage dependencies with pub: get, upgrade, outdated, add, remove.

// install dependencies:

// dart pub get

// upgrade all dependencies:

// dart pub upgrade

// list outdated dependencies:

// dart pub outdated

// add a dependency:

// dart pub add http

// remove a dependency:

// dart pub remove http

// search packages:

// dart pub search json

// publish:

// dart pub publish

// versions are locked in pubspec.lock

Static analysis

dart analyze does static analysis — run in CI to enforce quality.

// analyze the current package:

// dart analyze

// analyze a specific file:

// dart analyze lib/main.dart

// common checks:

// unused imports

// type errors

// discouraged patterns

// apply lint fixes:

// dart fix --apply

// CI integration:

// dart analyze && dart test

Formatting

dart format enforces a consistent style — indentation, quotes, line breaks. Use in team workflows.

// format current directory:

// dart format .

// format a specific file:

// dart format lib/main.dart

// check without modifying:

// dart format --output=none --set-exit-if-changed .

// style conventions:

// 2-space indent

// prefer single quotes

// no trailing whitespace

// CI checks format consistency

Unit tests

package:test provides test() and expect. Run with dart test. Place tests in test/.

// test/calculator_test.dart:

import 'package:test/test.dart';

int add(int a, int b) => a + b;

void main() {

test('addition is correct', () {

expect(add(1, 2), 3);

expect(add(-1, 1), 0);

});

group('edge cases', () {

test('large numbers add', () {

expect(add(1000000, 1), 1000001);

});

}

// run tests:

// dart test

// run a single file:

// dart test test/calculator_test.dart

// filter by name:

// dart test -n addition

Compile & deploy

dart compile produces executables: exe (native), js (web), aot-snapshot, kernel.

// compile a native executable:

// dart compile exe bin/main.dart

// specify the output:

// dart compile exe bin/main.dart -o myapp

// compile to JS (browser):

// dart compile js lib/main.dart

// AOT snapshot:

// dart compile aot-snapshot bin/main.dart

// compile kernel:

// dart compile kernel bin/main.dart

// after compile no Dart SDK is needed at runtime

// native exe starts fast

lint rules

Configure lints in analysis_options.yaml. The lints package ships a recommended set.

// analysis_options.yaml example:

// include: package:lints/recommended.yaml

// linter:

// rules:

// - prefer_final_locals

// - avoid_print

// analyzer:

// language:

// strict-casts: true

// recommended ruleset:

// package:lints/recommended.yaml

// Flutter projects use flutter_lints

// `dart analyze` applies these rules

Debugging

print is the simplest debugger. assert checks invariants; IDE breakpoints step through code.

void main() {

final total = calculate(3, 4);

print('调试: total=$total');

assert(total > 0, '结果应为正');

print(total);

}

int calculate(int a, int b) {

final sum = a + b;

// `dart:developer` `log` supports levels:

// log('中间值 $sum', name: 'calc');

return sum;

}

// `print` outputs to the console

// `dart:developer` `log` supports levels

// asserts are stripped in release mode

// breakpoints support step-through debugging

// `debugPrint` is for Flutter's high-volume logging

Official Links

Direct links to the official docs and resources.

Trademark & Use Notice

These programming language cheatsheets are open community references. The names, logos, and trademarks of the programming languages and runtimes referenced here (such as Java™, C#, Swift™, Kotlin™, Dart™, TypeScript™, Go™, Rust™, Python™, JavaScript™, Perl™, PHP, R, Scratch™, C, C++) are the property of their respective owners and are used here solely for identification and reference purposes.

All content in these cheatsheets is independently authored as a simplified, self-contained reference. It is not affiliated with, endorsed by, or sourced from any official documentation. Code examples, syntax references, and descriptions are original simplifications; for authoritative information please consult the official documentation of each language or runtime.

Where applicable, language version tags and badges (e.g. "C++17 / C++20", "C# 12", "Swift 5.9") reflect specific stable releases; behavior may differ in other versions. The choice of which version to document does not imply any preference or recommendation by the trademark holders.

If a trademark or copyright owner believes that any content on this site infringes their rights, please send an email to [email protected]. Upon receiving valid proof of rights, we will modify or remove the relevant content within a reasonable period.

This website assumes no legal liability for any direct or indirect losses arising from the use of information presented on these pages.

Version 2.1.1