Rust

println!("{}", item);

Приклад: WebAssembly або WASM — це формат виконання, який дає можливість запускати код у браузері та інших середовищах. Практична роль: threads дозволяють виконувати код паралельно, але доступ до shared state потрібно контролювати. Порада: `cargo clippy` варто запускати регулярно, особливо перед pull request. struct User { Створення нового проєкту:

Перевага enum: Rust enum дає можливість описувати різні варіанти стану без небезпечних null або неявних структур.

</syntaxhighlight>

Практична роль: Rust + WebAssembly дає можливість переносити продуктивний код у браузер або sandboxed environment. Практична користь: `?` дає можливість писати чистий код обробки помилок без довгих вкладених `match`. let age: u32 = 25;

Err(error) => println!("Error: {}", error),
New,

Rust має статичну типізацію. Приклад:

!

FFI і взаємодія з C

struct User {

count = 11; Rust підтримує потоки через стандартну бібліотеку. fn abs(input: i32) -> i32;

fn read_config(path: &str) -> Result<String, io::Error> {

Класичний приклад програми на Rust:

• `Ok(value)` — успішний результат;
• `Err(error)` — помилка. Він має іншу модель мислення, особливо через ownership, borrowing, lifetimes і строгий компілятор. `pub` робить елемент доступним ззовні модуля. Це означає, що код не використовує стандартну бібліотеку, яка залежить від операційної системи.

cargo run

Concurrency у Rust здатна включати:

• `println!`;
• `vec!`;
• `format!`;
• procedural macros;
• derive macros. text.push('!');

Enum

1. ![no_std]

fn print(&self);

let user = User {

cargo fmt Modules допомагають організувати код. Запуск:

Читання файлу

Rust має потужну систему макросів.

• use-after-free;
• double free;
• dangling pointers;
• data races;
• частини memory leaks;
• небезпечного спільного доступу до mutable data;
• багатьох помилок concurrency;
• неконтрольованого доступу до пам’яті. }

Приклад із явним lifetime:

Quit,
let content = fs::read_to_string("data.txt");

}

Rust особливо корисний для системного програмування, CLI, backend-сервісів, embedded, WebAssembly, безпечної concurrency і performance-sensitive software. * Rust Standard Library Documentation. Водночас Rust має вищий поріг входу, ніж багато популярних мов, і потребує зміни підходу до проєктування даних і ownership.

id: u32,

Blocked,

Embedded Rust

• швидкий запуск;
• один binary;
• хороша продуктивність;
• зручний Cargo;
• кросплатформеність;
• бібліотеки для аргументів, конфігурації й терміналу.== Struct ==

 let mut value = counter.lock().unwrap();

Причини:

 a + b

* персональні інформаційні дані;
* secrets;
* tokens;
* private keys;
* logs;
* error messages;
* telemetry;
* data retention;
* encryption;
* доступи;
* сторонні crates;
* серіалізацію даних. * Документація crates.io.=== Структура і метод ===

Приклад:

}

fn print_status(status: Status) {

Embedded Rust — це використання Rust для мікроконтролерів і вбудованих систем. } }

Приклади задач на Rust

</syntaxhighlight> </syntaxhighlight>

});

Testing

</syntaxhighlight> Типові команди:

pub fn add(a: i32, b: i32) -> i32 {

println!("{}", text);

</syntaxhighlight> Generics часто використовуються разом із traits:

});

• офіційний сайт Rust. Rust

print_text(&message);

Запуск:

• виклику C-бібліотек;
• створення Rust-бібліотек для C;
• інтеграції з legacy code;
• системних API;
• embedded SDK;
• high-performance modules. `Result` має два варіанти:

use std::io; Основні конкурентні переваги Rust:

struct User {

}

if let Some(name) = find_name(1) {

Rust покращує безпеку пам’яті, але не вирішує всі security-проблеми. fn main() { Приклад:

fn main() { Rust має сильну модель concurrency.== Move semantics ==

Lifetimes

}

struct User {

}

• надмірна боротьба з borrow checker;
• зайве використання `clone`;
• використання `String` там, де достатньо `&str`;
• часте `unwrap` без обробки помилок;
• неправильне розуміння lifetimes;
• спроба писати Rust як C++ або Java;
• занадто складні generic types;
• ігнорування Clippy;
• страх перед `Result` і `Option`;
• надмірне використання `Arc<Mutex<T>>`;
• спроба використовувати unsafe без потреби.

  '''Перевага Embedded Rust:''' він намагається дати безпечніші абстракції для low-level коду без втрати контролю над ресурсами.</div>
  '''Практичний висновок:''' Python зручний для швидких сценаріїв і data science, а Rust — для продуктивних, надійних і системних компонентів.</div>
  |-
  | Memory safety
  | Сильні перевірки компілятора
  | Переважно відповідальність програміста
  |-
  | Garbage collector
  | Немає
  | Немає
  |-
  | Ownership
  | Вбудована модель ownership
  | Ручна дисципліна
  |-
  | Tooling
  | Cargo, rustfmt, Clippy
  | Залежить від toolchain
  |-
  | Складність
  | Вища концептуально на старті
  | Простий синтаксис, складна пам’ять
  |-
  | Legacy
  | Молодша ERP-платформа
  | Величезна legacy-база
  |}
  
  Приклад оголошення зовнішньої C-функції:
  '''Висновок:''' C дає прямий контроль і величезну legacy-сумісність, а Rust додає сильніші compile-time гарантії безпеки. * Документація rustfmt і Clippy. ./main
   name: String::from("Alice"),
  У Rust змінні за замовчуванням immutable.</div>
  
  <syntaxhighlight lang="rust">
  </div>
  Основні типи:
  <div style="background:#e8f8f5; border-left:6px solid #16a085; padding:12px; margin:12px 0;">
  use std::sync::{Arc, Mutex};
  
  '''Rust''' — це сучасна системна мова програмування, яка поєднує високу продуктивність, відсутність garbage collector і сильні гарантії memory safety. }
  '''Суть прикладу:''' Rust-програма починається з функції `main`, а виведення тексту часто виконується через макрос `println!`. }
  
   fn area(&self) -> u32 {
  Приклад:
  <syntaxhighlight lang="rust">
  <syntaxhighlight lang="rust">
  |-
  | Memory management
  | Ownership без GC
  | Garbage collector
  |-
  | Простота старту
  | Складніший
  | Простіший
  |-
  | Performance
  | Дуже висока
  | Висока
  |-
  | Concurrency
  | Безпечна модель + async/threading
  | Goroutines і channels
  |-
  | Типові задачі
  | Systems, performance, embedded, WASM, backend
  | Cloud services, microservices, DevOps tools
  |}
  
  Rust часто використовують там, де раніше традиційно застосовували C або C++: системні утиліти, серверні застосунки, embedded, WebAssembly, CLI-інструменти, мережеві сервіси, інфраструктурне програмне забезпечення (ПЗ), криптографія, блокчейн, ігрові рушії та високопродуктивні бібліотеки. '''Суть impl:''' `impl` дає можливість додавати поведінку до типів без класичної об’єктної моделі з inheritance. let counter = Arc::clone(&counter);
  '''Generics''' дозволяють писати код, який функціонує з різними типами. Ok(a / b)
  '''Суть trait:''' trait описує, що тип уміє робити, не прив’язуючись до конкретної реалізації. '''Головна думка:''' Rust — це мова для продуктивного й надійного програмування, де компілятор оптимізує знаходити помилки пам’яті та concurrency ще до запуску програми. println!("{}", rect.area());
  
  Rust має вбудовану підтримку тестування. * Rust by Example. }
  
  }
  
   // низькорівневі операції
  
  }
  cargo clippy
  
  <div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">
  </div>
  [package]
  '''impl''' застосовується для для реалізації методів для типу. fn main() {
  
  * web apps;
  * high-performance browser logic;
  * plugins;
  * sandboxed execution;
  * cross-platform modules;
  * edge computing;
  * game logic;
  * cryptography in browser.<syntaxhighlight lang="rust">
  

}

Приклад:

}

Практична роль: struct застосовують, коли потрібно для опису об’єктів, конфігурацій, даних API, доменних моделей і стану програми. fn print_item<T: std::fmt::Display>(item: T) { критично: Option змушує програміста явно обробити випадок відсутності значення. } else {

Cargo

 height: 5,

* unsafe code;
* dependency vulnerabilities;
* supply chain risks;
* cryptographic correctness;
* input validation;
* authentication;
* authorization;
* secrets;
* логування чутливих даних;
* network security;
* business logic bugs;
* panic у production;
* race conditions у зовнішніх системах. '''Cargo.toml''' — це конфігураційний файл Rust-проєкту. У Rust останній вираз без крапки з комою здатна бути значенням, що повертається.</div>

'''критично:''' Rust не потрібно використовувати всюди. }

Рекомендовано:
 Err(String::from("Division by zero"))
</div>
Rust оптимізує уникати багатьох типових помилок:
 println!("Found: {}", name);

'''Суть mutability:''' Rust заохочує незмінність за замовчуванням, а змінність потрібно вказувати явно. * Cargo Book.

Суть ownership: Rust знає, хто відповідає за значення, і автоматизовано звільняє ресурс, коли власник більше не потрібен. Його сила — у надійності й контролі, а не в мінімальному порозі входу. Rust не має звичайного `null` для більшості safe-сценаріїв. Python

Безпека Rust

Практична роль: Cargo робить тестування частиною стандартного Rust workflow. name = "my_app"

println!("Hello from thread");

! fn main() {

let counter = Arc::new(Mutex::new(0));

enum у Rust набагато потужніший, ніж enum у багатьох інших мовах. struct User {

Тематичні мітки

} fn main() { }

use serde::{Deserialize, Serialize};

Підказка: у Rust-прикладах критично дивитися не лише на синтаксис, а й на ownership, Result, Option і borrowing. Увага: макроси Rust потужні, але їх варто використовувати там, де вони справді спрощують код, а не приховують логіку. Rust застосовується для для backend-розробки. Cargo застосовується для для: fn main() {

</syntaxhighlight>

!

extern "C" {
 add_exclamation(&mut message);
Приклади:

let active: bool = true;
Rust здатна бути не найкращим вибором для:
cargo clippy
Можливі складнощі:
! * The Rust Programming Language. Err(error) => eprintln!("Error: {}", error),

{| class="wikitable"

* неідіоматичний код;
* потенційні помилки;
* зайві clones;
* неправильні patterns;
* simplifications;
* performance issues;
* readability issues. '''Практична роль:''' Tokio виступає як одним із ключових інструментів для production async Rust. * dangling references;
* use-after-free;
* double free;
* data races;
* некоректному shared mutable state;
* частині invalid memory access. Rust здатна взаємодіяти з C через FFI. }
}
Rust часто порівнюють із C.== Rust і C++ ==

<div style="background:#eef2ff; border-left:6px solid #4f46e5; padding:12px; margin:12px 0;">
}
}

'''Увага:''' `Arc<Mutex<T>>` корисний, але надмірне використання shared mutable state здатна ускладнювати програму.</div>
 match read_config("config.toml") {
<div style="background:#e8f8f5; border-left:6px solid #16a085; padding:12px; margin:12px 0;">

 let rect = Rectangle {

'''критично:''' no_std не означає “без Rust”. Приклад:

<div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">
#[derive(Debug)]
Rust застосовується для у різних напрямах розробки. Коли власник виходить з області видимості, значення автоматизовано звільняється. '''Суть Result:''' помилки виступає як частиною типу, тому їх важче випадково проігнорувати. Але воно покладає частину відповідальності за безпеку на програміста. Go
</div>
Rust дуже популярний для створення command-line tools. Критерій

</div>

</div>

'''критично:''' у production-коді краще повертати `Result`, а не покладатися на `panic!` для звичайних помилок. * Rustonomicon. C

== Crates ==
 println!("Not found");
<div style="background:#f0eaff; border-left:6px solid #8e44ad; padding:12px; margin:12px 0;">
Приклад derive:
|-
| Виконання
| Компіляція
| Інтерпретований runtime
|-
| Швидкість розробки
| Повільніший старт, суворіший компілятор
| Дуже швидке прототипування
|-
| Performance
| Дуже висока
| Нижча для CPU-bound задач
|-
| Memory management
| Ownership
| Garbage collector
|-
| Типові задачі
| Systems, backend, CLI, WASM, embedded
| Data science, scripting, web, automation, AI
|}

let letter: char = 'A';
'''Перевага:''' Rust змушує програміста явно описувати ownership, borrowing і mutability, тому багато помилок знаходяться ще під час компіляції.</div>

* `clap`;
* `structopt`;
* `anyhow`;
* `thiserror`;
* `serde`;
* `tokio`;
* `tracing`. Rust і Go часто порівнюють у backend-розробці. Приклад:
Rust добре підходить, коли потрібні:
}
 name: String,

</syntaxhighlight> </syntaxhighlight>

<syntaxhighlight lang="toml">

Rust не використовує exceptions у звичному стилі. fn main() {
<syntaxhighlight lang="rust">
Serde застосовується для для:

Приклад:
</div>
FFI застосовується для для:
Приклад:
{| class="wikitable"

У цьому прикладі:

 New,
use std::fs;
'''Суть match:''' Rust змушує явно опрацьовувати всі важливі варіанти, що зменшує кількість пропущених випадків. '''Lifetimes''' — це спосіб Rust описувати, як довго references залишаються дійсними.== Arc і Mutex ==
}
== Clippy ==

<syntaxhighlight lang="rust">
</div>
Оператор `?` спрощує передачу помилки вище. * `fn main()` — точка входу в програму;
* `println!` — макрос для виведення тексту;
* `!` означає, що викликається макрос, а не звичайна функція. ! C++
<div style="background:#eafaf1; border-left:6px solid #2ecc71; padding:12px; margin:12px 0;">
Traits використовуються для:

'''no_std''' — це режим Rust без стандартної бібліотеки. Популярні crates:

<div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">

<syntaxhighlight lang="bash">
 println!("{}", message);
 println!("{}", user.display_name());
}
'''критично:''' move semantics — одна з причин, чому Rust здатна гарантувати безпеку пам’яті без garbage collector.</div>
</div>

Приклад:
}
}

<div style="background:#e8f8f5; border-left:6px solid #16a085; padding:12px; margin:12px 0;">

Оператор ?

• `async`;
• `await`;
• futures;
• async runtime;
• Tokio;
• async networking;
• async web frameworks. Вони лише описують компілятору, як довго reference здатна бути безпечним. Критерій

* `i8`, `i16`, `i32`, `i64`, `i128`, `isize`;
* `u8`, `u16`, `u32`, `u64`, `u128`, `usize`;
* `f32`, `f64`;
* `bool`;
* `char`;
* `String`;
* `&str`;
* tuples;
* arrays;
* slices;
* structs;
* enums.== Rust і C ==
<div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">
</div>

 let text = String::from("hello");
'''Crate''' — це одиниця компіляції й пакування в Rust. '''Суть borrowing:''' значення можна “позичити” функції, не передаючи їй власність. name: String,

 fn print(&self) {
version = "0.1.0"
 let handle = thread::spawn(move || {
<div style="background:#fff7ed; border-left:6px solid #fb923c; padding:12px; margin:12px 0;">
== Async Rust ==

== rustfmt ==

rustc main.rs
</div>
 id: 1,
</div>
'''Pattern matching''' дає можливість інтуїтивно опрацьовувати enum, Option, Result та інші структури. handle.join().unwrap();
</div>

Приклад:

<div style="background:#fff7ed; border-left:6px solid #fb923c; padding:12px; margin:12px 0;">

'''Висновок:''' Go часто простіший для cloud-сервісів, а Rust краще підходить там, де критичні контроль ресурсів, performance і memory safety.== Concurrency ==
}
}

Популярні web frameworks:
<syntaxhighlight lang="rust">
<syntaxhighlight lang="rust">

'''Небезпека:''' найгірший Rust-код часто виникає тоді, коли програміст намагається обійти модель ownership замість того, щоб перепроєктувати структуру даних.<div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">
</div>
 Err(error) => eprintln!("{}", error),

 }

Функції в Rust оголошуються через `fn`. '''Rust''' — це сучасна компільована мова програмування, орієнтована на безпеку пам’яті, високу продуктивність, надійну конкурентність і системне програмування. Поширені помилки:
fn add(a: i32, b: i32) -> i32 {
== Висновок ==

 }

 let result = add(2, 3);

'''Практична роль:''' rustfmt оптимізує команді писати код в одному стилі без ручного форматування.== Result ==

* REST API;
* microservices;
* high-performance backend;
* WebSocket-сервіси;
* API gateways;
* internal tools;
* edge services. Приклад:
</div>
 Ok(content) => println!("{}", content),

<syntaxhighlight lang="rust">

<syntaxhighlight lang="bash">

 Ok(value) => println!("{}", value),
fn find_user(id: u32) -> Option<String> {
Приклад:
 Some(String::from("Alice"))
'''Практична порада:''' Rust варто обирати, якщо потрібні продуктивність і безпека пам’яті, а команда готова прийняти сувору модель мови. self.width * self.height
</div>

== Error handling ==

<div style="background:#ecfdf5; border-left:6px solid #10b981; padding:12px; margin:12px 0;">

* '''Safe Rust''' — звичайний код із гарантіями компілятора;
* '''Unsafe Rust''' — код, де дозволені низькорівневі операції, які компілятор не здатна на 100% перевірити. Основна відмінність Rust. * дуже швидких прототипів;
* простих CRUD-застосунків;
* команд без часу на навчання;
* задач, де Python або Go дають достатню продуктивність;
* проєктів із сильними вимогами до готових domain-бібліотек, яких у Rust ще немає;
* сценаріїв, де потрібна велика кількість junior-розробників без Rust-досвіду. println!("{}", message);

Safe Rust і Unsafe Rust

};

• Axum;
• Actix Web;
• Rocket;
• Warp;
• Tide.== Serde ==

