📌 Funcións

En Dart, as funcións poden:

• Asignarse a variables.
• Pasarse como argumentos.
• Ser devoltas desde outras funcións.

Incluso podes facer que unha clase actúe como función implementando o método call().

✅ Declaracións básicas

Unha función pode definirse de varias formas.

• A máis común é usar a palabra clave tipo nome(parámetros)
• Tamén se pode omitir o tipo de retorno no caso de que se poda inferir.

A seguinte función comproba se un elemento está nunha lista:

bool contenElemento(List<String> lista, String elemento) {
  return lista.contains(elemento);
}

Tamén se pode definir omitindo o tipo de retorno (Dart dedúceo automaticamente):

contenElemento(lista, elemento) {
  return lista.contains(elemento);
}

Ambas versións fan o mesmo: devolven true se o elemento está na lista, e false se non está.

🧪 Exemplo de uso:

void main() {
  var froitas = ['mazá', 'laranxa', 'plátano'];

  print(contenElemento(froitas, 'mazá'));      // true
  print(contenElemento(froitas, 'sandía'));    // false
}

📌 Nota: Aínda que Dart permite omitir o tipo de retorno, é boa práctica poñelo cando sexa posible para facer o código máis claro.

✅ Sintaxe abreviada

Dart permite definir funcións dunha soa liña usando unha sintaxe abreviada empregando o operador =>.

Esta sintaxe é útil cando a función só devolve unha expresión simple.

Forma tradicional:

int dobrar(int numero) {
  return numero * 2;
}

Forma abreviada:

int dobrar(int numero) => numero * 2;

As dúas versións fan exactamente o mesmo: multiplican o número por 2 e devolven o resultado.

🧪 Exemplo de uso:

void main() {
  print(dobrar(3)); // 6
  print(dobrar(10)); // 20
}

📌 Nota importante:

• Só se pode usar esta sintaxe con unha única expresión que devolve un valor.
• Non se pode usar se a función leva máis dunha liña ou necesita condicións, bucles, etc.

❌ Non permitido:

// Isto non funciona:
int exemplo(int numero) => if (numero > 0) numero * 2;

✅ Solución correcta:

int exemplo(int numero) => numero > 0 ? numero * 2 : 0;

Neste último caso usamos unha expresión condicional (operador ternario), que si está permitida porque é unha única expresión que devolve valor.

📌 Tipos de parámetros

Cando definimos unha función podemos pasarlle valores (parámetros). Hai tres tipos principais:

• Parámetros obrigatorios
• Parámetros nomeados
• Parámetros opcionais

✅ 1. Parámetros obrigatorios

Son os típicos: debes pasalos na orde correcta e sempre.

void saudar(String nome, String apelido) {
  print('Ola $nome $apelido!');
}

saudar('Diego', 'Rodicio'); // ✅ Correcto
saudar('Diego'); // ❌ Erro: falta o segundo parámetro

✅ 2. Parámetros nomeados

Permiten indicar o nome do parámetro cando chamas á función. Son opcionais (por defecto), pero podes facer que sexan obrigatorios usando required.

Usa {parametro1, parametro2, …} para especificar parámetros nomeados. Se non lles asignas un valor por defecto nin os marcas como required, o seu valor por defecto será null.

void saudar({String? nome, String? apelido}) {
  print('Ola $nome $apelido!');
}

// Chamadas á función usando o nome dos parámetros:

saudar(nome: 'Diego', apelido: 'Rodicio');   // ✅ Ola Diego Rodicio
saudar(apelido: 'Rodicio', nome: 'Diego');   // ✅ Ola Diego Rodicio (a orde non importa)
saudar(nome: 'Diego');                       // ✅ Ola Diego null
saudar();                                    // ✅ Ola null null

📌 Neste exemplo:

• Usamos {} para definir parámetros nomeados.
• Podemos chamar á función indicando os nomes dos parámetros (nome:, apelido:).
• A orde non importa, porque están nomeados.
• Son opcionais, así que podes omitir un ou todos, e o seu valor será null se non se especifica.

💡 Se queres obrigar a pasar algún deles, podes usar required:

void saudar({required String nome, String? apelido}) {
  print('Ola $nome $apelido!');
}

saudar(); // ❌ Erro: falta o parámetro obrigatorio 'nome'

📌 En Flutter é moi común usar só parámetros nomeados, porque así se entende mellor o que representa cada valor.

✅ Valores por defecto en parámetros nomeados

Cando defines unha función con parámetros nomeados, podes indicar un valor por defecto. Isto significa que, se non se lle pasa ese valor cando se chama á función, Dart usará automaticamente o valor indicado.

📌 Sintaxe:

void mostrarMensaxe({String texto = 'Ola mundo'}) {
  print(texto);
}
mostrarMensaxe(); // Imprime: Ola mundo
mostrarMensaxe(texto: 'Bo día!'); // Imprime: Bo día!

📌 Importante: O valor por defecto ten que ser unha constante, é dicir, algo que xa se poida calcular en tempo de compilación (números, cadeas, booleanos, listas ou mapas constantes…).

