Coding/Learn/dart/dart pattern matching
Dart & Flutter Engineering Complete Course
01.Introduction & Execution Architecture
02.Syntax, Statements & Code Organization
03.Variables, Type Inference, final & const
04.Core Built-In Types: int, double, num, bool, String
05.String Interpolation, Multiline & Raw Strings
06.Operators: Arithmetic, Type Test, Ternary & Cascade
07.Conditional Branching: if, else if, else & Guards
08.Loops: standard for, for-in, while & do-while
09.Switch Statements, Switch Expressions & Exhaustiveness
10.Loop Control: break, continue & Labeled Jumps
11.Pattern Matching & Destructuring in Dart 3
12.Error Handling: try, catch, on, finally & assert
13.Functions, Return Types & Arrow Syntax (=>)
14.Named Parameters & the required Keyword
15.Optional Positional Parameters & Default Values
16.Anonymous Functions, Lambdas & typedefs
17.Lexical Scope & Stateful Closures
18.Synchronous Generators: sync* and yield
19.Lists: Fixed-Length, Growable & Index Operations
20.Sets: Unique Values & Set Theory Algebra
21.Maps: Key-Value Dictionaries & Lookups
22.Collection-if, Collection-for & Spread Operators
23.Iterables & Higher-Order Methods: map, where, fold
24.Generics: Type Parameters, Bounds & Methods
25.Classes & Objects: Members, Instance Methods & this
26.Constructors: Initializing Formals & Initializer Lists
27.Named, Redirecting & Factory Constructors
28.Const Constructors & Canonical Instance Caching
29.Getters, Setters & Private Fields (_)
30.Inheritance, Method Overriding (@override) & super
31.Abstract Classes & Method Contracts
32.Implicit Interfaces & the implements Keyword
33.Mixins: Multi-Source Composition with with & on
34.Extension Methods: Extending External APIs
35.Extension Types: Zero-Cost Inline Wrappers in Dart 3.3
36.Enhanced Enums with Fields, Methods & Patterns
37.Records: Anonymous Composite Tuples in Dart 3
38.Class Modifiers: sealed, final, base & interface
39.Sound Null Safety: Core Architecture
40.Nullable Types (Type?) & Non-Nullable Invariants
41.Null-Aware Operators: ?., ??, ??=, ?.. & ?[]
42.Null Assertion Operator (!) & Safe Invariants
43.The late Keyword: Lazy Initialization & Late Final
44.Type Promotion & Flow Analysis
45.Event Loop & Microtask Queue Architecture
46.Futures, async & await: Asynchronous Foundations
47.Future Combinators: wait, any, delayed & timeout
48.Streams: Asynchronous Data Flows & StreamControllers
49.Stream Transformers & Asynchronous Generators (async*)
50.Isolates: Multi-Core Concurrency & Isolate.run()
51.Packages & pubspec.yaml: Dependency Management
52.Libraries, Namespaces & Barrel Exports
53.Unit Testing with package:test & Matchers
54.Async Testing, Stream Tests & Fixtures
55.Effective Dart Guidelines & Linter Optimization
56.Comprehensive Dart Exercises & Algorithm Challenges
57.& Flutter Architecture Assessment & Knowledge Check
58.Capstone Project: Reactive State Machine & Stream Event Hub
59.Mastery Certification & Verified Graduate Credential
Course Certificate0%

Complete all lessons to earn

LearnPattern Matching & Destructuring in Dart 3
11 / 59 0%
Lesson 11 of 59
5 mins read

Pattern Matching & Destructuring in Dart 3

PreviousNext Lesson
In Plain English

Pattern Matching in Dart 3 enables expressive data destructuring and validation. Patterns match values against shapes, extract subcomponents into local variables, and assert conditions simultaneously. You can destructure Lists, Records, Maps, Object properties, and apply Relational Patterns (`>= 100`, `< 0`).

The Mental Model

"Pattern matching is like a coin sorter: coins roll down a slot where each coin fits into a matching hole and drops into a categorized sorting bin automatically."

Deep Dive: How It Works

List Patterns: `final [first, second, ...rest] = items;` extracts elements and gathers remaining items.

Record Destructuring: `final (name, age: userAge) = ("Alice", age: 30);`.

Relational Patterns: `case >= 18 && <= 65 => "Working Age"` matches numeric ranges directly in switch blocks.

Object Patterns: `case User(role: "admin", :email) => print("Admin: $email");`.

Syntax Blueprint

// List destructuring
final [a, b, ...tail] = [1, 2, 3, 4, 5];

// Relational switch pattern
final desc = switch (score) {
  >= 90 => "A",
  >= 80 => "B",
  _ => "F",
};

Destructuring sequences and matching relational boundary patterns.

PointCore Rules to Remember

Point star
Simultaneous Match & Extract: Validates structure and binds sub-variables in a single operation.
Point star
Rest Elements (...): Gathers remaining unassigned elements into a new sub-list.
Point star
Relational Patterns: Use comparison operators (`>`, `<`, `>=`, `<=`) directly inside switch cases.

Common Beginner Traps & How to Fix Them

Mistake:Trying to match a fixed-length list pattern against a list with different item counts without `...`.

Why it happens: `[a, b]` expects exactly 2 elements; if the list has 3, the match fails.

How to fix: Use `[a, b, ...]` or `if-case` matching.

Pro Tip: Use `if (json case {'id': int id, 'name': String name})` for bulletproof JSON API response validation and destructuring.

Live Interactive Example

Hit Run Code to see it live
List Destructuring and Relational Pattern Matching
Python 3.12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Output Console
Click "Run Code" to view the rendered output.
How it works: Destructured list elements into x and y and evaluated speed using relational ranges.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Destructure First and Last with Rest Pattern

  • PointGiven list `final scores = [100, 85, 90, 70, 95];`.
  • PointUse list pattern destructuring `final [first, ..., last] = scores;`.
  • PointPrint `First: $first, Last: $last`.
1
2
3
4
5
Sandbox Output
Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.

PreviousNext Lesson
Overview100 SheetLearnCertificates