> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Dart Record Pattern
A record pattern is a declarative construct in Dart used to match, validate, and destructure Record types. It allows developers to extract positional and named fields from a record into distinct variables and perform inline type checking within pattern-matching contexts like `switch` statements, `if-case` clauses, and variable declarations.
## Syntax and Destructuring
Record patterns mirror the syntax of record expressions but operate in reverse, binding the extracted values to variables.
**Positional Fields**
Positional fields are matched strictly by their order within the record.
```dart theme={"dark"}
// Destructuring via variable declaration
var (a, b) = (10, 'Dart');
```
**Named Fields**
Named fields are matched by their explicit identifiers, regardless of their order. The syntax requires the field name followed by a colon and the variable to bind.
```dart theme={"dark"}
var (name: n, age: a) = (name: 'Alice', age: 30);
```
Dart provides a syntactic shorthand for named fields when the bound variable name matches the field name. Prefixing the identifier with a colon implicitly creates a variable of the same name.
```dart theme={"dark"}
var (:name, :age) = (name: 'Alice', age: 30);
// Equivalent to: var (name: name, age: age)
```
## Pattern Matching and Control Flow
When used in control flow structures, record patterns act as predicates that evaluate to a boolean while simultaneously binding variables if the match succeeds.
```dart theme={"dark"}
final record = (1, 'success');
if (record case (int code, String message)) {
print(code); // Binds 1 to `code`
print(message); // Binds 'success' to `message`
}
```
## Advanced Mechanics
**Nested Subpatterns**
Record patterns can contain nested subpatterns, allowing for deep destructuring of complex, multi-layered data structures.
```dart theme={"dark"}
final complexRecord = (1, (x: 2, y: 3));
switch (complexRecord) {
case (int id, (:var x, :var y)):
print('$id, $x, $y');
}
```
**Wildcards**
The underscore `_` acts as a wildcard pattern to discard specific positional fields without binding them to a variable or allocating memory for them.
```dart theme={"dark"}
var (first, _, third) = (10, 20, 30);
```
**Type Checking and Casting**
Patterns can enforce type constraints on individual fields. If the runtime type of the record's field does not match the pattern's type annotation, the match fails safely without throwing an exception.
```dart theme={"dark"}
dynamic data = (1, 2.5);
switch (data) {
case (int a, String b):
// Match fails: Second field is double, not String
break;
case (int a, double b):
// Match succeeds: Types align, variables 'a' and 'b' are bound
break;
}
```
Tired of Poor Dart Skills? Fix That With Deep Grasping!
Learn More