❌ Non permitido:

// Isto dá erro porque DateTime.now() non é constante:
void exemplo({DateTime data = DateTime.now()}) { ... }

✅ Permitido:

void exemplo({int intentos = 3}) { ... }

✅ 3. Parámetros opcionais

Son como os obrigatorios, pero opcionais e colócanse entre corchetes.

void saudar(String nome, [String? apelido]) {
  if (apelido != null) {
    print('Ola $nome $apelido!');
  } else {
    print('Ola $nome!');
  }
}

saudar('Diego'); // Ola Diego!
saudar('Diego', 'Rodicio'); // Ola Diego Rodicio!

🚫 Non se poden mesturar [] e {} na mesma función

Este código non está permitido:

// ❌ Non válido
void exemplo(String nome, [int? idade], {bool? activo}) {
  // ...
}

📌 Dart non permite mesturar os dous tipos opcionais ([] e {}) nunha mesma definición de función.

✅ Entón… como se pode combinar?

Só se poden combinar:

• Parámetros posicionais obrigatorios
• E despois un tipo de parámetros opcionais: ou [], ou {}, pero non ambos.

// Válido: obrigatorio + nomeados
void exemplo(String nome, {int? idade, bool? activo}) {
  // ...
}

// Válido: obrigatorio + posicionais opcionais
void exemplo2(String nome, [int? idade, bool? activo]) {
  // ...
}

🧠 Resumo visual

📌 Función main()

En Dart, toda aplicación debe comezar cunha función chamada main(). Esta función é o punto de entrada do programa: é o primeiro que se executa cando lanzas a app.

✅ Forma básica

A forma máis sinxela da función main() non leva argumentos:

void main() {
  print('Ola, mundo!');
}

✅ Con argumentos

Tamén podes definir a función main() con un parámetro: unha lista de cadeas (List<String>), que recibe os argumentos da liña de comandos.

void main(List<String> argumentos) {
  print(argumentos);
}

💡 Isto é útil en programas de consola que aceptan valores ao executarse.

🧪 Exemplo:

void main(List<String> argumentos) {
  if (argumentos.isEmpty) {
    print('Non se pasou ningún argumento.');
  } else {
    print('Argumentos recibidos:');
    for (var argumento in argumentos) {
      print('- $argumento');
    }
  }
}

Se executas este programa con:

dart run programa.dart Maceda Ourense

A saída sería:

Argumentos recibidos:
- Maceda
- Ourense

📌 Funcións como obxectos

En Dart, as funcións son obxectos. Isto significa que se poden:

• Gardar en variables.
• Pasar como argumentos a outras funcións.
• Devolver desde outras funcións.

✅ 1. Pasar unha función como parámetro

A función forEach aplica outra función a cada elemento dunha lista. Podemos pasar unha función xa definida como parámetro:

void imprimirElemento(int elemento) {
  print(elemento);
}

void main() {
  var numeros = [1, 2, 3];
  numeros.forEach(imprimirElemento); // Pásase a función sen parénteses
}

📌 Fíxate en que non se chama á función, simplemente se pasa como obxecto (imprimirElemento, non imprimirElemento()).

✅ 2. Gardar unha función nunha variable

Podemos asignar unha función anónima (ou lambda) a unha variable e usala máis tarde:

var exclamativa = (String mensaxe) => '!!! ${mensaxe.toUpperCase()} !!!';

void main() {
  print(exclamativa('ola')); // !!! OLA !!!
}

Neste exemplo:

• A variable exclamativa contén unha función.
• Podemos chamala como se fose unha función normal.

✅ 3. Devolver unha función desde outra

Unha función tamén pode devolver outra función:

Function crearSaudo(String prefixo) {
  return (String nome) => '$prefixo $nome!';
}

void main() {
  var saudar = crearSaudo('Bo día');
  print(saudar('María')); // Bo día María!
}

🧠 Resumo

📌 Closures (tamén chamados funcións anónimas ou lambda)

En Dart, é posible crear funcións sen nome, chamadas de varios modos:

• Funcións anónimas
• Lambdas
• Closures

Son moi útiles para pasar funcións como argumentos ou usalas temporalmente.

✅ Estrutura dun closure

Unha función anónima defínese así:

(parámetros) {
  // corpo da función
}

Tamén pode escribirse en forma abreviada:

(parámetros) => expresión;

🧪 Exemplo práctico: converter elementos dunha lista

A función map() é un método dispoñible nas listas (List) e noutros obxectos iterables. Serve para transformar os elementos dunha lista, devolvendo unha nova secuencia cos resultados.

A función map:

• Argumento: recibe unha función (normal ou anónima).
• Esa función aplícase a cada elemento da lista orixinal.
• O resultado é un Iterable (unha especie de lista), que normalmente convertimos cun .toList().

const froitas = ['mazás', 'plátanos', 'laranxas'];

// Usamos unha función anónima dentro de map()
var enMaiusculas = froitas.map((elemento) {
  return elemento.toUpperCase();
}).toList();

