Scala Tutorial — Scala REPL, выражения, переменные, основные типы, простые функции, сохранение и запуск программ, комментарии

Предисловие

Это первое из нескольких учебных пособий по Scala, которые я создаю для своего курса «Введение в вычислительную лингвистику» в UT Austin осенью 2011 года, в основном на основе похожих учебных пособий, которые Катрин Эрк создала для преподавания Python в аналогичном курсе . Эти учебные пособия не предполагают предшествующий опыт программирования, что, к сожалению, все еще довольно редко встречается во вселенной help-folks-learn-Scala, и которое более или менее требует создания этих учебников. Единственное исключение, о котором я знаю, это SimplyScala .

Примечание : если вы уже знаете язык программирования, этот урок, вероятно, будет не очень полезным для вас. (Хотя, возможно, некоторые из более поздних, посвященных функциональному программированию и тому подобному, которые я собираюсь сделать, будут проверены.) А пока ознакомьтесь с существующими учебными материалами по Scala, которые я перечислил на странице ссылок для курса.

В этом руководстве предполагается, что у вас установлен Scala и что вы используете некую форму Unix (если вы используете Windows, вам стоит заглянуть в Cygwin). Если у вас есть проблемы с этим, вы можете попробовать примеры, оценивая их в поле кода на SimplyScala.

(Частичный) начальный тур по выражениям, переменным и основным типам Scala

Мы будем использовать Scala REPL для ввода выражений Scala и просмотра результатов их оценки. REPL означает read-eval (uate) -print-loop, что означает, что это программа, которая (1) читает выражения, которые вы вводите, (2) оценивает их с помощью компилятора Scala, (3) распечатывает результат оценка, а затем (4) ждет вас, чтобы ввести дополнительные выражения.

Примечание : очень важно, что вы действительно вводите команды, приведенные ниже, в REPL. Если вы просто прочитаете их, во многих случаях это будет выглядеть вполне очевидно (и это так), но тот, кто плохо знаком с программированием, обычно обнаруживает много пробелов в своем понимании, фактически пробуя что-то. В частности, языки программирования очень точны, поэтому они будут делать именно то, что вы им скажете — и вы почти наверняка перепутаете некоторые вещи и извлечете уроки из этого.

В оболочке Unix введите:

Вы должны увидеть что-то вроде следующего:

Строка scala> указывает, что REPL ожидает ввода выражений. Давайте введем некоторые.

REPL говорит нам, что первая — это строка, содержащая символы Hello world , а вторая — это Int , значением которой является целое число 2 . Строки и Ints являются типами — это простое, но важное различие, которое иногда занимает начинающее программирование, чтобы привыкнуть. Это позволяет Scala знать, что делать, когда вы хотите использовать числовое значение 2 (Int) или символ, представляющий 2 (String). Например, вот последний.

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

Scala оценивает результат и выводит результат на экран. Не удивительно, результат, как вы думаете, должен быть. В случае строк добавление не имеет смысла, но вместо этого оператор + указывает конкатенацию строк.

Итак, если вы считаете String «2? и строку «3?», и используйте оператор «+», вы не получите «5? — вместо этого вы получите «23?».

Мы можем попросить Scala отобразить результат оценки заданного выражения с помощью команды print .

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

1. Scala оценивает 2 + 3, что составляет 5.
2. Scala передает это значение в команду print .
3. вывод на печать «5?

Вы можете представить команду print как глагол, а ее параметр (например, Hello world или 2 ) как ее объект.

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

Здесь x — это переменная, которую мы указали, предварительно указав в ней значение val , которое указывает, что это фиксированная переменная, значение которой не может измениться.

Вы можете выбрать имена для переменных, но они должны следовать некоторым правилам.

• Имена переменных могут содержать: буквы, цифры, подчеркивание
• Они не должны начинаться с цифры
• Они не должны быть идентичны одному из «зарезервированных слов», которые уже определены в Scala, например, для if , def , val и var.

Типичными именами переменных будут строки, такие как x , y1 , result , firstName , here_is_a_long_variable_name .

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

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

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

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

Вы, вероятно, ожидали получить 3,5 для последнего. Тем не менее, поскольку 7 и 2 являются Ints, Scala возвращает Int — в частности, он возвращает количество раз, которое знаменатель может целиком войти в числитель. Чтобы получить результат, который вы обычно хотите получить здесь, вам нужно использовать удвоения, такие как следующие.

Теперь результатом является ожидаемое вами значение типа Double. Scala использует соглашения, чтобы знать тип значений, например, он знает, что в кавычках есть строки, то есть числа, которые имеют «.» в них двойники и цифры без «.» Интс. Это важная часть того, как Scala выводит типы переменных, что является очень полезным и несколько уникальным свойством среди языков такого рода (которые называются статически типизированными языками). Чтобы увидеть это немного подробнее, обратите внимание, что вы можете явно сказать Scala, какой тип переменной.

Часть строки a: Int указывает, что переменная a имеет тип Int. Вот несколько примеров других переменных с разными типами.

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

Важно отметить, что мы не можем присвоить переменной тип, который конфликтует с результатом выражения. Здесь мы пытаемся присвоить значение Double переменной типа Int, и Scala сообщает об ошибке.

Во многих случаях, особенно с началом программирования, вам не придется беспокоиться об объявлении типов ваших переменных. Мы увидим ситуации, когда это необходимо по мере нашего прогресса.

В дополнение к переменным, объявленным с помощью val , Scala позволяет объявлять переменные с помощью var — их значения могут быть переназначены. Несколько примеров — это самый простой способ увидеть разницу.

