язык rust пример кода

9f1577058f7ffa3a555d7e6bf485cc0c Мобильные и смартфоны
Содержание
  1. Rust на примерах. Часть 1
  2. Содержание
  3. 1. Привет, мир!
  4. 2. Форматированный вывод
  5. 3. Литералы и операторы
  6. 4. Переменные
  7. 5. Типы
  8. Заключение
  9. Введение в программирование на Rust
  10. Что такое Rust?
  11. Зачем изучать Rust?
  12. «Hello World!» на Rust
  13. Основы синтаксиса Rust
  14. Переменные и их изменяемость
  15. Типы данных
  16. Функции
  17. Комментарии
  18. Условные инструкции
  19. Промежуточный Rust: владение и структуры
  20. Владение
  21. Структуры
  22. Система сборки Rust: Cargo
  23. Продвинутые концепции для дальнейшего изучения
  24. Первые шаги по Rust
  25. Killer feature
  26. Что еще интересного
  27. Еще немного безопасности
  28. Перечисления
  29. А также
  30. Ложки дегтя
  31. Killer problem
  32. Сложность изучения
  33. В итоге
  34. Почитать
  35. Rust: Знакомимся с языком на примере «Угадай-ки»
  36. Создание нового проекта
  37. Обработка догадки
  38. Храним значения в переменных
  39. Обработка завершения с ошибкой (используем Result )
  40. Печать значений посредством println!
  41. Проверка первой части
  42. Генерирование секретного числа
  43. Используем крейты для получения дополнительного функционала
  44. Cargo.lock способствует сборке воспроизводимых (reproducible builds) программ
  45. Обновление крейта до свежей версии
  46. Генерирование случайного числа
  47. Сравниваем догадку с секретным числом
  48. Предлагайте ваши догадки несколько раз
  49. Завершение игры при правильной догадке
  50. Обработка неправильного ввода
  51. Заключение

Rust на примерах. Часть 1

Этот цикл статей является вольным переводом книги «Rust by Example», которую пишет Хорхе Апарисио на Github.

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

Содержание

1. Привет, мир!

Это код традиционной программы «Hello World»:

println! это макрос (мы рассмотрим их позже), который печатает текст в консоль.

Программа может быть сгенерирована с помощью компилятора Rust rustc:

rustc создаст бинарный файл «hello», который можно запустить:

2. Форматированный вывод

Макрос println! не только выводит в консоль, а также способен форматировать текст и сериализованные значения. Корректность проверяется во время компиляции.

Дополнительная информация о форматировании здесь: std​::fmt​

3. Литералы и операторы

Также целые числа можно выразить через шестнадцатеричное, восьмеричное или двоичное обозначение, используя один из префиксов: 0x, 0o или 0b.

В числовые литералы можно вставлять подчёркивания для читабельности, например, 1_000 такой же, как и 1000, а 0.000_001 такой же, как и 0.000001.

Доступные операторы и их приоритет похож на C-подобных языках.

4. Переменные

Значения (как и литералы) могут быть связаны с переменными, используя обозначение let.

4.1 Изменяемость

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

Компилятор будет выводить сообщения об ошибке изменчивости.

4.2 Области и видимость

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

4.3 Предварительное объявление

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

Компилятор запрещает использование неинициализированных переменных, так как это привело бы к непредсказуемым последствиям.

5. Типы

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

5.1 Приведение типов

Rust не предоставляет неявного преобразования типов (coercion) между примитивами, но, явное приведение типов (casting) может быть достигнуто с помощью ключевого слова as.

5.2 Литералы

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

5.3 Логический вывод

Логический вывод типов довольно умён. Тип добавляемой переменной используется как определитель типа для второй переменной. Вот продвинутый пример:

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

5.4 Псевдонимы (алиасы)

Заключение

Присоединяйтесь к google-группе: Rust по-русски для получения дополнительной информации по этому языку.
Можно помочь с переводом на Github: github.com/eg0r/rust-by-example

