Cuando trabajas con código que recibe datos de fuentes externas —como un JSON de una API o un mensaje de un socket—, el tipado estático de Dart se enfrenta a la realidad del mundo real. Aquí es donde entran las comprobaciones de tipo en tiempo de ejecución. El operador is nos permite preguntar si un objeto pertenece a un tipo específico, devolviendo un bool, mientras que is! es su contraparte para verificar que un objeto no es de ese tipo. Para cuando la lógica es ambigua, el operador as nos permite forzar un cast explícito hacia un tipo determinado, aunque con una advertencia: si la suposición falla, el programa lanzará una excepción de tipo TypeError.
La razón de ser de estos operadores es permitir que Dart mantenga su seguridad de tipos incluso cuando manejamos Object o dynamic. El compilador no siempre puede adivinar qué contiene una variable, por lo que estas herramientas permiten validar la estructura antes de operar. En términos de rendimiento, el uso de is es extremadamente eficiente gracias al análisis de flujo (flow analysis) del compilador. Si realizas un if (objeto is String), el compilador “promociona” automáticamente la variable dentro de ese bloque: ya no necesitas tratarla como un Object genérico, sino que puedes acceder a sus propiedades de String directamente. Debes usar is para la lógica de control de flujo y reservar el operador as únicamente para casos donde el tipo es garantizado por un contrato previo (como un mapa de configuración que ya has validado), ya que el uso excesivo de as suele ser síntoma de un diseño débil donde se está intentando “engañar” al sistema de tipos en lugar de estructurar los datos correctamente.
// main.dart
void main() {
final processor = DataProcessor();
// Caso 1: Uso seguro con promoción de tipos
print('--- Caso 1 ---');
processor.process(data: "Hola, Dart");
processor.process(data: 42);
// Caso 2: Uso de is! (negación)
print('\n--- Caso 2 ---');
processor.process(data: [1, 2, 3]);
// Caso 3: Precisión con genéricos y runtimeType
print('\n--- Caso 3 ---');
final list = List<String>(growable: false);
processor.process(data: list);
// Caso 4: El peligro del cast explícito (as)
print('\n--- Caso 4 ---');
processor.process(data: "Un String que intentaremos tratar como int");
}
class DataProcessor {
void process({required dynamic data}) {
// runtimeType devuelve el tipo exacto en ejecución (Type)
print('Analizando tipo: ${data.runtimeType}');
// El operador 'is' activa la promoción de tipos
if (data is String) {
// Aquí 'data' ya es tratado como String por el compilador
// No hace falta hacer: (data as String).length
print('String detectado. Longitud: ${data.length}');
return;
}
if (data is! List) {
print('El objeto no es una lista, ignorando...');
return;
}
// Dart es un lenguaje con tipos reificados.
// 'is List<String>' será true solo si la lista es de Strings.
if (data is List<String>) {
print('Lista de Strings detectada: $data');
} else {
print('Es una lista, pero no de Strings.');
}
// Ejemplo de uso de 'as' bajo una suposición peligrosa
try {
// Forzamos el cast. Si data no es un int, esto lanzará TypeError
final int valor = data as int;
print('Valor entero: $valor');
} catch (e) {
print('Error al intentar el cast con "as": $e');
}
}
}
Desglose técnico
En el ejemplo anterior, observa cómo processor.process recibe un dynamic. Esto desactiva la comprobación estática, delegando la responsabilidad al programador.
Cuando ejecutamos if (data is String), el compilador realiza un análisis de flujo. Si la condición es verdadera, el tipo de data dentro de ese bloque se promociona de dynamic a String. Esto es vital para la eficiencia: el compilador no necesita insertar una comprobación de tipo extra cada vez que accedes a data.length.
En el Caso 3, es crucial notar la reificación de tipos en Dart. A diferencia de otros lenguajes donde la información de los genéricos se borra (type erasure) al compilar, en Dart List<String> mantiene su identidad. Por eso, data is List<String> funciona correctamente y distingue entre una List<String> y una List<int>. Sin embargo, runtimeType nos devuelve el objeto Type que representa la clase en memoria, lo cual es extremadamente útil para debugging pero debe evitarse en lógica de negocio compleja por la fragilidad que introduce.
El uso de data as int en el Caso 4 es una instrucción directa al runtime. No estamos preguntando si es un int, estamos ordenando que se comporte como tal. Si la comprobación interna de la VM falla, el flujo se interrumpe con un error que no se puede capturar para “continuar” de la misma forma que un error de lógica, sino que es un fallo de tipo en la integridad del programa.
El error frecuente
Un error común es intentar usar as para evitar la verbosidad de is, asumiendo que el tipo es el correcto solo porque “estamos en esa parte del código”.
void processPayload(dynamic payload) {
// ERROR: Si payload es null o no es un Map, esto lanza TypeError inmediatamente
final config = payload as Map<String, dynamic>;
print(config['key']);
}
Si payload llega como null o como una String, el programa fallará de forma abrupta. La práctica recomendada es siempre usar is para validar la estructura y permitir que la promoción de tipos trabaje a tu favor, dejando el as solo para cuando el tipo es una certeza matemática dentro de tu lógica de ejecución.
La seguridad de tipos en Dart depende de que confíes en el análisis de flujo del compilador y no en la fuerza bruta del casting manual.
N° 19