Первый взгляд на параметры Scala

Поначалу может сбивать с толку их использование в параметрах, но в этих случаях может быть полезно думать о параметрах как о списках, которые имеют значение 0 или 1. Мы увидим несколько примеров этого в следующих случаях.

Выполнение действия, если значение не равно нулю

В большинстве приложений будет много нулевых проверок, которые выглядят примерно так:

// Java
String parsed = (String)simpleParse.get(3);
if (parsed != null) {
    // do some work involving the parsed value
}

Теперь давайте посмотрим на общий способ выполнения этой функции с помощью параметров:

// Scala
simpleParse.get(3).map { parsed =>
    // do some work involving the parsed value
}

Обратите внимание на использование map в опции, возвращаемой simpleParse.get. Думайте о Option в этом случае как о списке с 0 или 1 элементами. Если опция пуста, следующий за ней блок кода запускаться не будет. Если Option имеет значение, оно присваивается переменной parsed, которая, как мы знаем, не равна нулю и может использоваться в блоке кода.

Назначение значения по умолчанию при нулевом значении

Допустим, мы хотим получить значение от simpleParse, но если мы не получаем результат, мы хотим присвоить слово «неизвестно». В Java мы могли бы сделать что-то вроде этого:

// Java
String parsed = (String)simpleParse.get(-2);
String result = (parsed != null) ? parsed : "unknown";

Используя тернарный оператор, мы смогли попробовать получить значение с карты и присвоить значение по умолчанию в 2 строки. Поскольку функция Scala Map.get возвращает Option, мы можем использовать вместо нее функцию getOrElse Option:

// Scala
val result: String = simpleParse.get(-2).getOrElse("unknown")

В одной строке мы можем безопасно выполнить одну и ту же задачу! Вызов getOrElse для Option возвращает значение Option, если оно не пустое. Поскольку наш вызов simpleParse.get(-2) возвращает пустой Option, getOrElse вместо этого возвращает значение, которое мы предоставили, в данном случае строку «unknown».

Что, если мы хотим поработать, прежде чем присвоить значение по умолчанию?

// Java
String parsed = (String)simpleParse.get(-2);
String result;
if (parsed != null) {
    result = parsed;
} else {
    // do some task, like logging parse failure
    result = "unknown";
}

В этом примере мы можем выполнить некоторую задачу перед присвоением result значения по умолчанию. Это увеличило количество кода, требуемого для партии.

Посмотрим, как это можно сделать в Scala:

// Scala
val result = simpleParse.get(-2).getOrElse {
    // do some task, like logging parse failure
    "unknown"
}

Версия Scala дает тот же результат с меньшим количеством кода и более четким потоком.

Манипулирование проанализированным значением перед назначением

Допустим, в вашем Java-коде вы хотите выполнить некоторые действия перед назначением result = parsed, например, зарегистрировать успешный синтаксический анализ или добавить сообщение. На Java это может выглядеть примерно так:

// Java
String parsed = (String)simpleParse.get(2);
String result;
if (parsed != null) {
    // do some task, like logging the successful parse
    result = "Parsed number: " + parsed;
} else {
    // do some other task
    result = "unknown";
}

Чтобы добиться этого в Scala, мы можем объединить уже изученные примеры:

// Scala
val result = simpleParse.get(2).map { parsed => 
    // do some task, like logging the successful parse
    "Parsed number: " + parsed
}.getOrElse {
    // do some other task
    "unknown"
}

Давайте разберемся с этим.

Функция map концептуально изменяет содержимое Option с вызова на simpleParse.get(2). Он не возвращает измененную строку, а возвращает параметр, содержащий измененную строку. В этом случае непустая опция, содержащая «два», становится непустой опцией, содержащей «проанализированное число: два», к тому времени, когда она достигает вызова getOrElse. Таким образом, функция просто возвращает значение в Option и пропускает следующий блок кода.

Если вызов simpleParse.get должен был дать пустой Option, вызов map пропустил бы следующий блок кода и вместо этого остался бы пустым, что привело бы к вызову getOrElse для выполнения его определенной настройки блока кода result на «неизвестно».

Обработка вложенных параметров

Часто значения Java, которые могут быть нулевыми, передаются другим функциям, которые также могут создавать нулевые значения. Этот сценарий мало что изменит:

// Java
String parsed = (String)simpleParse.get(-1);
String result;
if (parsed != null) {
    result = functionThatMayReturnNull(parsed);
    // result is either a String or null
}
// do something based on the value of result

Однако в Scala это может немного отличаться:

// Scala
val result = simpleParse.get(-1).map { parsed =>
  functionThatReturnsAnOption(parsed)
}
// result is an Option[Option[String]]
// do something based on the value of result

Вызов map возвращает Option, содержащий все, что оценивается блоком кода. Поскольку мы вызываем функцию, которая возвращает параметр типа String, мы получаем вложенный параметр. Чтобы избавиться от вложенного Option, мы могли бы сделать что-то вроде этого:

// Scala
val result = simpleParse.get(-1).map { parsed =>
  functionThatReturnsAnOption(parsed).getOrElse("")
}
// result is an Option[String]

Эта модификация извлекает значение параметра или устанавливает значение по умолчанию внутри блока кода map. Хотя в некоторых случаях это может быть правильным шаблоном, обычно более правильным будет использовать flatMap:

// Scala
val result = simpleParse.get(-1).flatMap { parsed =>
  functionThatReturnsAnOption(parsed)
}
// result is an Option[String]

Параметры сведения с flatMap концептуально аналогичны использованию flatMap в списке. Поскольку Option может иметь только 0 или 1 значение, мы можем думать о flatMap как об удалении самого внешнего Option, оставляя нам только внутренний Option, пустой или непустой. Этот шаблон больше всего похож на приведенный выше пример Java.

Вывод

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

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