Crystal Programming. Введение на основе проекта в создание эффективных, безопасных и читаемых веб-приложений и приложений CLI

С самого начала Crystal создавался как быстрый. Он следует тем же принципам, что и другие быстрые языки, такие как C. Компилятор может анализировать исходный код, чтобы узнать точный тип каждой переменной и расположение памяти перед выполнением. Затем он может создать быстрый и оптимизированный собственный исполняемый файл без необходимости что-либо угадывать во время выполнения. Этот процесс широко известен как предварительная компиляция.

Компилятор Crystal построен на основе LLVM, той же инфраструктуры компилятора, которая используется в Rust, Clang и Apple Swift. В результате Crystal извлекает выгоду из того же уровня оптимизации, что и эти языки, что делает его хорошо подходящим для приложений с интенсивными вычислениями, таких как машинное обучение, обработка изображений или сжатие данных.

Но не все приложения привязаны к процессору. В большинстве случаев на карту поставлены другие ресурсы, такие как сетевые коммуникации или локальный диск. Все вместе они известны как ввод-вывод. Crystal имеет модель параллелизма, аналогичную горутинам Go или процессам Erlang, где несколько операций могут выполняться за циклом событий, не блокируя процесс и не делегируя слишком много работы операционной системе. Эта модель идеально подходит для таких приложений, как веб-службы или инструменты управления файлами.

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

Давайте взглянем на простую реализацию алгоритма сортировки выбором, написанную на Crystal:

def selection_sort(arr)

 # Для каждого индекса элемента...

 arr.each_index do |i|

  # Найдите наименьший элемент после него

  min = (i...arr.size).min_by {	|j| arr[j] }

  # Поменяйте местами позиции с наименьшим элементом

  arr[i], arr[min] = arr[min], arr[i]

 end

end

# Создайте перевернутый список из 30 тысяч элементов.

list = (1..30000).to_a.reverse

# Отсортируйте его, а затем распечатайте его голову и хвост select_sort(list)

p list[0...10]

p list[-10..-1]

В этом примере уже показаны некоторые интересные особенности Crystal:

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

• Это выразительно. Вы можете перебирать списки со специализированными блоками или использовать диапазоны.

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

Удивительно, но этот же код действителен и в Ruby. Воспользовавшись этим, если мы возьмем этот файл и запустим его как Ruby Selection_sort.cr (обратите внимание, что Ruby не заботится о расширениях файлов), это займет около 30 секунд. С другой стороны, выполнение этой программы после ее компиляции с помощью Crystal в оптимизированном режиме занимает около 0,45 секунды, то есть в 60 раз меньше. Конечно, эта разница не одинакова для любой программы. Это зависит от того, с какой рабочей нагрузкой вы имеете дело. Также важно отметить, что Crystal требуется время для анализа, компиляции, при необходимости оптимизации и создания собственного исполняемого файла.

На следующем графике показано сравнение этого алгоритма сортировки выбором, написанного для разных языков. Здесь вы можете видеть, что Crystal соревнуется на вершине, проигрывая C и очень близко приближаясь к Go. Важно отметить, что Crystal — безопасный язык: он имеет полную поддержку обработки исключений, отслеживает границы массивов, чтобы избежать небезопасного доступа, а также проверяет переполнение при целочисленных математических операциях. С другой стороны, C — небезопасный язык, и он ничего из этого не проверяет. Безопасность достигается за счет незначительного снижения производительности, но, несмотря на это, Crystal остается очень конкурентоспособным:

Сортировка выбором в перевернутом списке из 30 тыс. элементов

Рисунок 1.2. Сравнение реализации простой сортировки выбором на разных языках.

Сравнение веб-серверов

Crystal не только отлично подходит для выполнения вычислений в небольших случаях, но также хорошо работает в более крупных приложениях, таких как веб-сервисы. Язык включает в себя богатую стандартную библиотеку со всем понемногу, и вы узнаете о некоторых ее компонентах в Главе 4 «Изучение Crystal посредством написания интерфейса командной строки». Например, вы можете создать простой HTTP-сервер, например этот:

require "http/server"

server = HTTP::Server.new do |context|

 context.response.content_type = "text/plain"

 context.response.print "Hello world, got #{context

  .request.path}!"

end

puts "Listening on http://127.0.0.1:8080"

server.listen(8080)

Первая строка

require "http/server”

HTTP::Server

8080

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

Запросов в секунду на одном ядре

Рисунок 1.3 – Сравнение скорости запросов в секунду простых HTTP-серверов на разных языках

Здесь мы видим, что Crystal значительно опережает многие другие популярные языки (очень близкие к Rust и Go), а также является очень высокоуровневым и удобным для разработчиков. Многие языки достигают производительности за счет использования низкоуровневого кода, но при этом не требуется жертвовать выразительностью или раскрывать абстракции. Код Crystal легко читать и развивать. Та же тенденция наблюдается и в других приложениях, а не только в веб-серверах или микробенчмарках.

Теперь давайте попрактикуемся в использовании Crystal.

Теперь давайте поэкспериментируем с созданием нашей первой программы с использованием Crystal. Это основа того, как вы будете писать и выполнять код в оставшейся части этой книги. Вот наш первый пример:

who = "World"

puts "Hello, " + who + "!"

После этого выполните следующие действия:

1. Сохраните это в файле hello.cr.

2. Запустите его с помощью

crystal run hello.cr

3. Попробуйте изменить переменную

who

Не существует шаблонного кода, такого как создание статического класса или «основной» функции. Для этого базового примера также не нужно ничего импортировать из стандартной библиотеки. Вместо этого вы можете просто начать программировать прямо сейчас! Это хорошо для быстрого написания сценариев, но также упрощает приложения.

Обратите внимание: переменную

who

Вызов метода в Crystal не требует круглых скобок. Вы можете увидеть там

puts

puts("Hello, " + who + "!")

Конкатенацию строк можно выполнить с помощью оператора

+

Давайте попробуем что-нибудь еще, прочитав имя, введенное пользователем:

def get_name

 print "What's your name? "

 read_line

end

puts "Hello, " + get_name + "!"

После этого сделаем следующее:

1. Сохраните приведенный выше код в файле с именем “hello_name.cr”.

2. Запустите его с помощью команды

crystal run hello_name.cr

3. Он спросит ваше имя; введите его и нажмите Enter.

4. Теперь запустите его еще раз и введите другое имя. Обратите внимание на изменение вывода.

В этом примере вы создали метод

get_name

print

read_line

get_name

read_line

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

Создание исполняемого файла

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

До сих пор вы использовали

crystal run hello.cr

crystal build hello.cr

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

./hello.

Фактически,

crystal run hello.cr

crystal build hello.cr && ./hello

Вы также можете использовать

crystal build --release hello.cr

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

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

score = 38

distance = 104

score = 41

p score

Вы можете выполнить эту программу Crystal, записав ее в файл и используя

crystal file.cr

41

p

Если вы работаете с другими языками, такими как Java, C#, Go или C, обратите внимание, что это полноценная программа. В Crystal вам не нужно создавать основную функцию, объявлять переменные или указывать типы. Вместо этого при создании новой переменной и изменении ее значения используется тот же синтаксис.

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

# Назначаем две переменные одновременно

emma, josh = 19, 16

# Это то же самое, в две строки

emma = 19

josh = 16

# Теперь поменяем их значения emma, josh = josh, emma

p emma # => 16

p josh # => 19

Этот пример начинается со строки комментария. Комментарии предназначены для добавления пояснений или дополнительных деталей в исходный код и всегда начинаются с символа

#

emma

josh

19

16

emma

josh

josh

emma

Имена переменных всегда пишутся строчными буквами в соответствии с соглашением о разделении слов символом подчеркивания (известным как snake_case). Хотя это и редкость, в именах переменных также могут использоваться заглавные буквы и неанглийские буквы.

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

FEET = 0.3048 # Метры

INCHES = 0.0254 # Метры

my_height = 6 * FEET + 2 * INCHES # 1.87960 метров

FEET = 20 # Ошибка: константа FEET уже инициализирована.

Этот код показывает определение двух констант: ФУТОВ и ДЮЙМОВ. В отличие от переменных, им нельзя впоследствии присвоить другое значение. К константам можно получить доступ и использовать их в выражениях вместо их значений. Они полезны при присвоении имен специальным или повторяющимся значениям. Они могут хранить любые данные, а не только числа.

Теперь давайте рассмотрим некоторые из наиболее распространенных примитивных типов данных.

Числа (Numbers)

Как и в других языках, числа бывают разных видов; вот таблица с их описанием:

При записи числа в соответствии со значением будет использоваться наиболее подходящий тип: если это целое число, то это будет

Int32

Int64

UInt64

Float64

small_number = 47 # Это тип Int32

larger_number = 8795656243 # Теперь это тип Int64

very_compact_number = 47u8 # Тип UInt8 из-за суффикса

other_number = 1_234_000 # Это то же самое, что 1234000

negative_number = -17 # Есть и отрицательные значения

invalid_number = 547_u8 # 547 не соответствует диапазону UInt8

pi = 3.141592653589 # Дробные числа имеют формат Float64

imprecise_pi = 3.14159_f32 # Это Float32

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

hero_health_points = 100

hero_defense = 7

enemy_attack = 16

damage = enemy_attack - hero_defense # Враг наносит 9 единиц урона

hero_health_points -= damage # Теперь здоровье героя составляет 91

healing_factor = 0.05 # Герой исцеляется со скоростью 5% за ход

recovered_health = hero_health_points * healing_factor

hero_health_points += recovered_health # Теперь здоровье 95,55

# Этот же расчет можно выполнить и в одну строку: result = (100 - (16 - 7)) * (1 + 0.05) # => 95.55

Вот некоторые из наиболее распространенных операций с числами:

Существуют и другие типы чисел для выражения больших или более точных величин:

•

BigInt

•

BigFloat

•

BigDecimal

•

BigRational

•

Complex

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

Примитивные константы — true, false и nil

В Crystal есть три примитивные константы, каждая из которых имеет свое значение. Ниже указаны типы и использование:

Значения true и false являются результатом выражений сравнения и могут использоваться с условными выражениями. Несколько условных операторов можно комбинировать с помощью

&&

||

3 > 5 || 1 < 2

true

Не все данные состоят только из чисел; нам часто приходится иметь дело с текстовыми данными. Давайте посмотрим, как мы можем с ними справиться.

Строки и символы (String и Char)

Текстовые данные могут быть представлены типом String: они могут хранить произвольные объемы текста UTF-8, предоставляя множество служебных методов для его обработки и преобразования. Существует также тип

Char

text = "Crystal is cool!"

name = "John"

single_letter = 'X'

kana = 'あ' # Международные символы всегда действительны

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

name = "John"

age = 37

msg = "#{name} is #{age} years old" # То же, что и "Джону 37 лет"

Вы также можете использовать escape-последовательности внутри строки для обозначения некоторых специальных символов. Например, команда

puts "a\nb\nc”

Важно помнить, что строки Crystal являются неизменяемыми после их создания, поэтому любая операция над ними приведет к созданию новой строки. Многие операции можно выполнять со строками; они будут использоваться в примерах на протяжении всей книги. Вот некоторые распространенные операции, которые можно выполнять со строками:

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

Диапазоны (Ranges)

Еще один полезный тип данных —

Range

•

a..b

a

b

•

a...b

a

b

Ниже приведены примеры диапазонов:

1..5 # => 1, 2, 3, 4, и 5.

1...5 # => 1, 2, 3, и 4.

1.0...4.0 # => Включает 3,9 и 3,999999, но не 4.

'a'..'z' # => Все буквы алфавита

"aa".."zz" # => Все комбинации двух букв

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

1..	# => Все числа больше 1

...0	# => Отрицательные числа, кроме нуля

..	# => Ассортимент, который включает в себя все, даже самого себя

Диапазоны также можно применять к разным типам; подумайте, например, о временных интервалах.

С диапазонами можно выполнять множество операций. В частности,

Range

Enumerable

Iterable

Вы уже можете выражать некоторые данные, используя литеральные значения и переменные в своем коде. Этого достаточно для некоторых базовых вычислений; попробуйте использовать его для некоторых преобразований строк или математических формул. Некоторые виды значений можно сначала объявить, чтобы использовать позже; перечисления — самые простые из них.

Перечисления и символы (Enums and symbols)

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

String

Например, предположим, что вы взаимодействуете с каким-либо пользователем в многопользовательской системе. Этот конкретный пользователь может быть гостем, обычным пользователем, прошедшим проверку подлинности, или администратором. Каждый из них имеет разные возможности, и их следует различать. Это можно сделать с помощью числового кода для представления каждого типа пользователей, например 0, 1 и 2. Или это можно сделать с использованием типа

String

Лучшая альтернатива — объявить правильное перечисление возможных типов пользователей, используя ключевое слово

enum

enum UserKind

  Guest

  Regular

  Admin

end

Переменная, содержащая тип пользователя, может быть назначена путем ссылки на имя типа, а затем на один из объявленных типов:

user_kind = UserKind::Regular

puts "This user is of kind #{user_kind}"

Тип переменной

user_kind

UserKind

Int32

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

user_kind.guest?

user_kind

Guest

regular?

admin?

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

Symbol

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

user_kind = :regular

puts "This user is of kind #{user_kind}"

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

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

Управление потоком выполнения с помощью условных выражений

if

nil

false

else

secret_number = rand(1..5) # Случайное целое число от 1 до 5

print "Пожалуйста, введите свое предположение:"

guess = read_line.to_i

if guess == secret_number

  puts "Вы правильно догадались!"

else

  puts "Извините, номер был #{secret_number}."

end

true

false

if

unless

false

nil

unless guess.in? 1..5

  puts "Пожалуйста, введите число от 1 до 5."

end

if

else

if-else

if

unless

puts "Пожалуйста, введите число от 1 до 5." unless guess.in? 1..5

if

elsif

if

unless

if !guess.in? 1..5

  puts "Пожалуйста, введите число от 1 до 5."

elsif guess == secret_number

  puts "Вы правильно угадали!"

else

  puts "Извините, номер был #{secret_number}."

end

if

msg = if !guess.in? 1..5

    "Пожалуйста, введите число от 1 до 5."

   elsif guess == secret_number

    "Вы правильно угадали!"

   else

    "Извините, номер был #{secret_number}."

   end

puts msg

puts "Вы догадались #{guess == secret_number ? "правильно" : "неправильно"}!"

case

if

case

if

case

case Time.local.month

when 1, 2, 3

 puts "Мы в первом квартале"

when 4, 5, 6

 puts "Мы во втором квартале"

when 7, 8, 9

 puts "Мы в третьем квартале"

when 10, 11, 12

 puts "Мы в четвертом квартале"

end

if

month = Time.local.month

if month == 1 || month == 2	|| month == 3

 puts "Мы в первом квартале"

elsif month == 4	|| month == 5 || month == 6

 puts "Мы во втором квартале"

elsif month == 7 || month == 8	|| month == 9

 puts "Мы в третьем квартале"

elsif month == 10 || month == 11 || month == 12

 puts "Мы в четвертом квартале"

end

case

case Time.local.month

when 1..3

 puts "Мы в первом квартале"

when 4..6

 puts "Мы во втором квартале"

when 7..9

 puts "Мы в третьем квартале"

when 10..12

 puts "Мы в четвертом квартале"

end

int_or_string = rand(1..2) == 1 ? 10 : "привет"

case int_or_string

when Int32

 puts "Это целое число"

when String

 puts "Это строка"

end

case

===

if

===

if

case

else

case rand(1..10)

when 1..3

 puts "Я кот"

when 4..6

 puts "Я собака"

else

 puts "Я случайное животное"

end

while

if

secret_number = rand(1..5)

print "Пожалуйста, введите ваше предположение: "

guess = read_line.to_i

while guess != secret_number

 puts "Извините, это не то. Пожалуйста, попробуйте еще раз: "

 guess = read_line.to_i

end

