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.
📝 Прочтите этот рассказ позже в Журнале.
🗞 Просыпайтесь каждое воскресное утро и слышите самые интересные истории, мнения и новости недели, ожидающие в вашем почтовом ящике: Получите примечательный информационный бюллетень›