// Mostramos cada froita e a súa lonxitude
enMaiusculas.forEach((f) => print('$f: ${f.length}'));

✅ Que fai cada parte?

1. froitas.map(...): percorre cada elemento da lista froitas.
2. (elemento) { return elemento.toUpperCase(); }: converte a froita a maiúsculas.
3. .toList(): converte o resultado nunha lista.
4. forEach(...): percorre a nova lista para imprimir o resultado.

🎯 Resultado deste exemplo:

MAZÁS: 5
PLÁTANOS: 8
LARANXAS: 8

🧠 Resumo

📌 map() non modifica a lista orixinal. Crea unha nova.

✅ Outro exemplo: duplicar números

var numeros = [1, 2, 3, 4];
var dobrados = numeros.map((n) => n * 2).toList();

print(dobrados); // [2, 4, 6, 8]

✅ Exemplo simple: sumar números

var sumar = (int a, int b) {
  return a + b;
};

print(sumar(3, 4)); // 7

Aquí sumar é unha variable que contén unha función anónima.

✅ Exemplo con sintaxe abreviada

var dobrar = (int n) => n * 2;

print(dobrar(5)); // 10

✅ Exemplo sen parámetros

Tamén podes ter funcións anónimas sen parámetros:

var saudo = () => print('Bo día!');
saudo(); // Bo día!

✅ Exemplo como callback

List<int> numeros = [1, 2, 3, 4];

numeros.forEach((n) {
  print('Número: $n');
});

📌 Valores de retorno

En Dart, todas as funcións devolven un valor. Se non especificas nada, Dart devolve null por defecto.

✅ Devolver un valor simple

int sumar(int a, int b) {
  return a + b;
}

void main() {
  var resultado = sumar(3, 5);
  print(resultado); // 8
}

A función sumar() devolve un número enteiro (int). O tipo vai antes do nome da función.

✅ Se non poñemos return

void saudar(String nome) {
  print('Ola $nome');
}

void main() {
  var resultado = saudar('Ana');
  print(resultado); // null
}

📌 Como a función saudar non devolve nada, Dart devolve null automaticamente.

📌 Devolver varios valores

En Dart, non se poden devolver varios valores separados, pero podemos usar un rexistro (record) para empaquetalos nun único valor.

✅ Exemplo:

(String, int) obterNomeEIdade() {
  return ('Lucía', 17);
}

void main() {
  var (nome, idade) = obterNomeEIdade();
  print('Nome: $nome');
  print('Idade: $idade');
}

Neste exemplo:

• A función devolve un rexistro con dúas posicións: unha String e un int.
• Podemos desempaquetar o resultado usando var (nome, idade).

✅ Outro exemplo: devolver lista ou mapa

Tamén se poden devolver outros tipos de datos compostos:

List<int> primeirosTres() {
  return [1, 2, 3];
}

Map<String, dynamic> usuario() {
  return {
    'nome': 'Xoán',
    'idade': 20,
  };
}

✅ Función que non devolve nada (void)

void mostrarMensaxe() {
  print('Ola!');
}

📌 As funcións void non retornan nada (ou implicitamente retornan null).

🧠 Resumo

📌 A maiores…Xeradores

Un xerador é un tipo especial de función que xera elementos un a un, en lugar de devolvelos todos á vez.

Son útiles cando:

• A lista é moi longa ou infinita.
• Non queremos calcular todos os valores de golpe.
• Queremos aforrar memoria e recursos.

En Dart, úsanse coas palabras clave:

• sync* → para funcións normais (síncronas).
• async* → para funcións asíncronas (con await).
• yield → para devolver valores un a un.
• yield* → para delegar nun outro xerador.

✅ Xerador síncrono

Un xerador síncrono devolve un Iterable, é dicir, unha lista que se pode percorrer cun bucle for.

Iterable<int> naturaisAta(int n) sync* {
  int k = 0;
  while (k < n) {
    yield k;
    k++;
  }
}

void main() {
  for (var numero in naturaisAta(5)) {
    print(numero);
  }
}
// Saída: 0 1 2 3 4

📌 Aquí yield funciona coma un return, pero permite seguir desde onde quedou.

✅ Xerador asíncrono

Un xerador asíncrono devolve un Stream, útil cando os datos chegan pouco a pouco (como por rede).

Stream<int> naturaisAsincronosAta(int n) async* {
  int k = 0;
  while (k < n) {
    yield k;
    await Future.delayed(Duration(seconds: 1)); // espera 1 segundo
    k++;
  }
}

void main() async {
  await for (var numero in naturaisAsincronosAta(3)) {
    print(numero);
  }
}
// Saída: imprime un número por segundo

✅ Xerador recursivo

Tamén podes chamar a outro xerador dentro dun xerador, usando yield*.

Iterable<int> naturaisDescendentes(int n) sync* {
  if (n > 0) {
    yield n;
    yield* naturaisDescendentes(n - 1);
  }
}

void main() {
  for (var n in naturaisDescendentes(3)) {
    print(n);
  }
}
// Saída: 3 2 1

🧠 Resumo

Exemplos

🔗 Ver o código en DartPad