puts "Вы правильно угадали!"

until

while

unless

if

secret_number = rand(1..5)

print "Пожалуйста, введите ваше предположение: "

guess = read_line.to_i

until guess == secret_number

 puts "Извините, это не то. Пожалуйста, попробуйте еще раз: "

 guess = read_line.to_i

end

puts "Вы правильно угадали!"

break

next

break

next

secret_number = rand(1..5)

while true

 print "Пожалуйста, введите свое предположение (ноль, чтобы отказаться): "

 guess = read_line.to_i

 if guess < 0 || guess > 5

  puts "Неверное предположение. Пожалуйста, попробуйте еще раз."

  next

 end

 if guess == 0

  puts "Извините, вы сдались. Ответ был #{secret_number}."

  break

 elsif guess == secret_number

  puts "Поздравляем! Вы угадали секретный номер!"

  break

 end

 puts "Извините, это не то. Пожалуйста, попробуйте еще раз."

end

Изучение системы типов

typeof(x)

x.class

x.is_a?(Type)

a = 10

p typeof(a) # => Int32

# Измените 'a', чтобы оно стало строкой String

a = "привет"

p typeof(a) # => String

# Возможно, 'a' изменится на Float64

if rand(1..2) == 1

 a = 1.5

 p typeof(a) # => Float64

end

# Теперь переменная 'a' может быть либо String либо Float64

p typeof(a) # => String | Float64

# Но мы можем узнать во время выполнения, какой это тип.

if a.is_a? String

 puts "Это String"

 p typeof(a) # => String

else

 puts "Это Float64"

 p typeof(a) # => Float64

end

# Тип 'a' был отфильтрован внутри условного выражения, но не изменился.

p typeof(a) # => String | Float64

# Вы также можете использовать .class для получения типа среды выполнения

puts "It's a #{a.class}"

nil

Nil

nil.inspect

nil

is_a?

Экспериментируем с командой Crystal Play

Команда

crystal play

запускает Crystal Playground для воспроизведения языка с помощью вашего браузера. Он покажет результат каждой строки вместе с выведенным типом:

1. Откройте терминал и введите "crystal play”; он покажет следующее сообщение:

Listening on http://127.0.0.1:8080

2. Оставьте терминал открытым, а затем запустите этот URL-адрес в своем любимом веб-браузере. Это даст вам удобный интерфейс для начала программирования в Crystal:

Рисунок 2.1 - The Crystal playground

1. С левой стороны у вас есть текстовый редактор с некоторым кодом Crystal. Вы можете попробовать изменить код на какой-нибудь код из этой книги, чтобы получить интерактивный способ обучения.

2. С правой стороны есть поле с некоторыми аннотациями к вашему коду. Например, он покажет вам результат каждой строки рядом с типом значения, видимым компилятором.

Если вы сомневаетесь в каких-то примерах или нестандартных решениях, попробуйте их с помощью Crystal playground.

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

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

nil

def leap_year?(year) divides_by_4 = (year % 4 == 0)

  divides_by_100 = (year % 100 == 0)

  divides_by_400 = (year % 400 == 0)

  divides_by_4 && !(divides_by_100 && !divides_by_400)

end

puts leap_year? 1900 # => false

puts leap_year? 2000 # => true

puts leap_year? 2020 # => true

Определения методов начинаются с ключевого слова

def

jump_year?

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

puts

jump_year?

leap_year? 1900

puts(leap_year?(1900))

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

• Метод, заканчивающийся на

?

Bool

Nil

• Метод, заканчивающийся на

!

!

Методы могут основываться на других методах. Посмотрите это, например:

def day_count(year)

  leap_year?(year) ? 366 : 365

end

Методы могут быть перегружены по количеству аргументов. Посмотрите это, например:

def day_count(year, month)

  case month

  when 1, 3, 5, 7, 8, 10, 12

   31

  when 2

   leap_year?(year) ? 29 : 28

  else

   30

  end

end

В этом случае метод будет выбран в зависимости от того, как вы расставите аргументы для его вызова:

puts day_count(2020) # => 366

puts day_count(2021) # => 365

puts day_count(2020, 2) # => 29

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

def day_count(year, month)

  if month == 2

   return leap_year?(year) ? 29 : 28

  end

  month.in?(1, 3, 5, 7, 8, 10, 12) ? 31 : 30

end

Поскольку типы могут быть опущены при объявлении метода, типы параметров определяются при вызове метода. Посмотрите это, например:

def add(a, b) # 'a' and 'b' could be anything.

  a + b

end

p add(1, 2)	# Here they are Int32, prints 3.

p add("Crys", "tal") # Here they are String, prints "Crystal".

# Let's try to cause issues: 'a' is Int32 and 'b' is String.

p add(3, "hi")

# => Error: no overload matches 'Int32#+' with type String

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

a

В третьем вызове он пытается вызвать

add

Int32

String

add

a + b

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

a + b

Добавление ограничений типа

Отсутствие типов — не всегда лучший вариант. Вот несколько преимуществ указания типов:

• Сигнатуру метода с типами легче понять, особенно в документации.

• Для разных типов можно добавлять перегрузки с разными реализациями.

• Если вы допустили ошибку и вызвали какой-либо метод с неправильным типом, сообщение об ошибке будет более четким при вводе параметров.

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

def show(value : String)

  puts "The string is '#{value}'"

end

def show(value : Int)

  puts "The integer is #{value}"

end

show(12) # => The integer is 12

