Apply Dart 3 language features — branches, patterns, pattern types, and records — correctly and idiomatically.
\nUse this skill when:
\nswitch statements or if-else chains.// Standard if\nif (score >= 90) {\n grade = 'A';\n} else if (score >= 80) {\n grade = 'B';\n} else {\n grade = 'C';\n}\n\n// if-case: match and destructure against a single pattern\nif (pair case [int x, int y]) {\n print('$x, $y');\n}\nif conditions must evaluate to a bool.if-case, variables declared in the pattern are scoped to the matching branch.else branch (if present).switch (command) {\n case 'quit':\n quit();\n case 'start' || 'begin': // logical-or pattern\n startGame();\n default:\n print('Unknown command');\n}\ncase body executes and jumps to the end — break is not required.continue, throw, or return.default or _ to handle unmatched values.break to prevent fallthrough in an empty case.continue with a label for non-sequential fallthrough.case a || b) to share a body between cases.final color = switch (shape) {\n Circle() => 'red',\n Square() => 'blue',\n _ => 'unknown',\n};\ncase; use => for bodies; separate cases with commas._ (not default).switch statements and expressions at compile time.default/_, enums, or sealed types to satisfy exhaustiveness.sealed class Shape {}\nclass Circle extends Shape {}\nclass Square extends Shape {}\n\n// Dart knows all subtypes — no default needed:\nString describe(Shape s) => switch (s) {\n Circle() => 'circle',\n Square() => 'square',\n};\nswitch (point) {\n case (int x, int y) when x == y:\n print('Diagonal: $x');\n case (int x, int y):\n print('$x, $y');\n}\nwhen condition after a pattern to further constrain matching.if-case, switch statements, and switch expressions.false, execution proceeds to the next case.Patterns represent the shape of a value for matching and destructuring.
\n// Variable declaration\nvar (a, [b, c]) = ('str', [1, 2]);\n\n// Variable assignment (swap)\n(b, a) = (a, b);\n\n// for-in loop destructuring\nfor (final MapEntry(:key, :value) in map.entries) { ... }\n\n// switch / if-case (see Branches section)\n_ ignores parts of a matched value....) in list patterns ignore remaining elements.var Foo(:one, :two) = myFoo;\nif (data case {'user': [String name, int age]}) {\n print('$name, $age');\n}\n| Pattern | \nSyntax | \nDescription | \n
|---|---|---|
| Logical-or | \np1 \\|\\| p2 | \nMatches if any branch matches. All branches must bind the same variables. | \n
| Logical-and | \np1 && p2 | \nMatches if both match. Variable names must not overlap. | \n
| Relational | \n== c, < c, >= c | \nCompares value to a constant. Combine with && for ranges. | \n
| Cast | \nsubpattern as Type | \nAsserts type, then matches inner pattern. Throws if type mismatch. | \n
| Null-check | \nsubpattern? | \nMatches non-null; binds non-nullable type. | \n
| Null-assert | \nsubpattern! | \nMatches non-null or throws. Use in declarations to eliminate nulls. | \n
| Constant | \n42, 'str', const Foo() | \nMatches if value equals the constant. | \n
| Variable | \nvar name, final Type name | \nBinds matched value to a new variable. Typed form only matches the declared type. | \n
| Wildcard | \n_, Type _ | \nMatches any value without binding. | \n
| Parenthesized | \n(subpattern) | \nControls precedence. | \n
| List | \n[p1, p2] | \nMatches lists by position. Length must match unless a rest element is used. | \n
| Rest element | \n..., ...rest | \nMatches arbitrary-length tails or collects remaining elements. | \n
| Map | \n{'key': subpattern} | \nMatches maps by key. Missing keys throw StateError. | \n
| Record | \n(p1, p2), (x: p1, y: p2) | \nMatches records by shape; field names can be omitted if inferred. | \n
| Object | \nClassName(field: p) | \nMatches by type and destructures via getters. Extra fields ignored. | \n
// Create\nvar record = ('first', a: 2, b: true, 'last');\n\n// Type annotation\n({int a, bool b}) namedRecord;\n\n// Access\nprint(record.$1); // positional: 'first'\nprint(record.a); // named: 2\n$1, $2, .name); no setters.hashCode and == are automatically defined.(String name, int age) userInfo(Map<String, dynamic> json) {\n return (json['name'] as String, json['age'] as int);\n}\n\nvar (name, age) = userInfo(json);\n// Named fields:\nfinal (:name, :age) = userInfo(json);\nUse a record when:
\nUse a class when:
\ncopyWith.typedef for record types to improve readability and maintainability.When modernizing pre-Dart-3 code, follow these steps:
\n// Before (pre-Dart 3)\nString label;\nif (status == Status.loading) {\n label = 'Loading...';\n} else if (status == Status.success) {\n label = 'Done';\n} else {\n label = 'Error';\n}\n\n// After (Dart 3)\nfinal label = switch (status) {\n Status.loading => 'Loading...',\n Status.success => 'Done',\n Status.error => 'Error',\n};\n// Before\nabstract class Result {}\nclass Success extends Result { final String data; Success(this.data); }\nclass Failure extends Result { final String error; Failure(this.error); }\n\n// After — enables exhaustive switch\nsealed class Result {}\nfinal class Success extends Result { const Success(this.data); final String data; }\nfinal class Failure extends Result { const Failure(this.error); final String error; }\nReplace wrapper classes used solely for returning multiple values with records.
\nRun dart analyze to confirm exhaustiveness and type safety after each change.