Scala for Backend Engineering & Functional Programming · Урок

Неявные преобразования

Используйте с осторожностью

«Неявные преобразования» — бесплатный урок Scala for Backend Engineering & Functional Programming на CoddyKit. Это урок 3 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Scala for Backend Engineering & Functional Programming, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Scala for Backend Engineering & Functional Programming содержит 4 уроков всего.

Что такое неявное преобразование?

Неявное преобразование автоматически преобразует значение одного типа в другой, когда это требуется компилятору. Оно может сделать интерфейсы удобнее, но использовать его нужно осторожно, поскольку оно скрывает происходящее.

object Main {
  import scala.language.implicitConversions
  implicit def intToString(x: Int): String = s"number-$x"
  def main(args: Array[String]): Unit = {
    val s: String = 42
    println(s)
  }
}

Как компилятор их использует

Если тип значения не совпадает с ожидаемым, компилятор ищет неявное преобразование, устраняющее несоответствие, и незаметно вставляет его.

object Main {
  import scala.language.implicitConversions
  implicit def doubleToInt(d: Double): Int = d.toInt
  def addTen(x: Int): Int = x + 10
  def main(args: Array[String]): Unit = {
    println(addTen(3.9))
  }
}

Включение возможности

Для определения неявных преобразований требуется импортировать scala.language.implicitConversions, иначе компилятор выдаст предупреждение. Это намеренное ограничение, призванное не допускать чрезмерного использования преобразований.

object Main {
  import scala.language.implicitConversions
  case class Celsius(value: Double)
  implicit def doubleToCelsius(d: Double): Celsius = Celsius(d)
  def describe(c: Celsius): String = s"${c.value} C"
  def main(args: Array[String]): Unit = {
    println(describe(36.6))
  }
}

Обёртки для добавления методов (старый стиль)

До появления методов расширения неявные преобразования в класс-обёртку были способом «добавлять» методы к существующим типам — так называемый шаблон pimp-my-library.

object Main {
  import scala.language.implicitConversions
  class RichInt2(x: Int) {
    def squared: Int = x * x
  }
  implicit def toRich(x: Int): RichInt2 = new RichInt2(x)
  def main(args: Array[String]): Unit = {
    println(5.squared)
  }
}

Опасность: незаметные неожиданности

Поскольку преобразования невидимы в месте вызова, они могут приводить к запутанному поведению и ошибкам, которые трудно отследить. Опечатка может не помешать компиляции, случайно активировав преобразование.

object Main {
  import scala.language.implicitConversions
  implicit def boolToInt(b: Boolean): Int = if (b) 1 else 0
  def main(args: Array[String]): Unit = {
    val total = true + 4 // surprising! becomes 1 + 4
    println(total)
  }
}

Предпочитайте явные преобразования

Часто самый безопасный вариант — обычный именованный метод вместо неявного преобразования. Код становится длиннее, зато его смысл очевиден читателям.

object Main {
  case class Celsius(value: Double)
  def fromDouble(d: Double): Celsius = Celsius(d)
  def main(args: Array[String]): Unit = {
    val c = fromDouble(20.5)
    println(c)
  }
}

Scala 3: класс типов Conversion

В Scala 3 преобразования делаются явными с помощью экземпляра given Conversion[A, B]. Это яснее показывает намерение и по-прежнему требует импорта языка.

import scala.language.implicitConversions

object Main:
  given Conversion[Int, String] = (x: Int) => s"val-$x"
  def main(args: Array[String]): Unit =
    val s: String = 7
    println(s)

Преобразования применяются только один раз

Компилятор применяет не более одного неявного преобразования за раз. Он не объединяет два преобразования в цепочку, чтобы устранить несоответствие, что ограничивает количество неожиданностей.

object Main {
  import scala.language.implicitConversions
  implicit def intToStr(x: Int): String = x.toString
  def needString(s: String): Int = s.length
  def main(args: Array[String]): Unit = {
    println(needString(12345))
  }
}

Где находятся преобразования

Как и другие неявные значения, преобразования разрешаются из локальной области видимости, импортов и сопутствующих объектов. Если поместить их в импорт с понятным именем, их наличие будет заметно.

object Conversions:
  import scala.language.implicitConversions
  implicit def strToLen(s: String): Int = s.length

object Main:
  import Conversions._
  def main(args: Array[String]): Unit =
    val n: Int = "hello"
    println(n)

Когда преобразования уместны

Обоснованные варианты использования включают взаимодействие с типами Java, вспомогательные преобразования числовых типов и границы библиотек. Во всех остальных случаях предпочитайте методы расширения или явные функции.

object Main {
  import scala.language.implicitConversions
  case class Meters(v: Double)
  implicit def metersToDouble(m: Meters): Double = m.v
  def main(args: Array[String]): Unit = {
    val d: Double = Meters(3.5)
    println(d * 2)
  }
}

Практическое правило

Если читатель не может понять по коду, что происходит преобразование, это тревожный сигнал. Обращайтесь к неявным преобразованиям в последнюю очередь, после методов расширения и явных вызовов.

object Main {
  // Explicit and obvious - usually better
  case class Price(cents: Int)
  def toDollars(p: Price): Double = p.cents / 100.0
  def main(args: Array[String]): Unit = {
    println(toDollars(Price(1599)))
  }
}

Быстрая проверка

Каков главный риск неявных преобразований?

Итоги

Вы изучили неявные преобразования и их особенности:

Они автоматически преобразуют один тип в другой, когда типы не совпадают
Требуют import scala.language.implicitConversions
В Scala 3 используется given Conversion[A, B]
За один раз применяется только одно преобразование
Используйте их умеренно; отдавайте предпочтение методам расширения или явным вызовам

Часто задаваемые вопросы

Урок «Неявные преобразования» бесплатный?

Да — полный текст урока «Неявные преобразования» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Scala for Backend Engineering & Functional Programming, подпишись на CoddyKit PRO. Курс Scala for Backend Engineering & Functional Programming содержит 4 уроков всего.

Чему я научусь в уроке «Неявные преобразования»?

Используйте с осторожностью Ты практикуешь Scala for Backend Engineering & Functional Programming с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Scala for Backend Engineering & Functional Programming?

Предыдущий опыт не требуется. Scala for Backend Engineering & Functional Programming на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 4.

Сколько времени занимает урок «Неявные преобразования»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Scala for Backend Engineering & Functional Programming?

Да. Каждый урок Scala for Backend Engineering & Functional Programming включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к Scala for Backend Engineering & Functional Programming