Scala for Backend Engineering & Functional Programming · Lección

Parámetros implícitos

Paso de contexto

Parámetros implícitos 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.

Pasar el contexto automáticamente

Los parámetros implícitos permiten que el compilador proporcione un argumento por usted, tomándolo de los valores marcados como implicit en el ámbito. Son ideales para pasar contexto «ambiental», como la configuración o las reglas de formato.

object Main {
  def greet(name: String)(implicit greeting: String): String =
    s"$greeting, $name!"
  implicit val defaultGreeting: String = "Hello"
  def main(args: Array[String]): Unit = {
    println(greet("Ann"))
  }
}

La lista de parámetros implícitos

Marque la última lista de parámetros con la palabra clave implicit. Cuando la omite en el punto de llamada, el compilador busca un valor implícito compatible.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
  }
}

Proporcionar implícitos explícitamente

Siempre puede pasar un parámetro implícito de forma explícita, reemplazando el que está en el ámbito. Esto resulta útil en casos puntuales.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
    println(multiply(5)(2))
  }
}

Resolución de implícitos por tipo

El compilador compara los implícitos por tipo, no por nombre. Debe haber exactamente un valor implícito compatible en el ámbito; de lo contrario, la compilación falla por ambigüedad o por ausencia.

object Main {
  case class Config(env: String)
  def run()(implicit cfg: Config): String = s"running in ${cfg.env}"
  implicit val cfg: Config = Config("prod")
  def main(args: Array[String]): Unit = {
    println(run())
  }
}

implicitly para obtener un valor

El helper implicitly[T] obtiene directamente del ámbito el valor implícito de tipo T, sin necesidad de nombrar un parámetro.

object Main {
  implicit val name: String = "Scala"
  def main(args: Array[String]): Unit = {
    val n = implicitly[String]
    println(n)
  }
}

Atajo con context bound

Un context bound [T: Ordering] es una forma abreviada de un parámetro implícito de tipo Ordering[T]. Es habitual con las clases de tipos.

object Main {
  def max[T: Ordering](a: T, b: T): T = {
    val ord = implicitly[Ordering[T]]
    if (ord.gt(a, b)) a else b
  }
  def main(args: Array[String]): Unit = {
    println(max(3, 7))
    println(max("apple", "pear"))
  }
}

Transmitir el contexto entre llamadas

Los parámetros implícitos resultan especialmente útiles cuando muchas funciones necesitan el mismo contexto. Márquelo como implícito una vez y se transmitirá automáticamente a través de las llamadas anidadas.

object Main {
  case class User(name: String)
  def log(msg: String)(implicit u: User): Unit =
    println(s"[${u.name}] $msg")
  def doWork()(implicit u: User): Unit = {
    log("started")
    log("finished")
  }
  implicit val current: User = User("admin")
  def main(args: Array[String]): Unit = {
    doWork()
  }
}

Dónde se buscan los implícitos

El compilador busca implícitos en el ámbito local, en las importaciones y en los objetos complementarios de los tipos involucrados. Los objetos complementarios son un lugar ordenado para proporcionar valores predeterminados.

object Main {
  case class Currency(symbol: String)
  object Currency {
    implicit val default: Currency = Currency("$")
  }
  def price(amount: Int)(implicit c: Currency): String = s"${c.symbol}$amount"
  def main(args: Array[String]): Unit = {
    println(price(50))
  }
}

Errores de ambigüedad

Si hay dos implícitos del mismo tipo en el ámbito, el compilador informa de un error de implícito ambiguo. Mantenga como máximo uno por tipo o páselo explícitamente.

object Main {
  def label(x: Int)(implicit unit: String): String = s"$x$unit"
  implicit val unit: String = "px"
  def main(args: Array[String]): Unit = {
    // Only one implicit String in scope -> no ambiguity
    println(label(12))
  }
}

Comportamiento similar a los valores predeterminados

Los parámetros implícitos proporcionan una forma de valores predeterminados sensibles al contexto: la misma llamada de función produce resultados distintos según el implícito que esté en el ámbito.

object Main {
  def format(n: Double)(implicit decimals: Int): String =
    f"$n%.${decimals}f"
  implicit val d: Int = 2
  def main(args: Array[String]): Unit = {
    println(format(3.14159))
    println(format(3.14159)(4))
  }
}

Use los implícitos con moderación

Los parámetros implícitos son potentes, pero pueden dificultar la comprensión del código si se usan en exceso. Resérvelos para contextos transversales reales, como contextos de ejecución, configuraciones e instancias de clases de tipos.

object Main {
  case class Locale(code: String)
  def hello()(implicit loc: Locale): String =
    if (loc.code == "tr") "Merhaba" else "Hello"
  implicit val loc: Locale = Locale("tr")
  def main(args: Array[String]): Unit = {
    println(hello())
  }
}

Comprobación rápida

¿Cómo decide el compilador qué valor proporcionar para un parámetro implícito?

Repaso

Ha aprendido sobre los parámetros implícitos (al estilo de Scala 2):

Marque una lista de parámetros como implicit para que se complete automáticamente
La resolución se realiza por tipo, que debe ser único en el ámbito
implicitly[T] obtiene un valor; los context bounds [T: TC] son una forma abreviada
La búsqueda abarca el ámbito local, las importaciones y los objetos complementarios
Úselos para contexto transversal, no para todo

Preguntas frecuentes

¿La lección «Parámetros implícitos» es gratis?

Sí — el texto completo de «Parámetros implícitos» 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 «Parámetros implícitos»?

Paso de contexto 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 «Parámetros implícitos»?

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

← Volver a Scala for Backend Engineering & Functional Programming