Все замечания, ошибки или неточности отправляйте мне в почту.

Источник

Введение в программирование на Rust

1*cg92lT113 ksJTFZFvmHMw

Apr 17 · 12 min read

1*aOP b5uCkQRb1gmMCDzpmQ

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

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

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

Вот что мы рассмотрим в статье.

Что такое Rust?

Rust — это мультипарадигмальный статически типизированный язык программирования с открытым исходным кодом, используемый для создания операционных систем, компиляторов и других программно-аппаратных средств. Он был разработан Грейдоном Хором в Mozilla Research в 2010 году.

Rust оптимален с точки зрения производительности и безопасности, причем акцент здесь сделан на безопасном параллелизме. Этот язык больше всего похож на C или C++, но использует средство проверки заимствований для подтверждения безопасности ссылок.

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

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

Зачем изучать Rust?

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

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

«Hello World!» на Rust

Разберем все части этого кода.

fn — это сокращение от function («Функция»). В Rust (как и в большинстве других языков программирования) функция как бы говорит: «Сообщите мне информацию, а я сделаю то-то и то-то и затем дам ответ».

Функция main — это то место, где начинается программа.

Читайте также:  ветеринарная клиника свободы 29 телефон

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

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

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

Основы синтаксиса Rust

Теперь рассмотрим основные части программы на Rust и способы их реализации.

Переменные и их изменяемость

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

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

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

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

Например, вот этот код выдаст ошибку во время компиляции:

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

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

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

Типы данных

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

В этом случае наш пример с объявлением my_name будет переписан следующим образом:

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

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

Основные типы на Rust:

Функции

Функции — это наборы связанного кода на Rust, объединенные под кратким условным обозначением и вызываемые из других частей программы.

Вот формат для объявления функции:

Это уже знакомое нам сокращение от function («Функция»). За ним в коде Rust следует объявление функции.

Здесь находится идентификатор функции, который будет использоваться при ее вызове.

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

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

После параметра необходимо явно указать тип. Во избежание путаницы неявная типизация параметров в Rust запрещена.

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

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

Добавим немного кода. Переделаем hello-world в функцию say_hello() :

Совет? Увидели () — значит, вы имеете дело с вызовом функции. Если параметров нет, получаем внутри скобок пустое поле параметров. Сами скобки все равно остаются, указывая на то, что это функция.

Вот как будет выглядеть полная программа:

Комментарии

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

Совет? используйте комментарии для «закомментирования» разделов кода, выполнение которых не требуется, но которые позже понадобится добавить.

Условные инструкции

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

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

Вот как выглядит формат оператора if :

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

Промежуточный Rust: владение и структуры

Владение

Владение — это центральная особенность Rust и одна из причин такой его популярности.

Во всех языках программирования должна предусматриваться система освобождения неиспользуемой памяти. В некоторых языках, таких как Java, JavaScript или Python, есть сборщики мусора, которые автоматически удаляют неиспользуемые ссылки. В низкоуровневых языках типа C или C++ от разработчиков требуется всякий раз, когда это необходимо, выделять и освобождать память вручную.

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

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

Вот эти правила владения.

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

Структуры

Аналогом этих структур в таких языках, как Java и Python, являются классы.

Вот синтаксис объявления структуры:

Каждый создаваемый экземпляр типа Car должен иметь значения для этих полей. Поэтому создадим экземпляр Car для конкретного автомобиля со значениями для brand (модели) и year (года выпуска).

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

Читайте также:  где находится номер квитанции госпошлины

Вот как выглядит вся структура целиком:

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

Система сборки Rust: Cargo

Cargo — это система сборки и диспетчер пакетов Rust. Это важный инструмент для организации проектов на Rust. Здесь приводится перечень библиотек, необходимых проекту (они называются зависимостями). Он автоматически загружает любые отсутствующие зависимости и собирает программы на Rust из исходного кода.

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

