Rust учебник
Начало работы с Rust

замечания

Версии

Расширенное использование println!

println! (и его брат, print! ) обеспечивает удобный механизм для создания и печати текста, который содержит динамические данные, аналогичные семейству функций printf найденным на многих других языках. Его первым аргументом является строка формата , которая определяет, как другие аргументы должны быть напечатаны как текст. Строка формата может содержать заполнители (заключенные в {} ), чтобы указать, что должна произойти замена:

// No substitution -- the simplest kind of format string
println!("Hello World");
// Output: Hello World

// The first {} is substituted with a textual representation of
// the first argument following the format string. The second {}
// is substituted with the second argument, and so on.
println!("{} {} {}", "Hello", true, 42);
// Output: Hello true 42

На этом этапе вы можете спросить: как println! знать, чтобы напечатать логическое значение true как строку «true»? {} действительно является инструкцией для форматирования, что значение должно быть преобразовано в текст, используя показатель Display . Эта черта реализована для большинства примитивных типов ржавчины (строки, числа, булевы и т. Д.) И предназначена для «пользовательского вывода». Следовательно, число 42 будет напечатано в десятичном виде как 42, а не, скажем, в двоичном виде, то есть как оно хранится внутри.

Как мы печатаем типы, которые не реализуют Display , примеры - [i32] ( [i32] ), векторы ( Vec<i32> ) или опции ( Option<&str> )? Нет четкого пользовательского текстового представления (т. Е. Вы можете тривиально вставлять в предложение). Чтобы облегчить печать таких значений, Rust также имеет свойство Debug и соответствующий {:?} Placeholder. Из документации: « Debug должна форматировать вывод в контексте программирования, отладочном контексте». Давайте посмотрим несколько примеров:

println!("{:?}", vec!["a", "b", "c"]);
// Output: ["a", "b", "c"]

println!("{:?}", Some("fantastic"));
// Output: Some("fantastic")

println!("{:?}", "Hello");
// Output: "Hello"
// Notice the quotation marks around "Hello" that indicate
// that a string was printed.

Debug также имеет встроенный механизм довольно печати, который вы можете включить с помощью модификатора # после двоеточия:

println!("{:#?}", vec![Some("Hello"), None, Some("World")]);
// Output: [
//    Some(
//        "Hello"
//    ),
//    None,
//    Some(
//        "World"
//    )
// ]

Строки формата позволяют выразить довольно сложные замены :

// You can specify the position of arguments using numerical indexes.
println!("{1} {0}", "World", "Hello");
// Output: Hello World

// You can use named arguments with format
println!("{greeting} {who}!", greeting="Hello", who="World");
// Output: Hello World

// You can mix Debug and Display prints:
println!("{greeting} {1:?}, {0}", "and welcome", Some(42), greeting="Hello");
// Output: Hello Some(42), and welcome

println! и друзья также предупреждают вас, если вы пытаетесь сделать что-то, что не будет работать, а не сбой во время выполнения:

// This does not compile, since we don't use the second argument.
println!("{}", "Hello World", "ignored");

// This does not compile, since we don't give the second argument.
println!("{} {}", "Hello");

// This does not compile, since Option type does not implement Display
println!("{}", Some(42));

По своей сути макросы печати Rust - это просто обертки вокруг format! макрос, который позволяет создавать строку путем сшивания текстовых представлений разных значений данных. Таким образом, для всех приведенных выше примеров вы можете заменить println! для format! для сохранения форматированной строки вместо ее печати:

let x: String = format!("{} {}", "Hello", 42);
assert_eq!(x, "Hello 42");

Консольный вывод без макросов

// use Write trait that contains write() function
use std::io::Write;

fn main() {
    std::io::stdout().write(b"Hello, world!\n").unwrap();
}

• std::io::Write trait предназначен для объектов, которые принимают потоки байтов. В этом случае дескриптор стандартного вывода получается с помощью std::io::stdout() .

• Write::write() принимает байтовый срез ( &[u8] ), который создается с помощью литерала с байтовой строкой ( b"<string>" ). Write::write() возвращает Result<usize, IoError> , который содержит либо количество записанных байтов (по успеху), либо значение ошибки (при сбое).

• Вызов Result::unwrap() указывает, что ожидается, что вызов будет успешным ( Result<usize, IoError> -> usize ), и значение будет отброшено.

Минимальный пример

Чтобы написать традиционную программу Hello World в Rust, создайте текстовый файл hello.rs содержащий следующий исходный код:

fn main() {
    println!("Hello World!");
}

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

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

$ rustc hello.rs

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

$ ./hello
Hello World!

В системе Windows запустите:

C:\Rust> hello.exe
Hello World!

Начиная

Установка

Прежде чем вы сможете что-либо использовать с использованием языка программирования Rust, вам нужно будет его приобрести - либо для Windows, либо используя ваш терминал в Unix-подобных системах, где $ символизирует вход в терминал:

$ curl https://sh.rustup.rs -sSf | sh

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

Примечание. Некоторые дистрибутивы Linux (например, Arch Linux ) предоставляют rustup как пакет, который можно установить вместо него. И хотя многие Unix-подобные системы обеспечивают rustc и cargo как отдельные пакеты, по-прежнему рекомендуется использовать rustup поскольку это упрощает управление несколькими каналами выпуска и выполняет кросс-компиляцию.

Компилятор ржавчины

Теперь мы можем проверить, действительно ли Rust был успешно установлен на наших компьютерах, выполнив следующую команду либо в нашем терминале - если в UNIX - или в командной строке - если в Windows:

$ rustc --version

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

грузовой

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

$ cargo --version

Как и эквивалентная команда для компилятора Rust , это вернет и отобразит текущую версию Cargo .

Чтобы создать свой первый проект Cargo, вы можете отправиться в Cargo .

Кроме того, вы можете скомпилировать программы напрямую с помощью rustc как показано в минимальном примере .