1. Padrão Lógico OU A || B

Corresponde a qualquer um dos subpadrões; todos os ramos devem definir o mesmo conjunto completo de variáveis.

enum Color { red, yellow, blue, green }
void main() {
  Color c = Color.red;
  bool primary = switch(c) {
    Color.red || Color.yellow || Color.blue => true,
    _ => false
  };
  print(primary); // true
}Code language: Dart (dart)

2. Padrão Lógico E A && B

Ambos os subpadrões precisam combinar simultaneamente; subpadrões não podem vincular variáveis com o mesmo nome.

void main() {
  switch((2, 3)) {
    // Erro: dois subpadrões vinculam a variável b, conflito de nomes
    // case (var a, var b) && (var b, var c): print("ok");
    case (var a, var b) && (>1, <5):
      print("a=$a,b=$b"); // a=2,b=3
  }
}Code language: Dart (dart)

O trecho (>1, <5) exige que o primeiro número seja maior que 1 e o segundo menor que 5.

3. Padrão Relacional < > <= >= == !=

Usado para verificação de intervalos numéricos, frequentemente combinado com && para limitar o alcance dos valores

String asciiCharType(int charCode) {
  const space = 32, zero = 48, nine = 57;
  return switch(charCode) {
    < space => "Caractere de controle",
    == space => "Espaço",
    > space && < zero => "Pontuação",
    >= zero && <= nine => "Dígito",
    _ => "Outro"
  };
}
void main() {
  print(asciiCharType(50)); // Dígito
  print(asciiCharType(33)); // Pontuação
}Code language: Dart (dart)

Este exemplo usa o código ASCII para categorizar caracteres de controle, números e símbolos. Regra de avaliação do charCode no switch: abaixo de 32 = caractere de controle, igual a 32 = espaço, entre 32 e 48 = pontuação, de 48 a 57 inclusive = dígito, todos os demais valores são classificados como outro.

4. Padrão de Conversão de Tipo Forçada sub as Type

Realiza conversão explícita de tipo durante a desestruturação; lança exceção em tempo de execução se houver incompatibilidade de tipos

void main() {
  (num, Object) rec = (10, "hello");
  var (i as int, s as String) = rec;
  print(i + 5); // 15
  print(s.toUpperCase()); // HELLO
}Code language: Dart (dart)

Neste exemplo, o registro rec é desmontado em i e s. Se o primeiro elemento não for inteiro ou o segundo não for string, uma exceção de execução será disparada.

Veja o exemplo com erro abaixo:

void main() {
  (num, Object) rec = (9.3, "hello");
  var (i as int, s as String) = rec;
  print(i + 5); // 15
  print(s.toUpperCase()); // HELLO
}Code language: Dart (dart)

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
Unhandled exception:
type 'double' is not a subtype of type 'int' in type cast
#0      main (file:///D:/dartdemo/firstdart/bin/firstdart.dart:3:10)
#1      _delayEntrypointInvocation.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:314:19)
#2      _RawReceivePort._handleMessage (dart:isolate-patch/isolate_patch.dart:193:12)Code language: PHP (php)

5. Padrão de Verificação de Nulo sub?

Só combina se o valor não for nulo; variáveis internas são promovidas automaticamente para tipo não anulável. Se o valor for null, a combinação falha sem disparar erros.

void main() {
  String? str = "test";
  switch(str) {
    case var s?:
      print(s.length); // s é string não anulável, saída 4
    case null:
      print("Valor nulo");
  }
}Code language: Dart (dart)

6. Padrão de Afirmação de Não Nulo sub!

Só combina se o valor não for nulo; caso o valor seja null, lança exceção imediatamente em tempo de execução

void main() {
  List<String?> row = ["user", "bob"];
  switch(row) {
    case ["user", var name!]:
      print(name); // name é string não anulável
  }

  // Uso na desestruturação de variáveis
  (int?, int?) pos = (2, 3);
  var (x!, y!) = pos;
  print(x + y);
}Code language: Dart (dart)

Explicação de var name!

• var name：Padrão de Variável — var declara uma nova variável local name e vincula o valor quando a combinação for bem-sucedida;
• !：Padrão de Afirmação Nulo Posfixo — Exige que o valor atual não seja null; gera erro de execução se for nulo.

