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

Почему Scala так интересна

За последние 15 лет я использовал множество языков программирования в качестве академического исследователя, специалиста по данным и инженера. Я недавно изучил Scala и обнаружил, что это исключительно элегантный и мощный язык. Конкретно:

  • Scala - это очень разборчивый язык, который приятно читать.
  • Код Scala лаконичен.
  • В Scala есть мощная система типов для обнаружения ошибок при написании кода. Аннотации типов делают их еще более удобочитаемыми, поскольку вы знаете типы переменных для каждого фрагмента кода.
  • Scala поддерживает стиль функционального программирования, более естественный для многих не инженеров, чем традиционные процедурные языки программирования.

Вы можете найти более подробную информацию о моих мыслях о Scala в моей статье Первые впечатления от Scala от разработчика данных Java и Python. Кроме того, вы можете посетить scala-lang.org, чтобы узнать, что делает этот язык отличным.

В этой статье вы изучите несколько базовых примеров Scala, чтобы вы могли убедиться, насколько простым и элегантным может быть этот язык. Да, Scala - это богатый язык и экосистема с крутой кривой обучения для людей, желающих полностью овладеть технологией. Но я считаю, что любой может начать использовать Scala с базовым пониманием языка. Позже всегда можно изучить более продвинутые функции Scala, если им понадобится более сложный язык.

Вы даже можете оценить использование столь масштабируемого языка (отсюда и название Scala) в том смысле, что всегда есть более продвинутые функции, которые нужно изучить, когда у вас есть проблема, подходящая для них. Существует даже множество библиотек с открытым исходным кодом, которые расширяют язык, чтобы сделать его более мощным в определенных областях, таких как анализ и обработка «больших данных».

В этой статье мы рассмотрим некоторые основные примеры программирования из легендарной книги Структура и интерпретация компьютерных программ (SICP). Вы можете запустить эти примеры, включая модифицированные версии, в вашем браузере с помощью Scastie. Мы не будем останавливаться на деталях какого-либо отдельного примера, а вместо этого рассмотрим ряд примеров, чтобы вы могли сами увидеть закономерности. Включены небольшие упражнения, которые помогут вам изучить Scala. Мы снова будем использовать Scastie для тестирования кода, который мы пишем в упражнениях.

Привет, мир

Прежде чем погрузиться в SICP, давайте рассмотрим освященную веками традицию показа программы Hello World, которая просто выводит Hello World в качестве вывода.

Мы просто используем функцию печати строки. Вы можете скопировать этот код в Scastie, чтобы проверить это.

Математические выражения

SICP начинается с рассмотрения некоторых примеров математических выражений.

Формат этих математических выражений довольно интуитивно понятен. Кроме того, если вы работали с другими языками программирования, вы можете найти математический синтаксис, идентичный синтаксису других языков, таких как Python, Java, C #, C и Javascript.

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

В качестве упражнения, как бы вы умножили числа 7, 3 и 5 в Scala? Протестируйте свой код в браузере, используя Scastie.

Переменные

В Scala мы можем создать переменную и присвоить ей значение следующим образом.

Переменные можно переназначать.

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

Вальс (т. Е. Постоянные переменные)

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

Мы должны по возможности использовать val вместо var, чтобы код оставался простым и понятным. Работа со Scala научит нас шаблонам, позволяющим избегать переназначения переменных.

Функции

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

В определении функции (т.е. def) важно отметить то, что мы должны указать типы как для параметров функции, так и для возвращаемого значения функции. В этом случае функция принимает единственный целочисленный параметр x и возвращает целое число.

Функции могут принимать более одного входного параметра.

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

Скобки используются для объединения этих нескольких утверждений. Обратите внимание, что функция вычисляет значение последнего выражения, и нет необходимости в явном выражении return, как в некоторых других языках программирования. В этом примере также представлен новый тип Double, который используется для представления чисел с десятичными точками; в математическом выражении действительные числа.

Параметры функции не обязательно должны быть ограничены числовыми типами и могут принимать данные любого типа. Например, есть еще тип String, состоящий из текста; т.е. строка символов. Кроме того, функциям не нужно оценивать полезное значение, и эти функции объявляются с Unit типами возврата.

