Funciones como valores
Funciones de primera clase
Funciones como valores es una lección gratuita de Scala for Backend Engineering & Functional Programming en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Scala for Backend Engineering & Functional Programming, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
Las funciones son valores
En Scala, las funciones son valores de primera clase. Puede almacenarlas en variables, pasarlas como argumentos y devolverlas desde otras funciones, igual que los números o las cadenas.
object Main {
def main(args: Array[String]): Unit = {
val increment: Int => Int = x => x + 1
println(increment(5))
}
}Sintaxis del tipo de función
El tipo Int => String representa una función que recibe un Int y devuelve un String. Para varios parámetros se usan paréntesis: (Int, Int) => Int.
object Main {
def main(args: Array[String]): Unit = {
val add: (Int, Int) => Int = (a, b) => a + b
val label: Int => String = n => s"value=$n"
println(add(3, 4))
println(label(7))
}
}Sintaxis de lambda (función anónima)
Una función anónima, o lambda, se escribe (params) => body. No tiene nombre y a menudo se pasa directamente a otra función.
object Main {
def main(args: Array[String]): Unit = {
val square = (x: Int) => x * x
println(square(6))
}
}Funciones de orden superior
Una función de orden superior es aquella que recibe una función como parámetro o devuelve una función. map y filter son ejemplos clásicos.
object Main {
def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
def main(args: Array[String]): Unit = {
println(applyTwice(_ + 3, 10))
}
}Pasar funciones a métodos
Los métodos de colecciones aceptan funciones. Puede pasar una lambda insertada directamente o un valor de función con nombre.
object Main {
def main(args: Array[String]): Unit = {
val triple = (x: Int) => x * 3
println(List(1, 2, 3).map(triple))
println(List(1, 2, 3).map(x => x * 3))
}
}Devolver funciones
Una función puede devolver otra función. Aquí, multiplier devuelve una función que multiplica por un factor fijo: una pequeña fábrica de funciones.
object Main {
def multiplier(factor: Int): Int => Int = x => x * factor
def main(args: Array[String]): Unit = {
val timesTen = multiplier(10)
println(timesTen(5))
}
}Métodos frente a funciones
Un def define un método. Puede convertir un método en un valor de función mediante el guion bajo de la expansión eta: methodName _, o simplemente usarlo donde se espere una función.
object Main {
def doubleIt(x: Int): Int = x * 2
def main(args: Array[String]): Unit = {
val f: Int => Int = doubleIt
println(f(8))
println(List(1, 2, 3).map(doubleIt))
}
}Funciones sin parámetros
Una función puede no recibir argumentos. Su tipo se escribe () => T. Esto resulta útil para aplazar un cálculo.
object Main {
def main(args: Array[String]): Unit = {
val greeting: () => String = () => "Hello!"
println(greeting())
}
}Almacenar funciones en colecciones
Como las funciones son valores, puede almacenarlas en listas o mapas y buscarlas dinámicamente para crear un pequeño distribuidor de comandos.
object Main {
def main(args: Array[String]): Unit = {
val ops: Map[String, (Int, Int) => Int] = Map(
"add" -> (_ + _),
"mul" -> (_ * _)
)
println(ops("add")(3, 4))
println(ops("mul")(3, 4))
}
}Funciones como configuración
Pasar una función permite que quienes llaman personalicen el comportamiento. Aquí, un transformAll genérico aplica cualquier función a una lista.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), _ + 100))
println(transformAll(List(1, 2, 3), _ * 10))
}
}Un ejemplo más limpio de personalización
Este es el mismo concepto expresado de forma más limpia: quienes llaman proporcionan la transformación, mientras el método auxiliar se mantiene genérico y reutilizable.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), x => x + 100))
println(transformAll(List(1, 2, 3), x => x * x))
}
}Comprobación rápida
¿Qué es una función de orden superior?
Repaso
Ha aprendido que las funciones son valores de primera clase:
- Almacenar funciones en
val, listas y mapas - Tipos de función como
Int => String - Lambdas:
(x) => bodyy la forma abreviada_ - Las funciones de orden superior reciben o devuelven funciones
- Los métodos se convierten en valores de función mediante la expansión eta
Preguntas frecuentes
¿La lección «Funciones como valores» es gratis?
Sí — el texto completo de «Funciones como valores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Scala for Backend Engineering & Functional Programming, actualiza a CoddyKit PRO. El curso de Scala for Backend Engineering & Functional Programming incluye 4 lecciones en total.
¿Qué aprenderé en «Funciones como valores»?
Funciones de primera clase Practicas Scala for Backend Engineering & Functional Programming con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Scala for Backend Engineering & Functional Programming?
No se requiere experiencia previa. Scala for Backend Engineering & Functional Programming en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Funciones como valores»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Scala for Backend Engineering & Functional Programming?
Sí. Cada lección de Scala for Backend Engineering & Functional Programming incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Funciones como valores
- Currificación
- Composición
- Clausuras