Если скачать Rust с официального сайта, Cargo автоматически устанавливается вместе с компилятором ( rustc ) и генератором документации ( rustdoc ) как часть набора инструментальных средств Rust. Убедиться, что Cargo установлен, помогает ввод в командной строке следующей команды:

Для создания проекта с Cargo запустите в интерфейсе командной строки операционной системы следующее:

Чтобы все это увидеть, наберите:

Продвинутые концепции для дальнейшего изучения

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

Источник

Первые шаги по Rust

raodjnsmyuf5nphvpqwkhcwliyi

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

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

Killer feature

Rust пытается занять промежуточное положение между низкоуровневыми языками типа C/C++ и высокоуровневыми Java/C#/Python/Ruby… Чем ближе язык находится к железу, тем больше контроля, легче предвидеть как код будет выполняться. Но и имея полный доступ к памяти намного проще отстрелить себе ногу. В противовес С/С++ появились Python/Java и все остальные. В них нет необходимости задумываться об очистки памяти. Самая страшная беда — это NPE, утечки не такое уж частое явление. Но чтобы это все работало необходим, как минимум, garbage collector, который в свою очередь начинает жить своей жизнью, параллельно с пользовательским кодом, уменьшая его предсказуемость. Виртуальная машина еще дает платформонезависимость, но на сколько это необходимо — спорный вопрос, не буду его сейчас поднимать.

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

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

Эту концепцию можно продемонстрировать в следующем куске кода. Из метода main() вызывается test(), в котором создается рекурсивная структура данных MyStruct, реализующая интерфейс деструктора. Drop позволяет задать логику для выполнения, перед тем как объект будет уничтожен. Чем-то похоже на финализатор в Java, только в отличие от Java, момент вызова метода drop() вполне определен.

Вывод будет следующим:

Т.е. перед выходом из test() память была рекурсивно очищена. Позаботился об этом компилятор, вставив нужный код. Что такое Box и Option опишу чуть позже.

Таким образом Rust берет безопасность от высокоуровневых языков и предсказуемость от низкоуровневых языков программирования.

Что еще интересного

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

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

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

Из особенностей на которые я обратил внимание, стоит отметить следующее:

Еще немного безопасности

Как я уже говорил Rust уделяет большое внимание надежности кода и пытается предотвратить большинство ошибок на этапе компиляции. Для этого была исключена возможность делать ссылки пустыми. Это мне чем-то напомнило nullable типы из Kotlin. Для создания пустых ссылок используется Option. Так же как и в Kotlin, при попытке обратиться к такой переменной, компилятор будет бить по рукам, заставляя вставлять проверки. Попытка же вытащить значение без проверки может привести к ошибке. Но этого уж точно нельзя сделать случайно как, например, в Java.

Мне еще понравилось то, что все переменные и поля классов по умолчанию являются неизменяемыми. Опять привет Kotlin. Если значение может меняться, это явно надо указывать ключевым словом mut. Я думаю, стремление к неизменяемости сильно улучшает читабельность и предсказуемость кода. Хотя Option почему-то является изменяемым, этого я не понял, вот код из документации:

Перечисления

В Rust называются enum. Только помимо ограниченного числа значений они еще могут содержать произвольные данные и методы. Таким образом это что-то среднее между перечислениями и классами в Java. Стандартный enum Option в моем первом примере как раз принадлежит к такому типу:

Для обработки таких значений есть специальная конструкция:

А также

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

Читайте также:  обновление базы номеров телефонов

Ложки дегтя

Этот раздел необходим для полноты картины.

Killer problem

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

И это неполный список. Для первой пробы Rust, я опрометчиво решил написать односвязный список с базовыми методами. В конечном счете ссылка на узел получилась следующая Option >:

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

На Kotlin то же самое выглядит намного проще:

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

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

Сложность изучения

