No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Dart

Curso de Dart

Argel Franco Bejarano de la Cruz

Argel Franco Bejarano de la Cruz

Funciones de sintaxis corta (Arrow) y Anónimas (Lambda)

10/29
Recursos

Las funciones de sintaxis corta (Arrow) son declaradas en la misma línea y sólo pueden tener una expresión, misma que se declara después de una flecha (=>), por ejemplo:

void functionName(int a, int b) => a + b;

Las funciones anónimas, también conocidas como lambda o closures son similares a las nombradas pero con la diferencia de que no llevan nombre y suelen utilizarse para realizar una acción dentro de otro proceso, por ejemplo:

List list=["Rojo","Rosa","Verde"];
  list.forEach((val){
    print(val);
  });
}

Aportes 43

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

📌 También es conocida como flecha gorda (=>), se caracteriza por tener al lado derecho una expresión.

list.forEach((item) {
    print('${list.indexOf(item)}: $item');
  });```

Otra manera de usar el forEach 😄:

main(List<String> args) {
  List<String> letters = [ 'Ella', 'no','te', 'ama'];
  // Usando arrow function en un foreach
  letters.forEach((letter) => print(letter));
}

RESUMEN DE LA CLASE

Funciones Arrow y Anónimas

Arrow (también conocida como fat arrow): Se utiliza cuando la función tiene una sola línea de código. No se permiten llaves ni la palabra return. Ejemplo:

void functionArrow(int a, int b) => print("El resultado será ${a+b}");

//Si a la función le asignamos un tipo, la sentencia debe ser el retorno, así:

int sumar(int a, int b) => a + b;

Anónimas (también conocidas como lambda o closures): Poseen cero o más parámetros separados por comas. Se suelen utilizar al momento de recorrer colecciones. Ejemplo:

//Utilizando el método forEach que posee cada objeto lista al ser creado, recorremos la misma:

List lista = [1, 2, 3];

lista.forEach((val){
  print(val);
});

Código de la clase comentado:

// Clase sobre funciones arrow y funciones anónimas.

main(List<String> args) {
  
  String nombre = 'Bruce', apellido = 'Wayne';
  print("Soy Batman, y mi verdadera identidad es " + nombreCompleto(nombre, apellido));

  List colores = ['Amarillo', 'Azul', 'Rojo'];
  List personas = ['Logan', 'Clark', 'Barry'];

  // * Las funciones anónimas son aquellas que son creadas sin darles un nombre,
// * También son conocidas como lambda o closures.

//  ! Aunque una función anónima se ve muy similar a una función nombrada,
// ! Se puede ver de la siguiente forma:
// ? ([[Tipo] param1[, ...]]){ //Bloque de código};

  // ! For each es una función encargada de iterar por cada valor de una lista.
  // ! Recibe como parámetro una función, a la cual se le pasa un "nombre o clave", cual usaremos para referirnos a la variable iterada
  // ! Por lo tanto, es un gran ejemplo para utilizar una función anónima.
  colores.forEach( (color){ 
    print("$color es un color muy bonito para una bandera!");
  } );

  personas.forEach( (persona){ 
    if(persona == 'Logan'){
      print("Soy Wolverine");
    }
    if(persona == 'Clark'){
      print("Soy Superman");
    }
    if(persona == 'Barry'){
      print("Soy Flash");
    }
  } );

}

// * Las funciones arrow llevan este nombre por el símbolo usado para denotarlas,
  // * cual es => , estas son usadas para hacer uso de una función en la cual solo se utiliza una linea.
void funcionFlecha(nombre) => print("Hola $nombre, nos volvemos a encontrar!");

// ! Aunque se usan igual que las funciones anteriormente vistas, tienen reglas:
// ? No usar llaves {} ni la palabra [return].
// ? Entre el => y el ; solo puede haber una expresión.
String nombreCompleto(nombre, apellido) => nombre + " " + apellido;

código de funciones Anónimas

Yo confundía las funciones Arrow con las expresiones lambda. Qué bueno saber esto.

Algunas funciones pueden aceptar una referencia a una función como parámetro. A veces, se hace referencia a ellas como “inyecciones de dependencia” o “devoluciones de llamada”, ya que permite que la función de su llamada “devuelva la llamada” a su código, lo que le da la oportunidad de cambiar la forma en que se comporta la función llamada. Por ejemplo, la función de mapa del objeto Array le permite iterar sobre cada elemento de una matriz, luego construir una nueva matriz aplicando una función de transformación a cada elemento.

viva JAVASCRIPT

reglas para funciones Arrow y Anónimas

Estructura de las funciones Arrow

Estructura de las funciones Anónimas

Código de una función Arrow

Uso de funciones Anónimas y funciones Arrow

Genial! Aunque no me quedo claro lo de las anónimas

Veo que es similar a las arrow function de javascript

Encontre esta documentacion que te puede servir como un apunte
Saludos!

Tambien se puede implementar un arrow function como funcion anonima… ejemplo

list.forEach((value)=>print(value))
void main() {
  funcionArrow(2,4);
  
  var resultado = funcionArrowRetorno(4,56);
  print(resultado);
  
  //FUNCION ANONIMA
  List list = ['Rojo','Azul','Rosa'];
  list.forEach((val){
    print(val);
  });
  
  
  list.forEach((color){
    if (color == 'Azul'){
      print('Mi color favorito es ${color}');
    }  
  });
  
  list.forEach((var item) {
    print('${list.indexOf(item)}: $item');
  });
}

void funcionArrow(int a, int b) => print('el resultado es ${a+b}');

funcionArrowRetorno(int a, int b) => a+b;

genial

Para los que vienen de JavaScript en ES6 es casi igual.

Solo me pasa a mí o es que no se oye bien???

Woow, siento que se me va a explotar la cabeza. Genial curso

Arrow y Lambda, interesante.

Primera vez que escucho sobre las funciones , no pensaba que podrian ser tan utiles

void main(List <String> arguments) {
  int result = myArrow(3,5);
  print(result);

  List<String> myList;
  myList = ['Dato1','Dato2','Dato3'];

  myList.forEach((val){
    if(val.isNotEmpty){
      print(val);
      val = "${val} funciona";
      print (val);
    }
  });

}

int myArrow(int a, int b) => a+b;```