Significado combinado: var name! cria uma nova variável name e garante simultaneamente que seu valor nunca é nulo.

7. Padrão Constante

Literais, constantes nomeadas, construtores const e coleções const são todos padrões constantes; ocorre combinação quando os valores são idênticos

Tipos suportados: números, strings, booleanos, constantes nomeadas, objetos / listas const

void main() {
  const target = 10;
  int num = 10;
  switch(num) {
    case 1: print("Um");
    case target: print("Combina com a constante 10");
    case const [1,2]: print("Lista constante");
    default: print("Outro");
  }
}Code language: Dart (dart)

Resultado da execução

Combina com a constante 10

8. Padrão de Variável var x / int x / final x

Vincula uma nova variável local ao combinar com sucesso; ao adicionar anotação de tipo, valida o tipo do valor simultaneamente

void main() {
  switch((99, "dart")) {
    case (int a, String b):
      print("$a $b"); // 99 dart
    case (int a, int b):
      print("Dois valores numéricos");
  }
}Code language: Dart (dart)

9. Padrão de Identificador

Seu comportamento se divide em três contextos:

1. Contexto de declaração var (a,b)：Cria novas variáveis
2. Contexto de atribuição (a,b) = val：Sobrescreve variáveis existentes
3. Contexto de combinação switch：Tratado como constante (exceto _)

void main() {
  const c = 5;
  int val = 2;
  switch(val) {
    case c: print("Combina com a constante c");
    default: print("Sem combinação"); // Esta linha é executada
  }
}
Code language: Dart (dart)

10. Padrão com Parênteses (subPadrão)

Ajusta a precedência dos operadores de padrão para separar a ordem de avaliação entre || e &&

void main() {
  bool x = true, y = true, z = false;
  bool test = switch(true) {
    (x || y) && z => true,
    _ => false
  };
  print(test); // false
}
Code language: Dart (dart)

11. Padrão de Lista

Combina com objetos List e desestrutura elementos por posição; suporta o operador rest ... para capturar qualquer quantidade de elementos restantes

1. Combinação básica de lista

void main() {
  const a = "a", b = "b";
  var arr = ["a", "b"];
  switch(arr) {
    case [a, b]: print("Combinação encontrada");
    default: print("Sem combinação");
  }
}Code language: Dart (dart)

2. Captura de elementos restantes com rest

void main() {
  var [a, b, ...rest, c, d] = [1,2,3,4,5,6,7];
  print("$a $b $rest $c $d"); // 1 2 [3, 4, 5] 6 7
}
Code language: Dart (dart)

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
1 2 [3, 4, 5] 6 7Code language: CSS (css)

12. Padrão Map {"chave": subP}

Combina com objetos Map e valida apenas as chaves especificadas; se uma chave alvo não existir, lança StateError, chaves extras não citadas são ignoradas

void main() {
  var data = {"user": ["Lily", 13]};
  if(data case {"user": [String name, int age]}) {
    print("$name $age"); //Lily 13
  }
}Code language: JavaScript (javascript)

13. Padrão de Registro (Record)

Duas variantes: registro posicional (p1,p2), registro nomeado (k:p1,k2:p2)

Suporta a sintaxe abreviada :var para omitir nomes de campos repetidos

void main() {
  // Desestruturação de registro posicional
  var (name, age) = ("Doug", 25);
  // Desestruturação abreviada de campos nomeados
  final (:name, :age) = (name: "Tom", age: 18);
}
Code language: JavaScript (javascript)

14. Padrão de Objeto Classe(prop: p)

Combina com objetos do tipo especificado e desestrutura propriedades getter; suporta a abreviação :var

class Point {
  final int x, y;
  Point(this.x, this.y);
}

void main() {
  Point p = Point(10, 20);
  var Point(:x, :y) = p;
  print("$x $y");
}
Code language: JavaScript (javascript)

15. Padrão Curinga _

Combina com qualquer valor sem vincular variável; usado como placeholder ou apenas para validar tipo sem extrair o valor

void main() {
  var arr = [1,2,3];
  var [_, mid, _] = arr;
  print(mid); // 2

  switch((10, "abc")) {
    case (int _, String _):
      print("Combinação de tipo bem-sucedida");
  }
}Code language: JavaScript (javascript)

Pattern