El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Funciones Anónimas

Siguiente ►
►

Las funciones anónimas, también conocidas como funciones lambda, son funciones que no tienen un nombre explícito. En Scala, las funciones anónimas son una característica poderosa que permite escribir código más conciso y expresivo. En esta sección, aprenderemos cómo definir y utilizar funciones anónimas en Scala.

Conceptos Clave

  1. Definición de Funciones Anónimas: Cómo declarar y utilizar funciones anónimas.
  2. Sintaxis de Funciones Anónimas: La estructura y sintaxis de las funciones anónimas en Scala.
  3. Uso de Funciones Anónimas: Ejemplos prácticos de cómo y cuándo usar funciones anónimas.
  4. Funciones Anónimas y Funciones de Orden Superior: Cómo las funciones anónimas se integran con las funciones de orden superior.

Definición de Funciones Anónimas

Una función anónima en Scala se define utilizando la sintaxis =>. La parte izquierda del => contiene los parámetros de la función, y la parte derecha contiene el cuerpo de la función.

Ejemplo Básico

val suma = (a: Int, b: Int) => a + b
println(suma(3, 4))  // Salida: 7

En este ejemplo:

  • (a: Int, b: Int) son los parámetros de la función.
  • => es el operador que separa los parámetros del cuerpo de la función.
  • a + b es el cuerpo de la función.

Sintaxis de Funciones Anónimas

La sintaxis de las funciones anónimas puede variar dependiendo del contexto y de la cantidad de parámetros. Aquí hay algunas variaciones comunes:

Función Anónima sin Parámetros

val saludo = () => "Hola, Mundo!"
println(saludo())  // Salida: Hola, Mundo!

Función Anónima con un Solo Parámetro

val cuadrado = (x: Int) => x * x
println(cuadrado(5))  // Salida: 25

Función Anónima con Múltiples Parámetros

val multiplicar = (x: Int, y: Int) => x * y
println(multiplicar(3, 4))  // Salida: 12

Función Anónima con Tipos Inferidos

Scala puede inferir los tipos de los parámetros en muchos casos, lo que permite una sintaxis más concisa:

val suma = (a: Int, b: Int) => a + b
val sumaInferida = (a, b) => a + b  // Tipos inferidos
println(sumaInferida(3, 4))  // Salida: 7

Uso de Funciones Anónimas

Las funciones anónimas son especialmente útiles cuando se utilizan con funciones de orden superior, como map, filter y reduce.

Ejemplo con map

val numeros = List(1, 2, 3, 4, 5)
val cuadrados = numeros.map(x => x * x)
println(cuadrados)  // Salida: List(1, 4, 9, 16, 25)

Ejemplo con filter

val numeros = List(1, 2, 3, 4, 5)
val pares = numeros.filter(x => x % 2 == 0)
println(pares)  // Salida: List(2, 4)

Ejemplo con reduce

val numeros = List(1, 2, 3, 4, 5)
val sumaTotal = numeros.reduce((a, b) => a + b)
println(sumaTotal)  // Salida: 15

Ejercicios Prácticos

Ejercicio 1: Filtrar Números Impares

Escribe una función anónima que filtre los números impares de una lista.

val numeros = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val impares = numeros.filter(x => x % 2 != 0)
println(impares)  // Salida esperada: List(1, 3, 5, 7, 9)

Ejercicio 2: Calcular Factoriales

Escribe una función anónima que calcule el factorial de un número dado.

val factorial = (n: Int) => (1 to n).product
println(factorial(5))  // Salida esperada: 120

Ejercicio 3: Convertir a Mayúsculas

Escribe una función anónima que convierta una lista de cadenas a mayúsculas.

val palabras = List("scala", "es", "genial")
val mayusculas = palabras.map(_.toUpperCase)
println(mayusculas)  // Salida esperada: List("SCALA", "ES", "GENIAL")

Soluciones

Solución al Ejercicio 1

val numeros = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val impares = numeros.filter(x => x % 2 != 0)
println(impares)  // Salida: List(1, 3, 5, 7, 9)

Solución al Ejercicio 2

val factorial = (n: Int) => (1 to n).product
println(factorial(5))  // Salida: 120

Solución al Ejercicio 3

val palabras = List("scala", "es", "genial")
val mayusculas = palabras.map(_.toUpperCase)
println(mayusculas)  // Salida: List("SCALA", "ES", "GENIAL")

Conclusión

En esta sección, hemos aprendido sobre las funciones anónimas en Scala, su sintaxis y cómo utilizarlas en diferentes contextos. Las funciones anónimas son una herramienta poderosa que permite escribir código más conciso y expresivo, especialmente cuando se combinan con funciones de orden superior. En la próxima sección, exploraremos más sobre las colecciones y estructuras de datos en Scala.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados