Oleg Alexandrov

Rust

← Назад к перечню шпаргалок

Keyword Пример Описание
let let thing: i32 = 100;  
  let (part1, part2) = ("first", "second");  
  let shadowing_example = 123.4;  
  let shadowing_example = shadowing_example as u32;  
  let (part1, part2) = ("first", "second");  
let mut let mut changing_thing = true;  
  changing_thing = false;  
static static LANGUAGE: &str = "Rust"; Изменяемая переменная с временем жизни 'static.
static mut    
const const THRESHOLD: i32 = 10; Неизменяемая переменная.
  const WORDS: &'static str = "hello rust!";  

Типы

Data Type Example
i8 let data: i8 = -100;
i16 let data: i16 = -32_000;
i32 let data: i32 = -2_147_483_648;
i64 let data: i64 = -9_223_372_036_854_775_808;
i128 let data: i128 = -170_141_183_460_469_231...;
isize let data: isize = {i32 or i64, OS dependent};
u8 let data: u8 = 255;
u16 let data: u16 = 65535;
u32 let data: u32 = 4_294_967_295;
u64 let data: u64 = 18_446_744_073_709_551_615;
u128 let data: u128 = 340_282_366_920_938_463...;
usize let data: usize = {u32 or u64, OS dependent};
f32 let data: f32 = 3.14;
f64 let data: f64 = 3.141592653589793238;
bool let data: bool = true;
char let data: char = 'z';
str let data: &str = "Hello, world!";
array let data: [i32; 5] = [1, 2, 3, 4, 5];
tuple let data: (i32, f64, &str) = (500, 6.4, "hello");
slice let data: &[i32] = &[1, 2, 3][..];
unit let data: () = ();
function fn main() {}
struct struct User {name: String, age: u32}
enum enum Color {Red, Green, Blue}
trait trait Summary {fn summarize(&self) -> String;}
reference let data: &i32 = &1;
Vec let data: Vec<i32> = vec![1, 2, 3];
String let data: String = String::from("hello");
Smart Pointer Example Explanation
Box let data: Box<i32> = Box::new(5); позволяет хранить данные в куче, а не в стеке.
Rc let rc_type: Rc<i32> = Rc::new(5); умный указатель с подсчётом ссылок.
Weak let data: Weak<i32> = Weak::downgrade(&rc_type);  
Arc let data: Arc<i32> = Arc::new(5); атомарный подсчет ссылок.
RefCell let data: RefCell<i32> = RefCell::new(5); предоставляет единоличное владение данными.
Cell let data: RefCell<Cell<i32>> = RefCell::new(Cell::new(5));  
Deref   изменяет поведение оператора разыменования *.
Drop   позволяет регулировать, что происходит, когда значение выйдет из области видимости.
Async Type Example Explanation
Future let future: Future = async { 5 };  
Stream let stream: Stream = (0..5).into_stream();  
Pin let pin: Pin = Pin::new(future);  
JoinHandle let handle: JoinHandle = tokio::spawn(async {});  
Poll let poll: Poll = future.poll();  
Ready let ready: Ready = Poll::Ready(5);  
Pending let pending: Pending = Poll::Pending;  
Task let task: Task = tokio::spawn(async {});  
Context let context: Context = &mut Context::from_waker(waker);  
Waker let waker: Waker = noop_waker();  
Concurrency + Async Example
std::thread thread::spawn(move ll {});
std::sync::mpsc let (tx, rx) = mpsc::channel();
std::thread::JoinHandle let handle = std::thread::spawn(move ll {}); handle.join();
tokio::task::JoinHandle let handle = tokio::spawn(async {}); handle.await.unwrap();
std::sync::Arc let arc = Arc::new(vec![1, 2, 3]); let arc_clone = arc.clone();
std::sync::Mutex let mutex = Mutex::new(0); let mut guard = mutex.lock().unwrap(); *guard = 1;
tokio::sync::Mutex let mutex = Mutex::new(0); let mut guard = mutex.lock().await; *guard = 1;
std::sync::RwLock let rwlock = RwLock::new(0); let mut guard = rwlock.write().unwrap(); *guard = 1;
std::sync::Barrier let barrier = Arc::new(Barrier::new(3)); let b = barrier.clone(); spawn(move ll b.wait();)
std::sync::Condvar let pair = Mutex::new((0, Condvar::new())); let pair = pair.clone(); spawn(move ll let &(ref lock, ref cvar) = &*pair;) ...
std::sync::Once static START: Once = Once::new(); START.call_once(ll initialize()); START.call_once(ll println!("This will not run"));

Документация