Долгий процесс изучения Rust во многом следует из предыдущего раздела. Перед тем как написать вообще хоть что-то придется потратить время на освоение ключевой концепции владения памятью, т.к. она пронизывает каждую строчку. К примеру, простейший список у меня занял пару вечеров, в то время как на Kotlin то же самое пишется за 10 минут, при том что это не мой рабочий язык. Помимо этого многие привычные подходы к написанию алгоритмов или структур данных в Rust будут выглядеть по другому или вообще не сработают. Т.е. при переходе на него понадобится более глубокая перестройка мышления, просто освоить синтаксис будет недостаточно. Это далеко не JavaScript, который все проглотит и все стерпит. Думаю, Rust никогда не станет тем языком, на котором учат детей в школе программирования. Даже у С/С++ в этом смысле больше шансов.

В итоге

Мне показалась очень интересной идея управления памятью на этапе компиляции. В С/С++ у меня опыта нет, поэтому не буду сравнивать со smart pointer. Синтаксис в целом приятный и нет ничего лишнего. Я покритиковал Rust за сложность реализации графовых структур данных, но, подозреваю, что это особенность всех языков программирования без GC. Может быть, сравнения с Kotlin было и не совсем честным.

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

Почитать

Если вас заинтересовал Rust, то вот несколько ссылок:

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

Источник

Rust: Знакомимся с языком на примере «Угадай-ки»

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

Для того чтобы создать новый проект:

Если сведения об авторе, которые Cargo получил из вашей системы, неправильные, исправьте конфигурационный файл и сохраните. По умолчанию в новом проекте содержится «Hello, world».
src/main.rs

Давайте соберем программу и запустим:

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

Обработка догадки

Первая часть нашей программы будет просить пользователя ввести его догадку, обрабатывать его ввод и проверять, что он корректен (valid). Для начала давайте дадим пользователю ввести его догадку: Здесь и далее все изменения вносятся в src/main.rs :

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

fn позволяет объявить новую функцию, () указывает на то, что функция не принимает параметров, < предваряет тело функции. println! — макрос ( macro ), который выводит строку на консоль:

Храним значения в переменных

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

читается несколько тяжелее.

Обработка завершения с ошибкой (используем Result )

Печать значений посредством println!

<> является «заполнителем» (placeholder), указывает на то, что в полученной строке будет значение соответствующей этому заполнителю переменной. Чтобы напечатать несколько значений, используйте несколько заполнителей: первый заполнитель ( <> ) соответствует первому выводимому значению, второй — второму и т.д. Например, так:

Проверка первой части

Программа запросила число, мы ввели, программа вывела это число — все работает. Идем дальше.

Генерирование секретного числа

Используем крейты для получения дополнительного функционала

Cargo.lock способствует сборке воспроизводимых (reproducible builds) программ

Обновление крейта до свежей версии

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

Генерирование случайного числа

Программа должна каждый раз выводить разные случайные числа от 1 до 100.

Сравниваем догадку с секретным числом

После того как мы сгенерировали случайное число и получили догадку от пользователя, мы можем сравнить их. Внесем изменения в src/main.rs

Здесь был добавлен код:

Отлично! Несмотря на то что перед догадкой были введены пробелы, программа выяснила, что пользователь предложил 76. Запустите программу несколько раз и удостоверьтесь, что программа по-разному реагирует на разные догадки пользователя:

Предлагайте ваши догадки несколько раз

Ключевое слово loop позволяет нам создать бесконечный цикл. Добавим:

Как вы можете видеть, мы поместили все в цикл. Запустим:

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

Завершение игры при правильной догадке

Подведем последний штрих, добавив break для выхода из игры после выигрыша игрока:

Обработка неправильного ввода

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

Отлично. Осталось удалить из программы код печати задуманного числа.

Заключение

Здесь были представлены основные концепции языка Rust:

Источник

Мобилка
Adblock
detector