Как бы вы написали функцию, которая принимает два целых числа, определяет val, который является суммой двух целых чисел, а затем выводит это значение? Вот шаблон.

Ваш код работает в Scastie?

Условные

Scala поддерживает if выражений для условной оценки выражений. В отличие от других процедурных языков, где if - это инструкция (то есть код, который не оценивает значение), Scala if - это выражение, которое оценивает значение.

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

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

В этом примере нет предложения else.

Можете ли вы изменить функцию, которая будет вызываться printClassification, которая печатает как большие, так и маленькие числа, с суффиксом, который говорит: «достаточно велико» или «слишком мало»?

Условные выражения могут быть вложенными, как показано в следующем примере для функции SICP abs для вычисления абсолютного значения целого числа.

Рекурсивные функции

Иногда мы просто хотим повторить что-то в коде. Например, вывод чего-либо n раз или суммирования целых чисел от a до b . Исторически сложилось так, что многие языки программирования использовали так называемые циклы для повторения кода. Эта практика кодирования называется процедурным или императивным кодированием и до недавнего времени была доминирующей тенденцией в основных языках программирования.

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

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

Можете ли вы написать функцию с именем sumUpTo(x: Int), которая использует рекурсию для суммирования всех целых чисел от нуля до x (включительно)?

Опять же, вы можете протестировать свое решение в Scastie.

Немного о базовом сопоставлении с образцом

Я хотел бы воспользоваться моментом, чтобы показать, как конструкция Scala match может использоваться для реализации условной логики функции factorial.

Здесь мы используем конструкцию match для оценки различной логики на основе значения x. Кроме того, вы можете видеть, что мы не обрабатываем случай отрицательного значения явным образом. Вместо этого отрицательные входные данные приводят к выдаче MatchError, потому что ни один из определенных операторов case не соответствует этому входу. Также обратите внимание, как мы ввели val xp, который работает только тогда, когда его значение положительно.

Это базовое использование match, и он может делать гораздо более мощные вещи. В следующих статьях мы рассмотрим более сложные способы использования match.

Функции высшего порядка

В последней части этого введения в Scala давайте рассмотрим функции высшего порядка. Это функции, которые принимают другие функции в качестве аргументов. Рассмотрим следующий пример, в котором мы хотим вызвать функцию func ровно n раз, используя функцию callFunctionNTimes.

Вы можете видеть, что func аргумент callFunctionNTimes определен как (String) => Unit. Это означает, что func - это функция, которая принимает единственный аргумент String и не имеет возвращаемого значения. Мы можем передать любую функцию, которая принимает эту форму, включая как println, так и printTwice.

Можете ли вы написать функцию высшего порядка в форме: callForIntegersInRange(func: (Int) => Unit, start: Int, end: Int): Unit

Вот шаблон.

Опять же, вы можете протестировать свое решение в Scastie.

В сторону: интересно, что мы можем рассматривать println как функцию (String) => Unit и функцию a(Int) => Unit? Мы рассмотрим, как Scala позволяет нам делать это позже в этой серии, когда мы исследуем концепцию, называемую универсальными типами. Короткий ответ заключается в том, чтоprintln определяется как функция типа (Any) => Unit, и оба String и Int могут рассматриваться как Any тип.

Заключительные замечания

Спасибо, что изучаете Scala вместе со мной! Надеюсь, вам понравилось немного узнать о Scala, и вам не терпится узнать больше. Если что-то не так, пожалуйста, дайте мне знать, и я исправлю эти части. Кроме того, если есть части, которые вам действительно понравились, дайте мне знать, и я постараюсь сохранить этот стиль в будущем. Дайте мне знать, что вы думаете, на [email protected].

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

📝 Прочтите этот рассказ позже в Журнале.

🗞 Просыпайтесь каждое воскресное утро и слышите самые интересные истории, мнения и новости недели, ожидающие в вашем почтовом ящике: Получите примечательный информационный бюллетень›