No entendí lo de las funciones anónimas

muy interesante y simple de entender

import 'package:dart/dart.dart' as dart;

main(List<String> arguments) {
  print(functionArrowReturn(3, 5));
}

int functionArrowReturn (int a, int b) => a + b;```



** //Funcion anonima**
nombres.forEach((item){
if(item == ‘Rojo’){
print(item);
}
});

//Arrow Function without return value
void functionArrow(int a, int b) => print(a+b);

//Arrow Function with return value
int functionArrow2(int a, int b) => (a+b);

int suma(int a, int b){
  return a+b;
}
int suma(int a, int b)=>a+b;

Estas dos funciones son equivalentes

Al igual que en Kotlin y Javascript las funciones anónimas agilizan mucho el trabajo.

Seria de en que mas se utilizan las funciones arrow, aunque las habia visto mucho y utilizado en diferentes lenguajes nose si tendran el mismo concepto que en c# por ejemplo

main(List<String> arguments) {  
 
 print('El resultado de la suma es: ${sumaDosNumero(1,15)}'); 
  
 List paises=['Ecuador','Colombia','Peru'];
  
  paises.forEach((pais){
    print(pais);
  });
}

sumaDosNumero(int a , int b) => a+b;

result:

El resultado de la suma es: 16
Ecuador
Colombia
Peru

//Arrow solo podra ser utilizada en una funcion que utilice una sola linea
//Se les llama asi por que tiene una figura como =>
//No se usan llaves ni la palabra return

//Anonimas son similares a las funciones nombradas pero se pueden crear con una estructura diferente
//Se utilizan al momento de recorrer list, set, map

main(List<String> args) {
  funcionArrow(5, 5);
  
  int result = funcionArrowRetorno(5, 8);
  print(result);

  List list = ['rojo','azul','rosa'];

  //Recorrer una lista
  //Funcion anonima
  list.forEach((color) { 
    print(color);
  });
}

void funcionArrow (int a, int b) => print('El resultado sera ${a + b}');

int funcionArrowRetorno (int a, int b) => a + b;

Había trabajado antes las Arrow Functions en Javascript, y me parecían un modo muy particular y práctico para resumir código y hacerlo más legible (aunque al inicio la primera vez que vi esa sintaxis me causó pánico jajaja).
Con Dart me gusta mucho más llamando las funciones desde nuestra querida main.

¿Cómo se puede reutilizar una función anónima?

// Funciones Arrow y Anónimas

main(List<String> arguments){
funcionArrow(3, 5);
}

void funcionArrow(int a, int b) => print(‘el resultado sera ${a + b}’); {

}

// para el retorno

int funcionArrowRetorno (int a, int b) => a + b; {}

y en el main

var result = funcionArrowRetorno (3, 5);
print (result);

// funciones anónimas, vamos a hacer esto con una List

main(List<String> arguments){
funcionArrow(3, 5);

var result = funcionArrowRetorno(3, 5);
print(result);

List list = [‘Rojo’, ‘Azul’, ‘Rosa’];
list.forEach((val){
print (val);
});
} Salida: Rojo Azul Rosa

o bien podemos igualar

list.forEach(val){
if (val == ‘Rojo’){
print(val);
}
});

void workingWithAnonymousFunction()
{
  List<String> list = ['Rojo', 'Azul', 'Rosa'];
  list.forEach((c){
    print('color: ${c}');
  });

  List<int> numeros = [1, 2, 4, 6, 7, 9, 29, 11];
  numeros.forEach((numero){
    if(numero > 5)
      {
        print(numero);
      }
  });
}```
//funciones
main(List<String> args) {

funcionArrow(3, 5);

var resultado =funcionArrowRetorno(3, 5);
print(resultado);

List list = ['Rojo','azul','Verde'];

list.forEach((val) {
 print(val);
});

}

void funcionArrow(int a ,int b) => print('El resultado sera  ${a+b}');

int funcionArrowRetorno(int a, int b) => a + b;```

En mi opinion personal encuentro el forEach util en un 20%, yo prefiero usar el for normal.

List list =[“rojo”,“azul”,“rosa”];

for(int i=0;i<list.length;i++){
print(“Estamos en el color ${list[i]}”);
}

lo encuentro más util, pero claro cada programador es un mundo diferente, salu2

El primer ejemplo de la descripción está mal, debería ser int en vez de void, no?

¿Soy el único al que le choca la falta de ortografía?

  • será.
  • Anónimas.
    Lo digo es porque siendo profesor, debería tener esto en cuenta.

Las funciones arrow simplifican un monton el desarrollo.