📌 También es conocida como flecha gorda (=>), se caracteriza por tener al lado derecho una expresión.
Bienvenida e Introducción
Introducción y Bienvenida
Dart vs. Go vs. JavaScript vs. Kotlin
DartPad y qué editores utlizar
Básicos 1: Variables y Operadores
Variables: Números (int,double), String y booleanos
Colecciones
Diccionarios
Constantes (final y const)
Operadores aritméticos, de asignacion y lógicos
Básicos 2: Funciones y Parámetros
Declaración de funciones y la función Main()
Funciones de sintaxis corta (Arrow) y Anónimas (Lambda)
Parámetros requeridos, opcionales, posicionados, nombrados y por defecto
Básicos 3: Flujos de Control
If-Else y Expresiones Condicionales
Switch y Case
For
While y do-while
Break y Continue
Clases
Definición de clases y miembros
Constructores por defecto, por parámetro o nombrados
Métodos Getter y Setter y variables privadas
Herencia
Clases Abstractas
Interfaces implícitas
Utilizar Flutter en Dart
Iniciar y estructurar un proyecto en Flutter
Contenedores
Creando un botón personalizado con el Widget Container
Modelos de datos y peticiones http
Trabajando datos http y Widget Future Builder
Ejecutando el mismo código en Android y iOS
Conclusiones
Dart en el futuro
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
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
📌 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?
Las funciones arrow simplifican un monton el desarrollo.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?