# High Order Functions en Dart
Dart es un lenguaje orientado a objetos, pero tiene fuertes características funcionales. Una de las más importantes es que las funciones son **ciudadanos de primera clase** (first-class citizens).
Esto significa que las funciones pueden ser:
1. Asignadas a variables.
2. Pasadas como argumentos a otras funciones.
3. Retornadas por otras funciones.
Una **High Order Function** (Función de Orden Superior) es una función que hace al menos una de las siguientes cosas:
- Recibe una o más funciones como argumentos.
- Devuelve una función como resultado.
## Funciones como Argumentos
El ejemplo más común son los métodos de `List` o `Iterable`.
```dart
void main() {
final numbers = [1, 2, 3, 4, 5];
// 'map' es una High Order Function
// Recibe una función anónima (n) => n * 2
final doubled = numbers.map((n) => n * 2);
// 'where' recibe una función que devuelve bool
final evens = numbers.where((n) => n.isEven);
// 'forEach' recibe una función void
numbers.forEach(print); // Pasamos la función 'print' directamente
}
```
## Creando tus propias High Order Functions
```dart
// Definimos un tipo para la función callback
typedef MathOperation = int Function(int, int);
// Función que recibe otra función
void executeOperation(int a, int b, MathOperation operation) {
final result = operation(a, b);
print('El resultado es: $result');
}
int add(int a, int b) => a + b;
int multiply(int a, int b) => a * b;
void main() {
// Pasamos funciones nombradas
executeOperation(5, 3, add); // 8
executeOperation(5, 3, multiply); // 15
// Pasamos función anónima
executeOperation(10, 2, (a, b) => a - b); // 8
}
```
## Funciones que Retornan Funciones
Esto es útil para crear "fábricas" de funciones o configurar comportamientos.
```dart
// Devuelve una función que suma 'n'
int Function(int) makeAdder(int n) {
return (int i) => n + i;
}
void main() {
final addTwo = makeAdder(2);
final addTen = makeAdder(10);
print(addTwo(5)); // 7
print(addTen(5)); // 15
}
```
## Uso en Flutter
Flutter usa este patrón extensivamente, especialmente en `builders`.
```dart
class MyListView extends StatelessWidget {
@override
Widget build(BuildContext context) {
return ListView.builder(
itemCount: 100,
// itemBuilder es una función que Flutter llamará
// cuando necesite construir un item
itemBuilder: (context, index) {
return ListTile(title: Text('Item $index'));
},
);
}
}
```
O en callbacks de eventos:
```dart
ElevatedButton(
onPressed: () {
print('Button pressed');
},
child: Text('Click me'),
)
```
## Beneficios
1. **Abstracción:** Puedes abstraer *acciones*, no solo datos.
2. **Reutilización:** `map`, `filter`, `reduce` funcionan para cualquier tipo de dato gracias a que tú provees la lógica específica.
3. **Composición:** Puedes combinar funciones pequeñas para crear lógica compleja.
4. **Declarativo:** El código describe *qué* hacer, no *cómo* hacerlo (ej. `numbers.where((n) => n.isEven)` vs un loop `for` con `if`).
## Conclusión
Dominar las High Order Functions te permitirá escribir código Dart más limpio, conciso y "Flutter-idiomatic". Son la base de la programación reactiva y el manejo de eventos.
Este apartado profundiza en los conceptos clave, proporcionando ejemplos prácticos y mejores prácticas para su aplicación en proyectos reales.
Al comprender estos detalles, podrás diseñar soluciones más robustas, mantenibles y escalables en tus aplicaciones Flutter y Dart.