Dart typedef y tipos de función

typedef es el mecanismo de alias de tipo en Dart; te permite definir nombres cortos y legibles para tipos complejos.

Este capítulo presenta dos usos de typedef: el alias de tipo de función tradicional y el alias de tipo general introducido en Dart 3.0.


typedef: alias de tipo de función

Cuando un tipo de función se usa con frecuencia, typedef puede darle un nombre claro.

Esto es especialmente útil en escenarios como callbacks, manejadores de eventos, etc.

Ejemplo

// Definir un alias de tipo de función
// Representa: una función que recibe dos parámetros int y devuelve int
typedef IntOperation = int Function(int a, int b);

// Definir un tipo de callback
// Representa: una función que recibe un mensaje String y no devuelve valor
typedef MessageCallback = void Function(String message);

// Usar typedef como tipo de parámetro
int performOperation(int x, int y, IntOperation operation) {
  return operation(x, y);
}

void logMessage(String msg, MessageCallback callback) {
  print('Preparando para mostrar mensaje...');
  callback('[EJEMPLO] $msg');
}

void main() {
  // Pasar una función que coincida con la firma de IntOperation
  int add(int a, int b) => a + b;
  int multiply(int a, int b) => a * b;

  print('10 + 5 = ${performOperation(10, 5, add)}');
  print('10 × 5 = ${performOperation(10, 5, multiply)}');

  // También se puede pasar directamente una función anónima
  int result = performOperation(20, 4, (a, b) => a ~/ b);
  print('20 ÷ 4 = $result');

  // Usar MessageCallback
  logMessage('Operación completada', (msg) {
    print('Mensaje recibido: $msg');
  });
}
10 + 5 = 15
10 × 5 = 50
20 ÷ 4 = 5
准备输出消息...
收到消息: [EJEMPLO] 操作完成

Sin typedef, tendrías que repetir la firma de tipo de función en cada posición de parámetro.

Con typedef, las declaraciones de tipo se vuelven claras y uniformes, y solo necesitas modificar un lugar al cambiar.

typedef solo crea un alias para un tipo, no crea un tipo nuevo. IntOperation y int Function(int, int) son totalmente equivalentes en el sistema de tipos.


Tipos de función como parámetros

En Dart, las funciones son ciudadanas de primera clase (First-class Citizen) y pueden pasarse como valores ordinarios.

Ejemplo

// Declarar el parámetro usando el tipo de función directamente (sin usar typedef)
void processNumbers(
  List<int> numbers,
  bool Function(int) filter,
  String Function(int) formatter,
) {
  var filtered = numbers.where(filter);
  for (var n in filtered) {
    print(formatter(n));
  }
}

// Función de orden superior que devuelve una función
int Function(int) makeMultiplier(int factor) {
  // El cierre devuelto captura el factor
  return (int n) => n * factor;
}

void main() {
  var scores = [55, 78, 92, 60, 45, 88];

  print('--- Calificación aprobatoria ---');
  processNumbers(
    scores,
    (n) => n >= 60,                    // Condición de filtro
    (n) => 'Puntuación EJEMPLO: $n puntos',       // Formatear
  );

  print('--- Puntuación alta (> 80) ---');
  processNumbers(
    scores,
    (n) => n > 80,
    (n) => 'Alta puntuación: $n puntos',
  );

  // Función como valor de retorno
  var doubler = makeMultiplier(2);
  var tripler = makeMultiplier(3);
  print('5 × 2 = ${doubler(5)}');
  print('5 × 3 = ${tripler(5)}');
}
--- 及格分数 ---
EJEMPLO 分数: 78 分
EJEMPLO 分数: 92 分
EJEMPLO 分数: 60 分
EJEMPLO 分数: 88 分
--- 高分(> 80)---
高分: 92 分
高分: 88 分
5 × 2 = 10
5 × 3 = 15

Patrón de callback

El patrón de callback es el escenario de aplicación más común para los tipos de función.

Otorga al llamador el control de "qué hacer", haciendo que el código sea más flexible y reutilizable.

Ejemplo

// Definir un tipo de callback
typedef ResultCallback<T> = void Function(T result);
typedef ErrorCallback = void Function(String error);

