Ramificaciones

Esta página muestra cómo puedes controlar el flujo de tu código Dart usando ramas:

• sentencias y elementos if
• sentencias y elementos if-case
• sentencias y expresiones switch

También puedes manipular el control de flujo en Dart usando:

• Bucles (Loops), como for y while
• Excepciones, como try, catch y throw

Dart admite sentencias if con cláusulas else opcionales. La condición entre paréntesis después de if debe ser una expresión que se evalúe como un boolean:

if (isRaining()) {
  you.bringRainCoat();
} else if (isSnowing()) {
  you.wearJacket();
} else {
  car.putTopDown();
}

Para aprender cómo usar if en un contexto de expresión, consulta Expresiones condicionales.

Las sentencias if de Dart admiten cláusulas case seguidas de un patrón (pattern):

if (pair case [int x, int y]) return Point(x, y);

Si el patrón coincide con el valor, entonces la rama se ejecuta con cualquier variable que el patrón defina dentro de su alcance.

En el ejemplo anterior, el patrón de lista [int x, int y] coincide con el valor pair, por lo que la rama return Point(x, y) se ejecuta con las variables que definió el patrón, x e y.

De lo contrario, el control de flujo avanza hacia la rama else para ejecutarse, si existe una:

if (pair case [int x, int y]) {
  print('Was coordinate array $x,$y');
} else {
  throw FormatException('Invalid coordinates.');
}

La sentencia if-case proporciona una forma de coincidir y desestructurar (destructure) frente a un único patrón. Para probar un valor frente a múltiples patrones, utiliza switch.

Una sentencia switch evalúa una expresión de valor frente a una serie de casos. Cada cláusula case es un patrón (pattern) con el que se compara el valor. Puedes usar cualquier tipo de patrón para un caso.

Cuando el valor coincide con el patrón de un caso, se ejecuta el cuerpo del caso. Las cláusulas case no vacías saltan al final del switch al finalizar. No requieren una sentencia break. Otras formas válidas de finalizar una cláusula case no vacía son las sentencias continue, throw o return.

Usa una cláusula default o un comodín _ (wildcard) para ejecutar código cuando ninguna cláusula case coincide:

var command = 'OPEN';
switch (command) {
  case 'CLOSED':
    executeClosed();
  case 'PENDING':
    executePending();
  case 'APPROVED':
    executeApproved();
  case 'DENIED':
    executeDenied();
  case 'OPEN':
    executeOpen();
  default:
    executeUnknown();
}

Los casos vacíos continúan en el siguiente caso, lo que permite que los casos compartan un cuerpo. Para un caso vacío que no continúa (fall through), usa break en su cuerpo. Para una continuación no secuencial, puedes usar una sentencia continue y una etiqueta (label):

switch (command) {
  case 'OPEN':
    executeOpen();
    continue newCase; // Continues executing at the newCase label.
​
  case 'DENIED': // Empty case falls through.
  case 'CLOSED':
    executeClosed(); // Runs for both DENIED and CLOSED,
​
  newCase:
  case 'PENDING':
    executeNowClosed(); // Runs for both OPEN and PENDING.
}

Puedes usar patrones lógicos de tipo O (logical-or patterns) para permitir que los casos compartan un cuerpo o una guarda (guard). Para obtener más información sobre patrones y cláusulas case, consulta la documentación de patrones sobre Sentencias y expresiones switch.

Una expresión switch produce un valor basado en el cuerpo de la expresión del caso que coincida. Puedes usar una expresión switch en cualquier lugar donde Dart admita expresiones, excepto al comienzo de una sentencia de expresión. Por ejemplo:

var x = switch (y) { ... };
​
print(switch (x) { ... });
​
return switch (x) { ... };

Si deseas usar un switch al comienzo de una sentencia de expresión, usa una sentencia switch.

Las expresiones switch te permiten reescribir una sentencia switch como esta:

// Where slash, star, comma, semicolon, etc., are constant variables...
switch (charCode) {
  case slash || star || plus || minus: // Logical-or pattern
    token = operator(charCode);
  case comma || semicolon: // Logical-or pattern
    token = punctuation(charCode);
  case >= digit0 && <= digit9: // Relational and logical-and patterns
    token = number();
  default:
    throw FormatException('Invalid');
}

En una expresión, como esta:

token = switch (charCode) {
  slash || star || plus || minus => operator(charCode),
  comma || semicolon => punctuation(charCode),
  >= digit0 && <= digit9 => number(),
  _ => throw FormatException('Invalid'),
};

La sintaxis de una expresión switch difiere de la sintaxis de una sentencia switch:

• Los casos no comienzan con la palabra clave case.
• El cuerpo de un caso es una sola expresión en lugar de una serie de sentencias.
• Cada caso debe tener un cuerpo; no hay un paso implícito (fallthrough) para casos vacíos.
• Los patrones de caso se separan de sus cuerpos mediante => en lugar de :.
• Los casos se separan por , (y se permite una , final opcional).
• Los casos por defecto solo pueden usar _, en lugar de permitir tanto default como _.

La comprobación de exhaustividad (exhaustiveness checking) es una característica que reporta un error en tiempo de compilación si es posible que un valor entre en un switch pero no coincida con ninguno de los casos.

// Non-exhaustive switch on bool?, missing case to match null possibility:
switch (nullableBool) {
  case true:
    print('yes');
  case false:
    print('no');
}

Un caso por defecto (default o _) cubre todos los posibles valores que pueden fluir a través de un switch. Esto hace que un switch sobre cualquier tipo sea exhaustivo.

Los Enums y los tipos sellados (sealed types) son particularmente útiles para los switches porque, incluso sin un caso por defecto, sus posibles valores son conocidos y completamente enumerables. Usa el modificador sealed en una clase para habilitar la comprobación de exhaustividad cuando realices un switch sobre los subtipos de esa clase:

sealed class Shape {}
​
class Square implements Shape {
  final double length;
  Square(this.length);
}
​
class Circle implements Shape {
  final double radius;
  Circle(this.radius);
}
​
double calculateArea(Shape shape) => switch (shape) {
  Square(length: var l) => l * l,
  Circle(radius: var r) => math.pi * r * r,
};

Si alguien agregara una nueva subclase de Shape, esta expresión switch estaría incompleta. La comprobación de exhaustividad te informaría del subtipo faltante. Esto te permite usar Dart con un estilo similar al de los tipos de datos algebraicos funcionales (functional algebraic datatypes).

Para establecer una cláusula de guarda opcional después de una cláusula case, usa la palabra clave when. Una cláusula de guarda puede seguir a if case, y a las sentencias y expresiones switch.

// Switch statement:
switch (something) {
  case somePattern when some || boolean || expression:
    //             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Guard clause.
    body;
}
​
// Switch expression:
var value = switch (something) {
  somePattern when some || boolean || expression => body,
  //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Guard clause.
}
​
// If-case statement:
if (something case somePattern when some || boolean || expression) {
  //                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Guard clause.
  body;
}

Las guardas evalúan una expresión booleana arbitraria después de la coincidencia del patrón. Esto te permite agregar restricciones adicionales sobre si debe ejecutarse el cuerpo de un caso. Cuando la cláusula de guarda se evalúa como falsa, la ejecución procede al siguiente caso en lugar de salir de todo el switch.