show("hey") # => The string is 'hey'

show(3.14159) # Error: no overload matches 'show' with type Float64

x = rand(1..2) == 1 ? "hey" : 12

show(x) # => Either "The integer is 12" or "The string is 'hey'"

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

В этом примере вы также видите тип

Int

Последняя строка показывает концепцию множественной диспетчеризации в Crystal: если аргумент вызова тип объединения (в данном случае

Int32 | String

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

Ограничение типа аналогично аннотациям типов в большинстве других языков, где вы укажите фактический тип параметра. Но в Crystal нет аннотаций типов. Здесь важно слово «ограничение»: ограничение типа служит для ограничения возможных типы приемлемы. Фактический тип по-прежнему исходит из места вызова. Посмотрите это, например:

def show_type(value : Int | String)

  puts "Compile-time type is #{typeof(value)}."

  puts "Runtime type is #{value.class}."

  puts "Value is #{value}."

end

show_type(10)

# => Compile-time type is Int32.

# => Runtime type is Int32.

# => Value is 10.

x = rand(1..2) == 1 ? "hello" : 5_u8

show_type(x)

# => Compile-time type is (String | UInt8).

# => Runtime type is String.

# => Value is hello.

Интересно видеть, что тело метода всегда специализировано для типов, используемых в вызывайте сайт, не требуя проверок во время выполнения или какого-либо динамизма. Это часть того, что делает Кристалл очень быстрый язык.

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

def add(a, b) : Int

  a + b

end

add 1, 3 # => 4

add "a", "b" # Error: method top-level add must return Int but it is returning String

Здесь вариант строки не удастся скомпилировать, поскольку

a + b

Значения по умолчанию

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

def random_score(base, max = 10)

  base + rand(0..max)

end

p random_score(5) # => Some random number between 5 and 15.

p random_score(5, 5) # => Some random number between 5 and 10.

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

Именованные параметры

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

# These are all the same:

p random_score(5, 5)

p random_score(5, max: 5)

p random_score(base: 5, max: 5)

p random_score(max: 5, base: 5)

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

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

def store_opening_time(is_weekend, is_holiday)

  if is_holiday

    is weekend ? nil : "8:00"

  else

    is_weekend ? "12:00" : "9:00"

  end

end

В этой реализации нет ничего необычного. Но если вы начнете его использовать, все быстро станет очень запутанным:

p store_opening_time(true, false) # What is 'true' and 'false' here?

You can call the same method while specifying the name of each parameter for clarity:

p store_opening_time(is_weekend: true, is_holiday: false)

Чтобы принудительно дать имена некоторым параметрам, добавьте перед ними символ

*

*

def store_opening_time(*, is_weekend, is_holiday)

  # ...

end

p store_opening_time(is_weekend: true, is_holiday: false)

p store_opening_time(is_weekend: true, is_holiday: false)

p store_opening_time(true, false) # Invalid!

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

Внешние и внутренние имена параметров

Иногда параметр может иметь имя, которое имеет большой смысл в качестве описания аргумента для вызывающего объекта, но может звучать странно при использовании в качестве переменной в теле реализации метода. Crystal позволяет вам определить внешнее имя (видимое для вызывающего объекта) и внутреннее имя (видимое для реализации метода). По умолчанию они одинаковы, но это не обязательно. Посмотрите это, например:

def multiply(value, *, by factor, adding term = 0)

  value * factor + term

end

p multiply(3, by: 5) # => 15

p multiply(2, by: 3, adding: 10) # => 16

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

*

by

0

Передача блоков в методы

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

yield

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

def perform_operation

  puts "before yield"

  yield

  puts "between yields"

  yield

  puts "after both yields"

end

Затем этот метод можно вызвать, передав блок кода либо вокруг

do ... end

{ ... }

perform_operation {

  puts "inside block"

}

perform_operation do

  puts "inside block"

end

Выполнение этого кода приведет к следующему выводу:

before yield

inside block

between yields

inside block

after both yields

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

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

def transform(list)

  i = 0

  # new_list is an Array made of whatever type the block returns

  new_list = [] of typeof(yield list[0])

  while i < list.size

    new_list << yield list[i]

    i += 1

  end

  new_list

end

numbers =	[1, 2, 3, 4, 5]

p transform(numbers) { |n| n ** 2 } # => [1, 4, 9, 16, 25] p transform(numbers) { |n| n.to_s } # => ["1", "2", "3", "4", "5"]

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

|

Вышеупомянутый метод преобразования эквивалентен методу карты, доступному для массивов:

numbers =	[1, 2, 3, 4, 5]

p numbers.map { |n| n ** 2 }	# => [1, 4, 9, 16, 25]

p numbers.map { |n| n.to_s }	# => ["1", "2", "3", "4", "5"]

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

Как и

while

until

next

break

Использование

next

внутри блока

Используйте

next

yield

next

yield

def generate

 first = yield 1  # This will be 2

 second = yield 2 # This will be 10

 third = yield 3  # This will be 4

 first + second + third

end

result = generate do |x|

 if x == 2

   next 10

 end

 x + 1

end

p result

Метод

generate

yield

next

return

Другой способ выйти из выполнения блока — использовать ключевое слово

break

Использование

break

внутри блока

Используйте

break

result = generate do |x|

  if x == 2

   break 10 # break instead of next

  end

x + 1

end

p result

В этом случае

yield

1

2

yield

2

generate

result

10

break

Возвращение изнутри блока

Наконец, давайте посмотрим, как ведет себя

return

1

Следующий метод

collatz_sequence

Затем следует реализация метода, который запускает

collatz_sequence

1

def collatz_sequence(n)

  while true

   n = if n.even?

   n // 2

  else

   3 * n + 1

  end

  yield n

  end

end

def sequence_length(initial)

  length = 0

  collatz_sequence(initial) do |x|

   puts "Element: #{x}"

   length += 1

   if x == 1

     return length	# <= Note this 'return'

   end

 end

end

puts "Length starting from 14 is: #{sequence_length(14)}"

Метод

sequence_length

1

collatz_sequence

return

next

yield

break

В этом примере кода выводится

Length starting from 14 is: 17

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

•

Array

•

Tuple

•

Set

•

Hash

Set

•

NamedTuple

•

Deque

Далее давайте подробнее рассмотрим некоторые из этих типов контейнеров.

Массивы и кортежи

Вы можете выразить некоторые простые данные с помощью чисел и текста, но вам быстро понадобится собрать больше информации в списки. Для этого вы можете использовать массивы и кортежи. Массив — это динамический контейнер, который может увеличиваться, сжиматься и изменяться во время выполнения программы. С другой стороны, кортеж статичен и неизменяем; его размер и типы элементов известны и фиксируются во время компиляции:

numbers = [1, 2, 3, 4]   # This is of type Array(Int32)

numbers << 10

puts "The #{numbers.size} numbers are #{numbers}"

  # => The 5 numbers are [1, 2, 3, 4, 10]

С массивами нельзя смешивать разные типы, если они не были указаны при создании массива. Эти ошибки обнаруживаются во время сборки; они не являются исключениями во время выполнения. Посмотрите это, например:

numbers << "oops"

  # Error: no overload matches 'Array(Int32)#<<' with type String

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

first_list = [1, 2, 3, "abc", 40]

p typeof(first_list) # => Array(Int32 | String)

first_list << "hey!" # Ok

# Now all elements are unions:

element = first_list[0]

p element     # => 1

p element.class  # => Int32

p typeof(element) # => Int32 | String

# Types can also be explicit:

second_list = [1, 2, 3, 4] of Int32 | String

p typeof(second_list) # => Array(Int32 | String)

second_list << "hey!" # Ok

# When declaring an empty array, an explicit type is mandatory:

empty_list =	[] of Int32

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

Тип

Array

Indexable

Enumerable

Iterable

Кортеж похож на массив в том смысле, что он хранит ряд элементов в упорядоченном виде. Два основных различия заключаются в том, что кортежи являются неизменяемыми после их создания и что исходный тип каждого элемента сохраняется без необходимости объединения:

list = {1, 2, "abc", 40}

p typeof(list) # => Tuple(Int32, Int32, String, Int32)

element = list[0]

p typeof(element) # => Int32

list << 10	# Invalid, tuples are immutable.

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

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

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

Хэш

{...}

=>

population = {

  "China" => 1_439_323_776,

  "India" => 1_380_004_385,

  "United States" => 331_002_651,

  "Indonesia" => 273_523_615,

  "Pakistan" => 220_892_340,

  "Brazil" => 212_559_417,

  "Nigeria" => 206_139_589,

  "Bangladesh" => 164_689_383,

  "Russia" => 145_934_462,

  "Mexico" => 128_932_753,

}

Hash(String, Int32)

10

population = {} of String => Int32

puts "Total population: #{population.values.sum}"

Unhandled exception: Arithmetic overflow (OverflowError)

Hash(String, Int32)

Array(Int32)

4 503 002 371

Int32

-2 147 483 648

2 147 483 647

Int32

Int64

population = {

  "China" => 1_439_323_776,

  "India" => 1_380_004_385,

  # ...

  "Mexico" => 128_932_753,

} of String => Int64

puts "Total population: #{population.values.sum(0_i64)}"

do...end

loop do

  puts "I execute forever"

end

while true

while true

  puts "I execute forever"

end

times

each

times

5.times do

  puts "Hello!"

end

(10..15).each do |x|

  puts "My number is #{x}"

end

["apple", "orange", "banana"].each do |fruit|

  puts "Don't forget to buy some #{fruit}s!"

end

while

fruits = ["apple", "orange", "banana"]

# (1) Prints ["APPLE", "ORANGE", "BANANA"]

  p(fruits.map do |fruit| fruit.upcase

end)

# (2) Same result, braces syntax

p fruits.map { |fruit| fruit.upcase }

# (3) Same result, short block syntax

p fruits.map &.upcase

do... end

map

do...end

p

{ ... }

{ ... }

&.foo

{ |x| x.foo }

p fruits.map(&.upcase)

Tuple

splat

splat

*

def get_pop(population, *countries)

  puts "Requested countries: #{countries}"

  countries.map { |country| population[country] }

end

puts get_pop(population, "Indonesia", "China", "United States")

Requested countries: {"Indonesia", "China", "United States"}

{273523615, 1439323776, 331002651}

typeof(countries)

Tuple(String, String, String)

Splat

Организация вашего кода в файлах

crystal run

crystal build

require

def factorial(n)

  (1..n).product

end

require "./factorial"

(1..10).each do |i|

  puts "#{i}! = #{factorial(i)}"

end

crystal run program.cr

. -

./

../

require "./commands/*"

require

..

./

../

require "http/server" # Imports the HTTP server from stdlib.

Server = HTTP::Server.new do |context|

  context.response.content_type = "text/plain"

  context.response.print "Hello world, got

  #{context.request.path}!"

end

puts "Listening on http://127.0.0.1:8080" server.listen(8080)

Резюме

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

Array

Hash

splat

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

Дальнейшее чтение

Некоторые языковые детали были опущены, чтобы сделать текст кратким и целенаправленным. Однако вы можете найти документацию и справочные материалы по всему, что здесь объясняется более подробно, на веб-сайте Crystal по адресу https://crystal-lang.org/docs/.

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

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

class Person

end

person1 = Person.new

person2 = Person.new

В этом примере создается новый класс с именем

Person

p person1  # You can display any object and inspect it

p person1.to_s # Any object can be transformed into a String

p person1 == person2 # false. By default, compares by reference.

p person1.same?(person2) # Also false, same as above.

p person1.nil? # false, person1 isn't nil.

p person1.is_a?(Person) # true, person1 is an instance of Person.

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

initialize

@

Person

class Person

  def initialize(name : String)

   @name = name

   @age = 0

  end

  def age_up

   @age += 1

  end

  def name

   @name

  end

  def name=(new_name)

   @name = new_name

  end

end

Здесь мы создали более реалистичный класс

Person

@name

String

@age

Int32

initialize

Теперь давайте воспользуемся этим классом:

jane = Person.new("Jane Doe")

p jane # => #

jane.name = "Mary"

5.times { jane.age_up }

p jane # => #

В этом примере создается экземпляр

Person

@name

p

name=(new_name)

@name

age_up

Обратите внимание, что в методе

initialize

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

Манипулирование данными с использованием переменных и методов экземпляра

Все данные внутри объекта хранятся в переменных экземпляра; их имена всегда начинаются с символа

@

Начальное значение переменной экземпляра может быть задано либо внутри метода

initialize

initialize

initialize

nil

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

class Point

  def initialize(@x : Int32, @y : Int32)

  end

end

origin = Point.new(0, 0)

В этом первом случае класс

Point

initialize

class Cat

  @birthday = Time.local

  def adopt(name : String)

    @name = name

  end

end

my_cat = Cat.new

my_cat.adopt("Tom")

Теперь у нас есть класс, описывающий кошку. У него нет метода

initialize

@birthday

Time.local

initialize

Time

Time.local

@name

String?

String | Nil

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

class Person

 def initialize(first_name, last_name)

  @name = first_name + " " + last_name

 end

end

person = Person.new("John", "Doe")

В этом примере переменная

@name

+

String

+

class Person

 @name : String

 def initialize(first_name, last_name)

  @name = first_name + " " + last_name

 end

end

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

class Person

 def initialize(first_name, last_name)

  @name = "#{first_name} #{last_name}"

 end

end

В любой ситуации допускается явное объявление типа переменной экземпляра, возможно, для ясности.

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

obj.@ivar

Создание геттеров и сеттеров

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

class Person

  def initialize(@name : String)

  end

end

Мы уже можем создать нового человека и проверить его:

person = Person.new("Tony")

p person

Но было бы неплохо иметь возможность написать что-то вроде следующего, как если бы

@name

puts "My name is #{person.name}"

person.name

person

class Person

  def name

    @name

  end

end

Теперь вызов person.name действителен, как если бы переменная экземпляра была доступна извне. В качестве дополнительного преимущества будущий рефакторинг может изменить внутреннюю структуру объекта и переопределить этот метод, не затрагивая пользователей. Это настолько распространено, что специально для этого существует служебный макрос:

class Person

  getter name

end

Предыдущие два фрагмента ведут себя одинаково. Макрос-получатель создает метод, предоставляющий переменную экземпляра. Его также можно комбинировать с объявлением типа или начальным значением:

class Person

  getter name : String

  getter age = 0

  getter height : Float64 = 1.65

end

Несколько геттеров могут быть созданы в одной строке:

class Person

  getter name : String, age = 0, height : Float64 = 1.65

end

Для сеттеров логика очень похожа. Имена методов Crystal могут заканчиваться символом

=

class Person

  def name=(new_name)

    puts "The new name is #{new_name}"

  end

end

Этот метод

name=

person = Person.new("Tony")

person.name = "Alfred"

Последняя строка представляет собой просто вызов метода и не меняет значение переменной экземпляра

@name

person.name=("Alfred")

=

class Person

  def name=(new_name)

    @name = new_name

  end

end

Теперь он будет вести себя так, как если бы имя было общедоступным свойством объекта. Макрос установки может создавать для вас эти методы, подобно макросу геттера, который мы только что видели:

class Person

  setter name

end

Его также можно использовать с объявлением типа или начальным значением.

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

class Person

  property name

end

Это то же самое, что написать следующее:

class Person

  def name

    @name

  end

  def name=(new_name)

    @name = new_name

  end

end

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

Наследование

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

Person

class Person

  property name : String

  def initialize(@name)

  end

end

class Employee < Person

  property salary = 0

end

Экземпляр

Employee

Person

employee

person = Person.new("Alan")

employee = Employee.new("Helen")

employee.salary = 10000

p person.is_a? Person # => true

p employee.is_a? Person # => true

p person.is_a? Employee # => false

В этом примере родительским классом является

Person

Employee

class Employee

  def yearly_salary

    12 * @salary

  end

end

class SalesEmployee < Employee

property bonus = 0

  def yearly_salary

    12 * @salary + @bonus

  end

end

В этом примере мы видим, что ранее определенный класс

Employee

Person

yearly_salary

Employee

Employee

Person

yearly_ salary

SalesEmployee

Employee

При наследовании от класса и переопределении метода ключевое слово

super

yearly_salary

def yearly_salary

  super + @bonus

end

Поскольку метод

initialize

super

Теперь, когда мы определили несколько классов и подклассов, мы можем воспользоваться еще одной мощной концепцией: объекты типа подкласса могут храниться в переменной, типизированной для хранения одного из его базовых классов.

Полиморфизм

SalesEmployee

Employee

employee1 = Employee.new("Helen")

employee1.salary = 5000

employee2 = SalesEmployee.new("Susan")

employee2.salary = 4000

employee2.bonus = 20000

employee3 = Employee.new("Eric")

employee3.salary = 4000

employee_list = [employee1, employee2, employee3]

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

Array(Employee)

SalesEmployee

employee_list.each do |employee|

  puts "#{employee.name}'s yearly salary is $#{employee. yearly_salary.format(decimal_places: 2)}."

end

Это приведет к следующему результату:

Elen's yearly salary is $60,000.00.

Susan's yearly salary is $68,000.00.

Eric's yearly salary is $48,000.00.

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

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

Абстрактные классы

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

abstract class Shape

end

class Circle < Shape

  def initialize(@radius : Float64)

  end

end

class Rectangle < Shape

  def initialize(@width : Float64, @height : Float64)

  end

end

И круги, и прямоугольники - это разновидности фигур, и они могут быть поняты сами по себе. Но форма сама по себе является чем-то абстрактным и была создана для наследования. Когда класс является абстрактным, его создание в виде объекта запрещено:

a = Circle.new(4)

b = Rectangle.new(2, 3)

c = Shape.new # This will fail to compile; it doesn't make sense.

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

abstract class Shape

  abstract def area : Number

end

class Circle

  def area : Number

    Math::PI * @radius ** 2

  end

end

class Rectangle

  def area : Number

    @width * @height

  end

end

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

Абстрактный класс не ограничивается абстрактными методами - он также может определять обычные методы и переменные экземпляра.

Переменные класса и методы класса

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

Но классы тоже являются объектами! Разве у них не должны быть переменные экземпляра и методы? Да, конечно.

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

@@

@

class Person

  @@next_id = 1

  @id : Int32

  def initialize(@name : String)

    @id = @@next_id

    @@next_id += 1

  end

end

Здесь мы определили переменную класса с именем

@@next_id

@name

@id

Person

first = Person.new("Adam") # This will have @id = 1

second = Person.new("Jess") # And this will have @id = 2

# @@next_id inside Person is now 3.

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

Person

Подобно переменным класса, методы класса можно определить в самом классе, добавив к его имени префикс

self

class Person

  def self.reset_next_id

    @@next_id = 1

  end

end

Теперь вы можете вызвать

Person.reset_next_id

Поскольку метод класса вызывается для класса, а не для экземпляра класса, в игре нет никакого объекта, а ключевое слово

self

Подобно переменным экземпляра, существуют вспомогательные макросы, помогающие предоставлять переменные класса с помощью методов класса, то есть

class_getter

class_setter

class_property

class Person

  class_property next_id

end

Теперь можно сделать

Person.next_id = 3

x = Person.next_id

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

nil

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

Давайте рассмотрим пример:

def half(num : Int)

  if num.odd?

   raise "The number #{num} isn't even"

  end

  num // 2

end

p half(4) # => 2

p half(5) # Unhandled exception: The number 5 isn't even (Exception)

p half(6) # This won't execute as we have aborted the program.

В предыдущем фрагменте мы определили метод

half

Обратите внимание, что

raise "описание ошибки"

raise Exception. new("описание ошибки")

exception. Exception

Чтобы показать разницу между ошибками во время компиляции и во время выполнения, попробуйте добавить

p half("привет")

Исключения могут быть зафиксированы и обработаны с помощью ключевого слова rescue. Оно чаще используется в выражениях

begin

end

begin

  p half(3)

rescue

  puts "can't compute half of 3!"

end

Если внутри выражения

begin

rescue

begin

  p half(3)

rescue error

  puts "can't compute half of 3 because of #{error}"

end

Здесь мы зафиксировали объект exception и можем его проверить. Мы могли бы даже вызвать его снова, используя

raise error

def half?(num)

  half(num)

rescue

  nil

end

p half? 2 # => 1

p half? 3 # => nil

p half? 4 # => 2

В этом примере у нас есть версия метода

half

half?

Int32 | Nil,

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

half?

def half?(num)

  half(num) rescue nil

end

В реальном мире обычной практикой является пойти наоборот и сначала реализовать метод, который возвращает

nil

Стандартная библиотека содержит множество типов предопределенных исключений, таких как

DivisionByZeroError

IndexError

JSON::Error

Exception

Пользовательские исключения

Поскольку исключения - это обычные объекты, а

Exception

class OddNumberError < Exception

  def initialize(num : Int)

    super("The number #{num} isn't even")

  end

end

def half(num : Int32)

  if num.odd?

    raise OddNumberError.new(num)

  end

  num // 2

end

В этом примере мы создали класс с именем

OddNumberError

Exception

half

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

rescue

def half?(num)

  half(num)

rescue error : OddNumberError

  nil

end

Вы можете повторить несколько блоков

rescue