// Simular una operación asíncrona
void fetchUserData(
  String userId, {
  required ResultCallback<Map<String, dynamic>> onSuccess,
  required ErrorCallback onError,
}) {
  // Simular una solicitud de red
  print('Obteniendo datos del usuario...');

  // Simular éxito/fracaso
  if (userId == 'ejemplo') {
    var data = {
      'id': 'ejemplo',
      'name': 'Usuario EJEMPLO',
      'level': 'VIP',
    };
    onSuccess(data);
  } else {
    onError('El usuario $userId no existe');
  }
}

void main() {
  // Usar callback para manejar el resultado
  fetchUserData(
    'ejemplo',
    onSuccess: (data) {
      print('¡Obtención exitosa!');
      print('Nombre de usuario: ${data['name']}');
      print('Nivel: ${data['level']}');
    },
    onError: (error) {
      print('Error al obtener: $error');
    },
  );

  print('---');

  // Probar el caso de fallo
  fetchUserData(
    'unknown',
    onSuccess: (data) {
      print('Obtención exitosa');
    },
    onError: (error) {
      print('Error al obtener: $error');
    },
  );
}
正在获取用户数据...
获取成功!
用户名: EJEMPLO 用户
等级: VIP
---
正在获取用户数据...
获取失败: 用户 unknown 不存在

Escenarios de aplicación comunes del patrón de callback:

EscenarioEjemplo de tipo de callback
Solicitud de redonSuccess(data) / onError(error)
Eventos de UIonTap() / onLongPress()
Transformación de datosCallbacks en map(), where(), reduce()
TemporizadorTimer(callback, duration)
Animación completadaonComplete()

Aunque el patrón de callback es flexible, puede llevar al "infierno de callbacks" al manejar múltiples operaciones asíncronas anidadas. Dart proporciona async/await para manejar flujos asíncronos de manera más elegante; lo presentaremos en detalle en el capítulo 17.


Dart 3.0: alias de tipo general

Dart 3.0 amplía las capacidades de typedef; ahora puedes crear alias para cualquier tipo, no solo tipos de función.

Ejemplo

// Dart 3.0: typedef puede crear alias para cualquier tipo

// Alias para tipos de colección complejos
typedef JsonMap = Map<String, dynamic>;
typedef UserList = List<Map<String, dynamic>>;

// Alias genérico
typedef Result<T> = ({T data, String? error});

// Alias de tipo de función (uso tradicional)
typedef Validator<T> = String? Function(T value);

// Usar alias de tipo
void processJson(JsonMap json) {
  print('Procesando JSON: $json');
  print('Número de claves: ${json.length}');
}

void validateAndPrint<T>(T value, Validator<T> validator) {
  var error = validator(value);
  if (error != null) {
    print('Validación fallida: $error');
  } else {
    print('Validación exitosa: $value');
  }
}

void main() {
  // Usar el alias JsonMap
  JsonMap userData = {
    'name': 'ejemplo',
    'age': 10,
    'isVip': true,
  };
  processJson(userData);

  // Usar el alias Result
  Result<String> successResult = (data: 'Operación exitosa', error: null);
  Result<String> errorResult = (data: '', error: 'Tiempo de espera de conexión de red agotado');
  print('Éxito: ${successResult.data}');
  print('Fallo: ${errorResult.error}');

  // Usar Validator genérico
  Validator<String> nameValidator = (value) {
    if (value.isEmpty) return 'El nombre no puede estar vacío';
    if (value.length < 3) return 'El nombre debe tener al menos 3 caracteres';
    return null;  // null indica que la validación es exitosa
  };

  validateAndPrint('EJEMPLO', nameValidator);
  validateAndPrint('AB', nameValidator);
}
处理 JSON: {name: ejemplo, age: 10, isVip: true}
键的数量: 3
Éxito: 操作成功
失败: 网络连接超时
验证通过: EJEMPLO
验证失败: 名称至少 3 个字符

Los alias de tipo de Dart 3.0 reducen considerablemente las declaraciones de tipo largas, haciendo que el código sea más conciso y legible.

Los alias de tipo (typedef) y el tipo en sí son completamente equivalentes en tiempo de ejecución; son solo "apodos" en tiempo de compilación. Esto significa que no puedes usar typedef para distinguir dos tipos con la misma estructura pero semántica diferente: se considerarán el mismo tipo.

Otras extensiones