Example Explanation
/// Комментарий документа внешней строки, используйте его для типов, признаков, функций.
//! Комментарий внутренней строки документа, в основном используемый в начале файла для модуля документа.
// Комментарий к строке. Используйте их для документирования потока кода или внутреннего устройства.
/* … */ Блочный комментарий.
/** … */ Комментарий документа внешнего блока.
/*! … */ Комментарий документа внутреннего блока.

Ключевые слова

Keyword Описание
as выполнить примитивное преобразование, уточнить конкретную характеристику, которую содержит объект, или переименовать элемент в выражении use
async вернуть Future вместо блокирования текущего потока
await приостановить выполнение до тех пор, пока не будет готов результат Future
break немедленно выйти из цикла
const определить константу или неизменяемый сырой указатель
continue досрочно перейти к следующей итерации цикла
crate в пути модуля ссылается на корень пакета
dyn динамическая отсылка к объекту характеристики
else ветвь для конструкций потока управления if и if let в случае, если никакая другая ветвь не была исполнена
enum определить перечисление
extern подключить внешнюю функцию или переменную
false логический литерал «ложь»
fn определить функцию или тип указателя на функцию
for перебор элементов итератора, реализация типажа или указание срока жизни более продолжительного периода
if ветвление на основе результата условного выражения
impl реализовать функциональность непосредственно или через типаж, методы
in часть синтаксиса определения цикла for
let объявить переменную
loop безусловный (бесконечный) цикл
match сопоставить значение с образцами
mod определить модуль
move заставить замыкание принять на себя владение всеми своими захватами
mut обозначить изменяемость для ссылок, сырых указателей или привязок к шаблонам
pub обозначить публичную доступность полей структур, блоков impl или модулей
ref привязка по ссылке
return возврат из функции
Self псевдоним для типа, который мы определяем или реализуем
self объект, содержащий этот метод, или текущий модуль
static глобальная переменная или время жизни на протяжении всего выполнения программы
struct определить структуру
super родительский модуль текущего модуля
trait определить типаж, интерфейс
true логический литерал «истина»
type определить псевдоним типа или ассоциированный тип
union определить union, является только ключевым словом при использовании в объявлении объединения
unsafe обозначить небезопасный код, функции, типажи или реализации
use ввести объекты в область видимости
where обозначить утверждения, которые ограничивают тип
while условный цикл, основанный на результате условного выражения

Соглашения по именованию сущностей

Item Convention
Crates unclear
Modules snake_case
Types UpperCamelCase
Traits UpperCamelCase
Enum variants UpperCamelCase
Functions snake_case
Methods snake_case
General constructors new or with_more_details
Conversion constructors from_some_other_type
Macros snake_case!
Local variables snake_case
Statics SCREAMING_SNAKE_CASE
Constants SCREAMING_SNAKE_CASE
Type parameters concise UpperCamelCase, usually single uppercase letter: T
Lifetimes short lowercase, usually a single letter: ‘a, ‘de, ‘src
Features unclear but see C-FEATURE

as_, to_, into_

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

Префикс Стоимость Владение
as_ бесплатный, свободный заимствованный -> заимствованный (borrowed -> borrowed)
to_ дорогой, ценный заимствованный -> заимствованный; заимствованный -> принадлежащий (типы, не являющиеся копиями); принадлежащий -> принадлежащий (типы копий)
into_ изменяемый, переменная принадлежащий -> принадлежащий (типы, не являющиеся копиями) (owned -> owned)

Например:

Переменные

let age = 36;
age = 25;       // ошибка!
println!("Age = {}", age);

let mut age = 36;
println!("Начальное значение: {}", age);

age = 25;
println!("Конечное значение: {}", age);

let (a, b) = (b, a);

// или

std::mem::swap(&mut a, &mut b);

Затенение переменных (shadowing)

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

let number = 10;
println!("number = {}", number);

let number = 15;
println!("number = {}", number);

let number = 254;
println!("number = {}", number);

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

let _x = 5;
let y = 10;

Format

let x = 42.1337;
let s = format!("{:.2}", x);
println!("{}", s); // 42.13

// Сырая строка
println!(r#"<a href="link.html">ссылка</a>"#); // "<a href="link.html">ссылка</a>"

// Экранирование
println!("<a href=\"link.html\">ссылка</a>"); // <a href="link.html">ссылка</a>

fn takes_u32(x: u32) {
    println!("u32: {x}");
}

fn takes_i8(y: i8) {
    println!("i8: {y}");
}

CLI

Cargo:

Владение (Ownership) и его передача присваиванием (Move)

Правила владения

Ключевое правило: Каждое значение имеет одного и только одного владельца-переменную:

Ссылки и заимствование (References and Borrowing):

Ссылки

← Назад к перечню шпаргалок

This site is open source. Improve this page.