'''Перевага Cargo:''' Rust має сильну стандартну культуру збірки, тестування й залежностей, тому старт проєкту зазвичай простіший, ніж у C/C++.<div style="background:#fff7ed; border-left:6px solid #fb923c; padding:12px; margin:12px 0;">

</div>
cargo test
Rust і Python мають дуже різні ролі.

impl User { Option застосовується для, коли значення здатна бути або не бути. } }

Borrow checker — це частина компілятора Rust, яка перевіряє правила borrowing.

</syntaxhighlight> Головна перевага: Rust дає можливість писати продуктивний низькорівневий код із сильнішими гарантіями безпеки, ніж традиційні системні мови. cargo build

let handle = thread::spawn(|| {

height: u32,

fn main() {

enum Status {

Приклад:

println!("Async Rust");

</syntaxhighlight>

! match find_user(1) {

Async Rust застосовується для для асинхронного програмування.</syntaxhighlight>

<syntaxhighlight lang="rust">
 };

fn first<T>(items: &[T]) -> Option<&T> {
Після `let b = a;` власником рядка стає `b`, а `a` більше не можна використовувати.<syntaxhighlight lang="bash">
</div>

Коли `text` виходить з області видимості, пам’ять для `String` звільняється автоматизовано. Rust

Основні підходи:
 String::from("data")
<syntaxhighlight lang="rust">
 Status::Active => println!("Active"),
<div style="background:#ecfdf5; border-left:6px solid #10b981; padding:12px; margin:12px 0;">

== Impl ==

 } else {
</div>
fn main() {

 println!("{} {}", user.id, user.name);

<div style="background:#ecfdf5; border-left:6px solid #10b981; padding:12px; margin:12px 0;">

<div style="background:#fff4e5; border-left:6px solid #f39c12; padding:12px; margin:12px 0;">

Ключові елементи:
cargo doc
 format!("{} #{}", self.name, self.id)
У реальних проєктах частіше використовують Cargo, а не прямий виклик `rustc`. }
 width: u32,

let mut message = String::from("hello");

a + b

* threads;
* channels;
* mutex;
* atomic types;
* async/await;
* task runtimes;
* message passing;
* shared state із контролем доступу. #[derive(Serialize, Deserialize)]
== Web development ==
 }
<div style="background:#e8f8f5; border-left:6px solid #16a085; padding:12px; margin:12px 0;">
</div>

let mut handles = vec![];

Status::New => println!("New"),

Приклад:

Коли варто використовувати Rust

критично: Rust не виступає як “простішою заміною C”. a + b

println!("{}", result);

Обмеження Rust

} ! fn main() {

• binary crate — виконувана програма;
• library crate — бібліотека;
• internal crate — частина workspace;
• published crate — пакет на crates.io. Move { x: i32, y: i32 },

• memory safety;
• відсутність garbage collector;
• висока продуктивність;
• сильна типізація;
• borrow checker;
• безпечніша concurrency;
• Cargo;
• хороше tooling;
• pattern matching;
• потужні enums;
• traits і generics;
• зручна обробка помилок через Result;
• придатність для системного програмування;
• WASM;
• embedded;
• FFI з C. }

Практична роль: generics дозволяють створювати гнучкі бібліотеки без втрати типобезпеки.== Див. так само ==

Some(String::from("Alice"))

</syntaxhighlight>

Mutable borrowing

Some(name) => println!("User: {}", name),
if b == 0.0 {

! println!("{}", result);

</syntaxhighlight>

Хороші практики Rust

Clippy — linter для Rust.

Він перетворює Rust-код на виконуваний файл або бібліотеку. Safe Rust запобігає багатьом помилкам:

handles.push(handle);

let status = Status::Active;

use std::thread; </syntaxhighlight>

for handle in handles {

|- | Memory safety | Ownership і borrow checker | RAII, smart pointers, але багато небезпечних можливостей |- | Абстракції | Traits, generics, enums | Classes, templates, inheritance, RAII |- | Tooling | Єдиний Cargo workflow | Різні build systems і package managers |- | Складність | Складний borrow checker | Дуже велика й складна мова |- | Performance | Висока | Висока |}

Типові сценарії:

edition = "2021"

rustfmt — інструмент форматування Rust-коду. id: u32,

Приклад сфер сценарії використання: impl Rectangle { Rust так само порівнюють із C++. Її головні концепції — ownership, borrowing, lifetimes, traits, Result, Option і pattern matching.== Функції == Практична роль: Serde виступає як стандартним вибором для роботи з форматами даних у Rust-проєктах. Практична роль: crates дозволяють повторно використовувати бібліотеки й будувати модульні Rust-проєкти.== Modules == use std::fs;

Borrow checker

Типові помилки початківців

`&message` — це immutable reference. } } }

1. [test]

rustfmt оптимізує: Практична роль: Rust здатна бути хорошим вибором для backend-сервісів, де важливі продуктивність, надійність і контроль ресурсів. } </syntaxhighlight> SEO title: Rust — мова програмування для безпечного системного програмування, продуктивності, пам’яті та concurrency

SEO keywords: Rust, мова програмування Rust, Rust programming language, системне програмування, memory safety, ownership, borrowing, lifetimes, Cargo, crates.io, rustc, traits, enums, pattern matching, Result, Option, async Rust, Tokio, Actix, Axum, WebAssembly, WASM, embedded Rust, concurrency, safe systems programming, програмування

</noinclude>
 {{SEO
Шаблон для службового SEO-опису сторінки. 

}}

mod math {

'''rustc''' — це компілятор Rust. Критерій
== Змінні ==
'''Основна ідея:''' Rust намагається поєднати продуктивність C/C++ із сильнішими гарантіями безпеки пам’яті на етапі компіляції. fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
<div style="background:#fef2f2; border-left:6px solid #ef4444; padding:12px; margin:12px 0;">
'''Головна перевага:''' Rust дає memory safety без garbage collector, використовуючи ownership, borrowing і перевірки компілятора.

}

println!("Hello, world!");

Status::Blocked => println!("Blocked"),

let price: f64 = 19.99;

use std::thread;

Якщо виникає помилка, `?` повертає її з функції. Приклад:

[dependencies]

let content = fs::read_to_string(path)?;

• системне програмування;
• CLI-інструменти;
• серверні застосунки;
• high-performance backend;
• embedded systems;
• WebAssembly;
• мережеві сервіси;
• криптографічні бібліотеки;
• блокчейн;
• game development;
• операційні системи;
• драйвери;
• бази даних;
• компілятори;
• інфраструктурне ПЗ;
• security-sensitive software. if id == 1 {

Критично: FFI часто потребує `unsafe`, тому межі між Rust і C потрібно ретельно перевіряти.== rustc ==

Приклад компіляції одного файлу:

1. [tokio::main]

anyhow = "1"
fn main() {
<syntaxhighlight lang="rust">

У простих випадках компілятор виводить lifetimes сам. b
fn find_name(id: u32) -> Option<String> {

 println!("{}", self.name);

* абстракцій;
* polymorphism;
* generic programming;
* спільних інтерфейсів;
* dependency boundaries;
* тестування;
* бібліотек. handle.join().unwrap();
 }
Він містить:
fn main() {

unsafe {
<div style="background:#fff4e5; border-left:6px solid #f39c12; padding:12px; margin:12px 0;">
 assert_eq!(add(2, 3), 5);

'''Serde''' — одна з найпопулярніших Rust-бібліотек для серіалізації й десеріалізації. None

<syntaxhighlight lang="rust">
 Active,
Приклад:

<syntaxhighlight lang="toml">

</div>
 Ok(text) => println!("{}", text),
fn main() {

Rust добре підходить для WebAssembly. Rust
enum Message {
'''Правило:''' у Rust здатна бути багато immutable references або одна mutable reference, але не обидва варіанти одночасно. Text(String),
</div>

Приклад:

Сценарії:

<syntaxhighlight lang="rust">

* хто володіє значенням;
* чи можна використовувати reference;
* чи не живе reference довше за значення;
* чи немає одночасного mutable і immutable доступу;
* чи немає data race в safe Rust. }

 width: 10,

use std::fs;

 items.first()

* мережевих сервісів;
* async I/O;
* HTTP-серверів;
* TCP/UDP;
* background tasks;
* timers;
* channels;
* високонавантажених backend-систем. Blocked,
Приклад:
<syntaxhighlight lang="rust">
== Коли Rust здатна бути невдалим вибором ==

'''Практична роль:''' rustc не лише компілює код, а й виконує суворі перевірки ownership, borrowing, lifetimes і типів. }
<div style="background:#ecfdf5; border-left:6px solid #10b981; padding:12px; margin:12px 0;">

Для чого застосовується для Rust

fn add(a: i32, b: i32) -> i32 {

Borrowing

Практична роль: async Rust корисний для високонавантажених мережевих сервісів, де потрібно опрацьовувати багато одночасних операцій вводу-виводу. Головне правило: ідіоматичний Rust — це код, який використовує типи, ownership, Result, pattern matching і tests для явного опису коректної поведінки. fn test_add() {

}

Option

} </syntaxhighlight>

Обробка Option

Порада: у Rust-проєкті критично контролювати залежності, features і версії crates, особливо для production. id: 1,

• роботи з raw pointers;
• FFI;
• системних API;
• низькорівневих оптимізацій;
• embedded;
• взаємодії з C;
• реалізації деяких структур даних. let result = math::add(2, 3);

name: String,

Rust і Go

async fn fetch_data() -> String {

Memory safety — одна з головних цілей Rust. * Документація Tokio.== Загальний SEO-опис ==

Pattern matching

Приклад:

• використовувати `cargo fmt`;
• запускати `cargo clippy`;
• писати tests;
• обмежувати `unsafe`;
• документувати unsafe-блоки;
• використовувати `Result` для помилок;
• не зловживати `unwrap` у production;
• уникати зайвих `clone`;
• починати із простих типів;
• використовувати traits для абстракцій;
• контролювати dependencies;
• регулярно оновлювати crates;
• додавати CI;
• перевіряти panic paths;
• писати зрозумілі error messages.=== Простий Result ===

println!("{}", text);

match divide(10.0, 2.0) {

Tokio — популярний async runtime для Rust. let a = String::from("hello");

Суть функції: функція в Rust має чіткі типи аргументів і тип результату.

'''Перевага для CLI:''' Rust дає можливість створювати швидкі й надійні інструменти, які швидко поширювати як один виконуваний файл. '''Ownership''' — це центральна концепція Rust. } else {

! !</div>
 match status {
fn main() {

 None => println!("User not found"),

</div>

== Rust і Python ==

</div>

'''Перевага:''' Rust дає можливість писати concurrent code з сильнішими гарантіями безпеки, ніж багато низькорівневих мов. }

<div style="background:#eafaf1; border-left:6px solid #2ecc71; padding:12px; margin:12px 0;">

* високий поріг входу;
* складність ownership і lifetimes;
* довший час компіляції;
* async Rust здатна бути складним;
* не всі бібліотеки такі зрілі, як у C/C++ або Python;
* borrow checker потребує зміни мислення;
* іноді складніше оперативно написати прототип;
* unsafe все одно потрібен у низькорівневих сценаріях;
* складні generic і trait bounds можуть ускладнювати код. fs::read_to_string(path)
Tokio застосовується для для:
<syntaxhighlight lang="rust">

<div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">

</div>

Rust часто застосовується для в системах, які працюють із важливими даними. Критерій
}
<div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">
Rust в embedded здатна бути корисний через:
'''struct''' дає можливість створювати власні типи даних.

Unsafe потрібен для:

Tokio

Практична роль: типи допомагають Rust знаходити помилки ще під час компіляції. * назву пакета;

• версію;
• edition;
• dependencies;
• dev-dependencies;
• build settings;
• features;
• metadata. Приклад:

Borrowing дає можливість тимчасово передати доступ до значення без передачі ownership.== Ownership ==

Практична роль: borrow checker часто здається суворим, але саме він знаходить багато помилок до запуску програми.

fn main() {
cargo fmt

[dependencies]

use std::io;
let mut count = 10;
 name: String::from("Alice"),

Він контролює: </syntaxhighlight> застосовується для для:

Приклад: Приклад:

async fn main() {

</syntaxhighlight>

</syntaxhighlight> cargo run Щоб змінна була змінною, потрібно явно написати `mut`: fn main() {

}

}

CLI-інструменти

tokio = { version = "1", features = ["full"] }
{| class="wikitable"
}

} Для запуску async-коду зазвичай потрібен runtime, як приклад Tokio.== WebAssembly == </syntaxhighlight>

Cargo.toml

критично: lifetimes не подовжують життя об’єктів. let user = User {

Threads

let count = 10; fn main() {

no_std

Потрібно контролювати:

Висновок: Rust і C++ обидві підходять для high-performance systems, але Rust більше фокусується на memory safety через типову систему й borrow checker.== Типи даних ==

cargo check

• підтримувати єдиний стиль;
• зменшувати суперечки про формат;
• покращувати читабельність;
• цифровізувати formatting у CI. serde = "1"

}

Необхідно контролювати:

id: u32,
fn display_name(&self) -> String {
name: String,

 } else {

}
Clippy оптимізує знаходити:
<div style="background:#e7f3ff; border-left:6px solid #2b7cff; padding:12px; margin:12px 0;">
fn print_text(text: &String) {
'''Практична роль:''' modules дозволяють розділяти великий Rust-проєкт на зрозумілі частини. У Rust значення здатна бути переміщене від одного власника до іншого.

}

println!("{}", *counter.lock().unwrap());

name: String,

Макроси

Rust має два режими:

Result застосовується для для обробки помилок.

} Критично: `unsafe` не вимикає всі перевірки Rust. Правило: навіть memory-safe мова не захищає від логічного витоку даних, якщо програма сама записує secrets у logs або передає їх не туди.== Перша програма на Rust ==

Запуск тестів:

Приватність даних

Active,

id: u32,

`Arc` і `Mutex` часто використовуються для безпечного спільного стану між потоками. };

} cd hello_rust

Memory safety

}

*value += 1;

 }
cargo new hello_rust

}
<div style="background:#e8f8f5; border-left:6px solid #16a085; padding:12px; margin:12px 0;">
Enum здатна так само містити інформаційні дані:

Щоб змінити значення через reference, потрібне mutable borrowing. let b = a;

fn main() {

• JSON;
• YAML;
• TOML;
• MessagePack;
• API;
• конфігурацій;
• збереження даних;
• обміну повідомленнями.

  fn add_exclamation(text: &mut String) {
  Приклад:
  
  Залежності описуються у файлі `Cargo.toml`. // println!("{}", a); // помилка: a більше не виступає як власником
  == Джерела ==
   }
  
  enum Status {
  
  <div style="background:#fff7ed; border-left:6px solid #fb923c; padding:12px; margin:12px 0;">
  '''Помилка:''' очікувати, що Rust одразу буде таким же швидким у розробці, як Python або JavaScript. Rust
  <div style="background:#ecfdf5; border-left:6px solid #10b981; padding:12px; margin:12px 0;">
  
  }
  
  trait Printable {
  
   if id == 1 {
  
  </div>
  

fn read_file(path: &str) -> Result<String, io::Error> {

Кожне значення в Rust має власника. * Документація Serde.

</syntaxhighlight>

• embedded;
• kernels;
• bootloaders;
• bare-metal;
• constrained environments;
• операційних систем;
• firmware.

match content {

struct Rectangle {

Cargo — це офіційний build system і package manager для Rust. платформа ownership і borrowing забезпечується через Rust створений; так само реалізовано яка дає можливість компілятору перевіряти правильність роботи з пам’яттю ще до запуску програми виступає ключовою рисою розробки швидкого й надійного програмного забезпечення без garbage collector.

 println!("{}", b);
cargo test
'''Trait''' описує поведінку, яку здатна реалізувати тип. * Rust Reference.</div>
через через ownership і type system Rust користувачі можуть уникати data races. ! * memory safety;
* no_std;
* контролю ресурсів;
* відсутності garbage collector;
* strong typing;
* безпечнішим abstractions;
* функції ERP працювати близько до hardware. Найбільшу цінність він дає там, де помилки пам’яті, продуктивність і надійність справді критичні. Crate здатна бути:
 } else {
!

Приклад:

Rust має обмеження. impl Printable for User {

if a.len() > b.len() {

fn divide(a: f64, b: f64) -> Result<f64, String> {

let message = String::from("hello");

Generics

конкурентні переваги Rust

}

}

Traits

• створення проєктів;
• збірки;
• запуску;
• тестування;
• керування залежностями;
• публікації crates;
• форматування workflow;
• запуску прикладів;
• документації.

• `Result<T, E>` для recoverable errors;
• `Option<T>` для відсутності значення;
• `panic!` для unrecoverable errors;
• `?` для передачі помилок;
• crates на кшталт `thiserror` і `anyhow`. for _ in 0..5 {

• висока продуктивність;
• memory safety;
• системне програмування;
• CLI tools;
• backend із високим навантаженням;
• embedded;
• WebAssembly;
• безпечна concurrency;
• криптографія;
• low-level libraries;
• FFI;
• довгострокова надійність;
• контроль ресурсів.

Критично: Rust зменшує клас memory-safety bugs, але не скасовує security review, threat modeling, тестування й контроль залежностей. a

Ok(content)

// count = 11; // помилка }

None

• Програмування
• Мова програмування
• Мова програмування C
• C++
• Go
• Python
• Системне програмування
• Низькорівневе програмування
• Memory safety
• Ownership
• Borrowing
• Cargo
• WebAssembly
• Embedded Rust
• Tokio
• Serde
• CLI
• Backend
• Безпека застосунків
• Налагодження коду
• Логування
• Алгоритм
• Структура даних

Приклад:

• Rust
• Rust programming language
• Мова програмування Rust
• Програмування
• Системне програмування
• Memory safety
• Ownership
• Borrowing
• Cargo
• Concurrency
• WebAssembly
• Embedded
• Документація