Галерея диаграмм связей Освоение RUST 2-го издания
Это интеллектуальная карта для освоения RUST, языка системного программирования, который обеспечивает беспрецедентную безопасность и сочетает в себе высокую производительность C и C . Rust значительно упрощает написание параллельных программ и широко используется в программировании системного уровня, сетевом программировании, разработке встроенных систем и других областях. С помощью приведенных выше шагов и предложений вы сможете постепенно улучшить свои навыки программирования на Rust и наслаждаться безопасностью памяти и эффективной производительностью, обеспечиваемыми Rust.
Отредактировано в 2024-04-04 15:14:48Cent ans de solitude est le chef-d'œuvre de Gabriel Garcia Marquez. La lecture de ce livre commence par l'analyse des relations entre les personnages, qui se concentre sur la famille Buendía et raconte l'histoire de la prospérité et du déclin de la famille, de ses relations internes et de ses luttes politiques, de son métissage et de sa renaissance au cours d'une centaine d'années.
Cent ans de solitude est le chef-d'œuvre de Gabriel Garcia Marquez. La lecture de ce livre commence par l'analyse des relations entre les personnages, qui se concentre sur la famille Buendía et raconte l'histoire de la prospérité et du déclin de la famille, de ses relations internes et de ses luttes politiques, de son métissage et de sa renaissance au cours d'une centaine d'années.
La gestion de projet est le processus qui consiste à appliquer des connaissances, des compétences, des outils et des méthodologies spécialisés aux activités du projet afin que celui-ci puisse atteindre ou dépasser les exigences et les attentes fixées dans le cadre de ressources limitées. Ce diagramme fournit une vue d'ensemble des 8 composantes du processus de gestion de projet et peut être utilisé comme modèle générique.
Cent ans de solitude est le chef-d'œuvre de Gabriel Garcia Marquez. La lecture de ce livre commence par l'analyse des relations entre les personnages, qui se concentre sur la famille Buendía et raconte l'histoire de la prospérité et du déclin de la famille, de ses relations internes et de ses luttes politiques, de son métissage et de sa renaissance au cours d'une centaine d'années.
Cent ans de solitude est le chef-d'œuvre de Gabriel Garcia Marquez. La lecture de ce livre commence par l'analyse des relations entre les personnages, qui se concentre sur la famille Buendía et raconte l'histoire de la prospérité et du déclin de la famille, de ses relations internes et de ses luttes politiques, de son métissage et de sa renaissance au cours d'une centaine d'années.
La gestion de projet est le processus qui consiste à appliquer des connaissances, des compétences, des outils et des méthodologies spécialisés aux activités du projet afin que celui-ci puisse atteindre ou dépasser les exigences et les attentes fixées dans le cadre de ressources limitées. Ce diagramme fournit une vue d'ensemble des 8 composantes du processus de gestion de projet et peut être utilisé comme modèle générique.
Знание RUST
Глава 1. Начало работы с Rust
1.1 Что такое Rust и зачем он вам нужен
Rust — это быстрый, высокопараллельный, безопасный и расширяющий возможности язык программирования, первоначально созданный и выпущенный в 2006 году Грейдоном Хоаром. Теперь это язык с открытым исходным кодом, который в основном поддерживается и развивается командой Mozilla и многими членами сообщества открытого исходного кода.
У Rust есть веб-сайт разработки с открытым исходным кодом на GitHub, и темпы его развития очень высоки. Новые функции добавляются в язык через процесс запроса комментариев (RFC), управляемый сообществом, где каждый может отправить новые функции, а затем подробно описать их в документе RFC. Затем достигается консенсус по RFC, и если консенсус достигнут, функция переходит в фазу реализации.
Rust существует как статический и строго типизированный язык. Статические атрибуты означают, что компилятор имеет информацию обо всех соответствующих переменных и типах во время компиляции и выполняет большую часть проверок во время компиляции, оставляя лишь небольшой объем проверки типов во время выполнения.
1.2 Установите цепочку инструментов Rust
Rustup.rs
1.3 Введение в Rust
1.3.1 Примитивные типы
логическое значение
Это общие логические значения, которые могут быть либо истинными, либо ложными.
голец
характер
целое число
Этот тип характеризуется разрядностью. Максимальная длина, поддерживаемая Rust, составляет 128 бит.
размер
Целое число со знаком переменного размера (размер зависит от размера базового указателя).
использовать
Целое число без знака переменного размера (размер зависит от размера базового указателя).
ф32
f32-битный тип с плавающей запятой
ф64
f64-битный тип с плавающей запятой
[Т;]
Массив фиксированного размера, T представляет тип элемента, N представляет количество элементов и является неотрицательной константой во время компиляции.
[Т]
Представление непрерывной последовательности с динамическим размером, где T представляет любой тип.
ул.
Нарезка строк, в основном используется в качестве ссылки, т.е. &str
(Т, У, ..)
Конечные последовательности T и U могут быть разных типов.
фн(i32)->i32
Функция, которая получает параметр типа i32 и возвращает параметр типа i32. Функции также имеют тип.
1.3.2 Объявление переменных и неизменяемость
В Rust мы используем ключевое слово let для объявления переменных. После инициализации переменной ей нельзя присвоить другое значение. Если позже вам понадобится указать эту переменную на другую переменную (того же типа), вам нужно поставить перед ней ключевое слово mut.
1.3.3 Функция
Функции абстрагируют набор инструкций в именованные сущности, которые позже можно вызывать из другого кода и помогают пользователям управлять сложностью.
fn add(a: u64, b: u64) -> u64 { а б } fn main() { пусть а: и64 = 17; пусть б = 3; пусть результат = добавить (а, б); println!("Результат {}", результат); }
Функции — это, по сути, выражения, которые возвращают значение, которое по умолчанию является значением типа () (единица измерения), которое аналогично возвращаемому типу void в C/C++.
1.3.4 Закрытие
Rust поддерживает замыкания. Замыкания похожи на функции, но содержат больше информации о среде или области, в которой они объявлены. Хотя у функций есть связанное с ними имя, у определений замыканий его нет, но их можно присвоить переменным. Еще одним преимуществом вывода типов Rust является то, что в большинстве случаев вы можете указывать параметры замыканий без типов. Это простейшее замыкание «let my_closure = ||();». Мы определяем замыкание без параметров, которое ничего не делает. Затем мы можем вызвать его через my_closure(), который похож на функцию. Две вертикальные полосы «||» используются для хранения параметров замыкания, таких как |a, b|. Иногда необходимо указать тип параметра (|a:u32|), когда Rust не может определить правильный тип.
fn main() { пусть удвоитель = |x| x * 2; пусть значение = 5; пусть дважды = удвоитель (значение); println!("{} удвоено равно {}", value, дважды); пусть big_closure = |b, c| { пусть z = bc; з* дважды }; пусть some_number = big_closure(1, 2); println!("Результат закрытия: {}", some_number); }
1.3.5 Строка
Строка — один из наиболее часто используемых типов данных в любом языке программирования. В Rust они обычно появляются в двух формах: тип &str и тип String. Строки Rust гарантированно являются действительными последовательностями байтов в кодировке UTF-8. Они не оканчиваются NULL, как строки C, и могут содержать нулевые байты между строками.
fn main() { let вопрос = «Как дела?»; let person: String = "Боб".to_string(); let namaste = String::from("zd"); println!("{}! {} {}", намасте, вопрос, человек); }
В приведенном выше коде тип человека и намасте — строка, а тип вопроса — &str. Существует множество способов создания данных типа String. Данные строкового типа размещаются в куче. Данные типа &str обычно являются указателем на существующую строку. Эти строки находятся в стеке и куче или могут быть строками в сегменте данных скомпилированного объектного кода.
1.3.6 Условия и решения
Условные суждения в Rust аналогичны условным суждениям в других языках. Они также следуют структуре if else, подобной C.
fn main() { пусть ржавчина_ис_авесоме = правда; если ржавчина_is_awesome { println!("Действительно"); } еще { println!("Ну, тебе стоит попробовать Rust!"); } }
В Rust конструкция if — это не оператор, а выражение. Говоря общим языком программирования, операторы не возвращают никакого значения, а выражения — возвращают. Это различие означает, что условия if else в Rust всегда возвращают значение. Значение может иметь тип пустого () или фактическое значение. Какой бы ни была последняя строка фигурных скобок, она становится возвращаемым значением выражения if else. Важно отметить, что ветки if и else должны иметь один и тот же тип возвращаемого значения.
fn main() { пусть результат = если 1 == 2 { "Чего ждать?" } еще { «Ржавчина имеет смысл» }; println!("Знаете что? {}.", result); }
Когда назначаемое значение возвращается из выражения if else, нам нужно использовать точку с запятой в качестве конечного знака. Например, если — выражение, то let — это оператор, который предполагает наличие точки с запятой в конце.
1.3.7 выражение совпадения
Выражения соответствия в Rust очень просты и удобны в использовании. По сути, он похож на упрощенную версию оператора switch на языке C, позволяя пользователям делать выводы на основе значения переменной и наличия расширенных функций фильтрации.
fn req_status() -> u32 { 200 } fn main() { пусть статус = req_status(); статус совпадения { 200 => println!("Успех"), 404 => println!("Не найден"), другое => { println!("Запрос не выполнен с кодом: {}",other); } } }
Каждое совпадение должно возвращать один и тот же тип. Кроме того, мы должны выполнить точное сопоставление всех возможных совпадающих значений. Rust позволяет нам игнорировать оставшиеся возможности, используя catch все переменные (здесь — другие) или _ (подчеркивание).
1.3.8 Цикл
Повторное выполнение чего-либо в Rust можно выполнить с помощью трех конструкций: цикла, while и for. Во все эти конструкции обычно включаются ключевые слова continue и Break, позволяющие пропустить цикл и выйти из него соответственно.
fn main() { пусть мут х = 1024; петля { если х <0 { перерыв; } println!("Еще {} прогонов", x); х -= 1; } }
Дополнительной особенностью выполнения циклов в Rust является возможность помечать блоки кода цикла именами. Это можно использовать в ситуациях, когда у вас есть два или более вложенных цикла и вы хотите выйти из любого из них, а не только для циклов, которые непосредственно содержат операторы прерывания.
fn silly_sub(a: i32, b: i32) -> i32 { пусть результат mut = 0; 'приращение: цикл { если результат == а { пусть mut dec = b; 'декремент: цикл { еслиdec==0{ перерыв 'приращение; } еще { результат -= 1; декабрь -= 1; } } } еще { результат = 1; } } результат } fn main() { пусть а = 10; пусть б = 4; пусть результат = silly_sub(a, b); println!("{} минус {} равно {}", a, b, result); }
В Rust также есть ключевое слово for, похожее на цикл for, используемый в других языках, но его реализация совершенно другая. Цикл for в Rust — это, по сути, синтаксический сахар для более мощной итерационной конструкции (итератора). Проще говоря, циклы for в Rust работают только с типами, которые можно преобразовать в итераторы. Одним из таких типов является тип Range. Тип Range может относиться к серии чисел.
fn main() { print!("Нормальный диапазон: "); для меня через 0..10 { print!("{},", i); } println!(); print!("Включая диапазон: "); для меня в 0..=10 { распечатать!("(),", i); } }
1.3.9 Пользовательские типы данных
Пользовательские типы — это типы, определяемые пользователями. Пользовательские типы могут состоять из нескольких типов. Они могут быть оболочками примитивных типов или комбинацией нескольких пользовательских типов. Они существуют в трех формах: структура, перечисление и объединение, также известные как структура, перечисление и объединение. Они позволяют вам проще представлять ваши данные. Правила именования пользовательских типов соответствуют CamelCase.
Состав
В Rust существует три формы объявления структуры. Простейшей из них является структура модуля, которая объявляется с использованием ключевого слова struct, за которым следует его имя и заканчивается точкой с запятой.
структура Манекен; fn main() { пусть значение = Манекен; }
Вторая форма структуры — это структура кортежа, с которой связаны данные. Каждое из этих полей не имеет имени, но на него ссылаются в зависимости от его положения в определении.
struct Color(u8, u8, u8); fn main() { пусть белый = Цвет(255, 255, 255); пусть красный = белый.0; пусть зеленый = белый.1; пусть синий = белый.2; println!("Красное значение: {}", red); пусть оранжевый = Цвет (255, 165, 0); пусть Color(r, g, b) = оранжевый; println!("R: {}, G: {}, B: {} (оранжевый)", r, g, b); пусть Color(r, _, b) = оранжевый; }
Структуры кортежей идеальны при моделировании данных с числом атрибутов менее 5. Любой другой выбор, кроме этого, ухудшит читаемость кода и его логику. Для типов данных с более чем тремя полями создавайте структуры, используя язык C. Это третья и наиболее часто используемая форма.
структура Player { имя: Строка, я: u8, друзья: u8, счет: u16 } fn Bump_player_score (мут игрок: Игрок, счет: u16) { player.score = счет; println!("Обновлена статистика игрока:"); } fn main() { let name = "Алиса".to_string(); let player = Player {имя, iq: 171, друзья: 134, счет: 1129 }; Bump_player_score (игрок, 120); }
перечислять
Перечисления — хороший способ сделать это, когда вам нужно моделировать разные типы вещей. Он создается с использованием ключевого слова enum, за которым следует имя перечисления и пара фигурных скобок. Внутри фигурных скобок мы можем написать все возможные типы, т.е. варианты. Эти варианты могут быть определены с данными или без них, а содержащиеся в них данные могут быть любым дальним типом, структурой, структурой кортежа или даже типом перечисления.
перечисление Направление { Н, Э, С, Вт } перечисление PlayerAction { Двигаться { направление: Направление, Скорость: u8 }, Ждать, Атака (направление) } fn main() { let Simulated_player_action = PlayerAction::Move { направление: Направление::N, скорость: 2, }; совпадение Simulated_player_action { PlayerAction::Wait => println!("Игрок хочет подождать"), PlayerAction::Move { направление, скорость } => { println!("Игрок хочет двигаться в направлении {:?} со скоростью {}", направление, скорость) } PlayerAction::Attack(направление) => { println!("Игрок хочет взломать направление {:?}", направление) } }; }
1.3.10 Функции и методы типов
реализовать блок в структуре
Мы можем добавить поведение к определенной структуре, используя два механизма: функции, подобные конструктору, и методы получения и установки.
структура Player { имя: Строка, я: u8, друзья: u8 } реализовать игрока { fn with_name(name: &str) -> Player { Игрок { имя: name.to_string(), iq: 100, друзья: 100 } } fn get_friends(&self) -> u8 { себя.друзья } fn set friends(&mut self, count: u8) { self.friends = количество; } } fn main() { let mut player = Player::with_name("Дэйв"); player.set_friends(23); println!("Количество друзей пользователя {}: {}", player.name, player.get_friends()); let _ = Player::get_friends(&player); }
Связанный метод: этот метод не имеет self-типа в качестве первого параметра. Это похоже на статические методы в объектно-ориентированных языках программирования. Эти методы доступны для вызова самого типа и не требуют вызова экземпляра типа. Связанный метод вызывается путем предшествующего имени метода имени структуры и двойного двоеточия.
Метод экземпляра: функция, которая принимает self в качестве первого внешнего параметра. Здесь self аналогично self в Python и указывает на экземпляр, реализующий метод.
реализовать блоки и перечисления
Перечисления широко используются в конечных автоматах, и при использовании с выражениями сопоставления они могут сделать код перехода состояний очень кратким. Их также можно использовать для моделирования пользовательских типов ошибок.
перечисление PaymentMode { Дебет, Кредит, ПайПал } fn pay_by_credit (amt: u64) { println!("Обработка кредитного платежа на сумму {}", amt); } fn pay_by_debit (amt: u64) { println!("Обработка дебетового платежа на сумму {}", amt); } fn paypal_redirect (amt: u64) { println!("Перенаправление на PayPal на сумму: {}", amt); } внедрить PaymentMode { fn pay(&self, sum: u64) { сопоставить себя { PaymentMode::Debit => pay_by_debit(сумма), PaymentMode::Credit => pay_by_credit(сумма), PaymentMode::Paypal => paypal_redirect(сумма) } } } fn get_saved_pay_mode() -> PaymentMode { Режим оплаты::Дебет } fn main() { пусть платеж_режим = get_saved_pay_mode (); pay_mode.pay(512); }
1.3.11 модуль, операторы импорта и использования.
Языки программирования часто предоставляют возможность разделить большие блоки кода на несколько файлов для управления сложностью. Java следует соглашению, согласно которому каждый файл .java является общедоступным классом, а C предоставляет нам файлы заголовков и операторы включения. Rust предоставляет модульный механизм. Модули — это способ именования и организации кода в программах Rust.
Для каждой программы Rust требуется корневой модуль. Для исполняемых файлов это обычно файл main.rs, а для библиотек — файл lib.rs.
Модули могут быть объявлены внутри других модулей или организованы в файлы и каталоги.
Чтобы компилятор распознал наш модуль, нам нужно использовать объявление ключевого слова mod. В нашем корневом модуле нам нужно использовать ключевое слово use перед именем модуля, что означает включение элемента в область видимости.
Элементы, определенные в модуле, по умолчанию являются частными и должны быть доступны вызывающим сторонам с помощью ключевого слова pub.
1.3.12 Сбор
множество
Массивы имеют фиксированную длину и могут хранить элементы одного типа. Они обозначаются [T, N], где T представляет любой тип, а N представляет количество элементов массива. Размер массива не может быть представлен переменной и должен быть буквальным значением usesize.
кортеж
Список проектов
пара ключ/значение
кусочек
1.3.13 Итератор
подтема
подтема
подтема
1.4 Улучшен счетчик персонажей
1.5 Резюме
Глава 2. Использование Cargo для управления проектами
2.1 Менеджер пакетов
2.2 Модули
2.2.1 Вложенные модули
2.2.2 Использование файлов в качестве модулей
2.2.3 Использование каталогов в качестве модулей
2.3 Груз и библиотеки
2.3.1 Создайте новый проект Cargo
2.3.2 Груз и зависимости
2.3.3 Использование Cargo для выполнения тестов
2.3.4 Использование Cargo для запуска примера
2.3.5 Грузовое рабочее место
2.4 Расширение грузового инструмента
2.4.1 Подкоманды и установка Cargo
2.4.2. Использование clippy для форматирования кода
2.4.3 Знакомство с файлом манифеста Cargo.toml
2.5 Настройка среды разработки Rust
2.6 Используйте Cargo для создания программы imgtool
2.7 Резюме
Глава 3. Тестирование, документация и сравнительный анализ
3.1 Цель тестирования
3.2 Организация тестов
3.3 Модульное тестирование
3.3.1 Первый модульный тест
3.3.2 Запуск тестов
3.3.3 Код проверки изоляции
3.3.4 Тестирование на отказ
3..3.5 Игнорировать тесты
3.4 Интеграционное тестирование
3.4.1 Первый интеграционный тест
3.4.2 Совместное использование общего кода
3.5 Документация
3.5.1 Написание документации
3.5.2 Создание и просмотр документов
3.5.3 Размещенные документы
3.5.4 Свойства документа
3.5.5 Документированное тестирование
3.6 Контрольный показатель
3.6.1 Встроенные инструменты микротестирования
3.6.2 Тестирование стабильной версии Rust
3.7 Написание и тестирование пакетов программного обеспечения – симулятор логических вентилей
3.8 Интеграционное тестирование CI и Travis CI
3.9 Резюме
Глава 4. Типы, дженерики и признаки
4.1 Системы типов и их важность
4.2 Дженерики
4.2.1 Создание дженериков#
4.2.2 Общая реализация
4.2.3 Общие приложения
4.3 Использование функций для абстрагирования поведения
4.3.1 Характеристики
4.3.2 Различные формы функций
4.4 Использование общих функций пакета — интервалы функций
4.4.1 Характеристические интервалы по типам
4.4.2 Характеристические интервалы универсальных функций и блоков кода реализации
4.4.3 Использование комбинации признаков " " для формирования интервала
4.4.4 Интервал функции и синтаксис реализации функции
4.5 Знакомство с функциями стандартной библиотеки
4.6 Использование объектов-характеристик для достижения истинного полиморфизма
4.6.1 Распространение
4.6.2 Характеристические объекты
4.7 Резюме
Глава 5 Управление памятью и безопасность
5.1 Программы и память
5.2 Как программы используют память
5.3 Управление памятью и классификация
5.4 Введение в распределение памяти
5.4.1 Стек
5.4.2 Куча
5.5 Дефекты в управлении памятью
5.6 Безопасность памяти
5.7 Три принципа безопасности памяти
5.7.1 Право собственности
5.7.2 Повторное использование типов через признаки
5.7.3 Заимствование
5.7.4 Типы методов, основанные на правилах заимствования
5.7.5 Жизненный цикл
5.8 Типы указателей в Rust
5.8.1 Ссылки — безопасные указатели
5.8.2 Необработанные указатели
5.8.3 Интеллектуальные указатели
5.8.4 Интеллектуальные указатели с подсчетом ссылок
5.8.5 Применение внутренней изменчивости
5.9 Резюме
Глава 6. Обработка исключений
6.1 Введение в обработку исключений
6.2 Устранимые исключения
6.2.1 Опция
6.2.2 Результат
6.3 Комбинация Опция/Результат
6.3.1 Общие комбинаторы
6.3.2 Приложение сумматора
6.3.3 Преобразование между типами Option и Result
6.4 Ранний возврат и оператор "?"
6.5 Неустранимые исключения
6.6 Пользовательские ошибки и характеристики ошибок
6.7 Резюме
Глава 7. Расширенные концепции.
7.1 Введение в системы типов
7.1.1 Блоки кода и выражения
7.1.2 оператор let
7.1.3 Циклы как выражения
7.1.4 Ясность типа и различие символов в числовых типах
7.1.5 Вывод типа
7.1.6 Введите псевдонимы
7.2 Строка
7.2.1 Строка, содержащая информацию о праве собственности — строка
7.2.2 Заимствование строки——&str
7.2.3 Нарезка и разбиение строк
7.2.4 Использование строк в функциях
7.2.5 Конкатенация строк
7.2.6 Сценарии применения &str и String
7.3 Глобальные значения
7.3.1 Константы
7.3.2 Статические значения
7.3.3 Функция времени компиляции — const fn
7.3.4 Динамические статические значения через макрос lazy_static
7.4 Итераторы
7.5 Расширенные типы
7.5.1 Типы неопределенной длины
7.5.2 Типы функций
7.5.3 никогда не вводите «!» и не отправляйте функции.
7.5.4 Союз
7.5.5 Корова
7.6 Расширенные функции
7.6.1 Размер и размер
7.6.2 Заимствование и AsRef
7.6.3 ТоБонед
7.6.4 Откуда и внутрь
7.6.5 Характеристика объектов и безопасность объектов
7.6.6 Общий синтаксис вызова функций
7.6.7 Правила функций
7.7 Расширенные замыкания
7.7.1 Закрытие Fn
7.7.2 Закрытие FnMut
7.7.3 Закрытие FnOnce
7.8 Константы в структурах, перечислениях и признаках
7.9 Модули, пути и импорт
7.9.1 Импорт
7.9.2 Повторный импорт
7.9.3 Конфиденциальность
7.10 Расширенные шаблоны сопоставления и меры защиты
7.10.1 Защитник матча
7.10.2 Расширенная конструкция сдачи в аренду
7.11 Кастинг
7.12 Типы и память
7.12.1 Выравнивание памяти
7.12.2 модуль std::mem
7.13 Сериализация и десериализация с использованием serde
7.14 Резюме
Глава 8. Параллелизм
8.1 Модель выполнения программы
8.2 Параллелизм
8.2.1 Параллельные методы
8.2.2 Дефекты
8.3 Параллелизм в Rust
8.3.1 Основы потоков
8.3.2 Пользовательские темы
8.3.3 Доступ к данным в потоках
8.4 Модель параллелизма потоков
8.4.1 Модель совместного использования состояний
8.4.2 Взаимное исключение
8.4.3 Совместная изменчивость посредством Arc и Mutex
8.4.4 Связь посредством обмена сообщениями
8.5 Потокобезопасность в Rust
8.5.1 Что такое потокобезопасность?
8.5.2 Характеристики резьбобезопасности
8.5.3 Отправить
8.5.4 Синхронизация
8.6 Реализация параллелизма с использованием модели актера
8.7 Другие библиотеки
8.8 Резюме
Глава 9 Макросы и метапрограммирование
9.1 Что такое метапрограммирование?
9.2 Сценарии применения макросов Rust
9.3 Макросы и их типы в Rust
9.4 Создавайте макросы с помощью macro_rules!
9.5 Встроенные макросы в стандартной библиотеке
9.6 Тип макроса_правил!
9.7 Повторение в макросах
9.8 Расширенное применение макросов — написание DSL для инициализации HashMap
9.9 Варианты использования макросов — написание тестов
9.10 Упражнение
9.11 Макросы процесса
9.12 Производные макросы
9.13 Макросы высокого уровня
9.14 Часто используемые пакеты макросов процессов
9.15 Резюме
Глава 10. Небезопасный Rust и интерфейсы внешних функций
10.1 Безопасность и опасность
10.1.1 Небезопасные функции и блоки кода
10.1.2 Небезопасные характеристики и реализации
10.2 Вызов кода C в Rust
10.3 Вызов кода Rust через язык C
10.4 Использование внешних библиотек C/C в Rust
10.5 Создание собственных расширений Python с использованием PyO3
10.6 Создание собственных расширений для Node.js в Rust
10.7 Резюме
Глава 11 Журнал
11.1 Ведение журнала и его важность
11.2 Требования к системе ведения журналов
11.3 Структура журналирования и ее особенности
11.4 Метод регистрации
11.4.1 Неструктурированное журналирование
11.4.2 Структурированное журналирование
11.5 Вход в Rust
11.5.1 журнал — ведение журналов для Rust
11.5.2 env_logger
11.5.3 журнал4рс
11.5.4 Использование slog для структурированного журналирования
11.6 Резюме
Глава 12 Rust и сетевое программирование
12.1 Введение в сетевое программирование
12.2 Синхронный сетевой ввод/вывод
12.3 Асинхронный сетевой ввод-вывод
12.3.1 Асинхронные абстракции в Rust
12.3.2 Создание асинхронного сервера Redis
12.4 Резюме
Глава 13. Создание веб-приложений с помощью Rust
13.1 Веб-приложения на Rust
13.2 Использование Hyper для HTTP-связи
13.2.1 Серверный API Hyper создает службу коротких URL-адресов
13.2.2 Hyper как клиент – создание короткого URL-клиента
13.2.3 Веб-фреймворк
13.3 Базовые знания Actix Web
13.4 Создание API закладок с помощью actix-web
13.5 Резюме
Глава 14 Rust и WebAssembly
14.1 Важность долговечности данных
14.2 SQLite
14.3 PostgreSQL
14.4 пул соединений r2d2
14.5 Постгрес и дизельный ORM
14.6 Резюме
Глава 15 Rust и WebAssembly
15.1 Что такое WebAssmbly
15.2 Цели проектирования WebAssembly
15.3 Начало работы с WebAssembly
15.3.1 Попробуйте онлайн
15.3.2 Методы создания WebAssembly
15.4 Rust и WebAssembly
15.4.1 васм-биндген
15.4.2 Другие проекты WebAssembly
15.5 Резюме
Глава 16. Rust и настольные приложения
16.1 Введение в разработку графического интерфейса
16.2 Структура GTK
16.3 Создание настольного новостного приложения с помощью gtk-rs
16.4 Упражнения
16.5 Другие новые платформы пользовательского интерфейса
16.6 Резюме
Глава 17. Отладка
17.1 Введение в отладку
17.1.1 Основы отладчика
17.1.2 Предварительные условия для ввода в эксплуатацию
17.1.3 Настройка ГБД
17.1.4 Пример программы — багги
17.1.5 Основы ГБД
17.1.6 Интеграция GDB в код Visual Studio
17.2 Знакомство с отладчиком rr
17.3 Резюме