Вы можете думать о переменной val как о герметичном стеклянном контейнере, в который вы можете посмотреть, чтобы увидеть его значение, но в котором вы не можете поместить что-то новое, и о переменной var как открываемом контейнере, который позволяет вам как видеть значение, так и менять его. новое значение для старого. Мы собираемся сосредоточиться на использовании vals в основном, поскольку они в конечном итоге дают много преимуществ в сочетании с функциональным программированием, и потому что я надеюсь, что вы начнете думать о терминах vals, а не vars, когда вы только начинаете.

функции

Переменные более полезны, когда используются в контексте функций, в которых переменная типа x может быть введена с различными значениями пользователем функции. Давайте рассмотрим преобразование градусов по Фаренгейту в градусы Цельсия. Чтобы преобразовать 87, 92 и 100 из Фаренгейта в Цельсий, мы могли бы сделать следующее.

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

Разбивая это, мы имеем:

• def — ключевое слово Scala, указывающее, что функция определяется
• f2c — имя, данное функции
• (x: Double) — параметр функции, представляющий собой переменную с именем x типа Double
• (x — 32) * 5 / 9.0 — это тело функции, которое примет значение, данное пользователем функции, вычтет из него 32, а затем умножит результат на пять девяток

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

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

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

Что действительно так же, как делать это явно.

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

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

Редактирование программ в текстовом редакторе и запуск их в командной строке

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

Сохраните этот файл как HelloWorld.scala , убедившись, что он сохраняется только в виде текста. Затем в оболочке Unix перейдите в каталог, в котором сохранен этот файл, и введите следующее.

Вы увидите, что Hello world выводится, но приглашение Unix заклинило сразу после него. Вы, возможно, ожидали, что он распечатает и затем оставит приглашение Unix на следующей строке; однако в команде print или в строке, которую мы попросили напечатать, нет ничего, что указывало бы на необходимость использования новой строки. Чтобы это исправить, вернитесь в редактор и измените строку следующим образом.

Когда вы запускаете это, ваше приглашение Unix появляется в строке, следующей за Hello world . Такие символы, как ‘ \ n ‘, являются метасимволами, которые указывают на выходные данные, отличные от стандартных символов, таких как буквы, цифры и символы.

Теперь вы могли бы достичь того же результата, написав.

Функции print и println одинаковы, за исключением того, что последний всегда добавляет новую строку в конце своего вывода — то, что часто желательно и, таким образом, упрощает жизнь программиста. Тем не менее, нам все еще часто приходится использовать символ новой строки и другие символы при выводе строк. Например, поместите следующее в HelloWorld.scala и запустите его снова.

Из вывода должно быть совершенно ясно, что означает « \ t ». Обратите внимание, что нет необходимости ставить ‘ \ n ‘ после последних 3, потому что println использовался вместо print .

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

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

Сохраните это как ScalaFirstStepsPart1.scala и запустите его с исполняемым файлом Scala. Вы должны увидеть следующие результаты.

Выглядит хорошо, правда? Но что происходит с этими печатными заявлениями? Ранее мы видели, что 2 + 3 оценивается как 5, но что «2? +» 3? оценивается как «23?», и здесь мы использовали + для String и Int. Разве это не должно привести к ошибке? Scala автоматически конвертирует Int в строку для нас, что значительно упрощает вывод результатов. Это означает, что мы можем сделать что-то вроде следующего (вернуться к использованию REPL).

Это кажется немного бессмысленным, потому что мы могли бы просто написать «22 августа 2011 года?», Но вот пример, где это немного более полезно: мы можем назвать завтрашний день, используя Int для сегодняшнего дня и добавляя один к нему.

Обратите внимание, что часть (dayOfTheMonthToday + 1) на самом деле представляет собой дополнение Int, и результат этого преобразования преобразуется в строку, которая объединяется с остальной частью строки. Этот пример все еще довольно надуманный (и, очевидно, не относится к концу месяца и т. Д.), Но это автоконверсия часто используется, когда вы начинаете работать с более сложными программами. И, может быть, даже более очевидно, мы могли бы разумно захотеть добавить Int и Double.

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

Еще одна вещь, которую стоит отметить, это то, что последний оператор print прошел несколько строк. Мы узнаем больше о правилах для операторов, которые выполняются по нескольким строкам, но этот пример показывает, пожалуй, самый простой для запоминания: когда вы открываете скобку с помощью «(», вы можете продолжать идти по нескольким строкам до тех пор, пока он не станет его партнером. «)» Встречается. Так, например, мы могли бы сделать следующее очень распространенное утверждение.

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

Ссылка: Первые шаги в Scala для начинающих программистов, часть 1 от нашего партнера по JCG Джейсона Болдриджа в блоге Bcomposes .

Статьи по Теме :

• Scala Tutorial — кортежи, списки, методы для списков и строк
• Scala Tutorial — условное исполнение с блоками if-else и соответствием
• Scala Tutorial — итерация, для выражений, yield, map, filter, count
• Scala Tutorial — регулярные выражения, сопоставление
• Scala Tutorial — регулярные выражения, сопоставления и замены с помощью API scala.util.matching
• Учебник по Scala — Карты, Наборы, groupBy, Параметры, Flatten, FlatMap
• Scala Tutorial — scala.io.Source, доступ к файлам, flatMap, изменяемые Карты
• Scala Tutorial — объекты, классы, наследование, черты, списки с несколькими связанными типами, применение
• Scala Tutorial — скриптинг, компиляция, основные методы, возвращаемые значения функций
• Scala Tutorial — SBT, scalabha, пакеты, системы сборки
• Scala Tutorial — блоки кода, стиль кодирования, замыкания, проект документации scala
• Веселье с функцией композиции в Scala
• Как Scala изменил мой взгляд на мой Java-код
• Какие функции Java были исключены в Scala?
• Тестирование с помощью Scala
• Вещи, которые должен знать каждый программист