Книжная полка Сохранить
Размер шрифта:
А
А
А
|  Шрифт:
Arial
Times
|  Интервал:
Стандартный
Средний
Большой
|  Цвет сайта:
Ц
Ц
Ц
Ц
Ц

Переход на Rust. Рефакторинг исходного кода с других языков

Покупка
Новинка
Артикул: 890866.01.99
Доступ онлайн
1 799 ₽
В корзину
Эта книга научит вас расширять функциональность и повышать производительность приложений за счет поэтапного рефакторинга кодовой базы на язык Rust. Вы узнаете, как использовать Rust для обертывания опасного исходного кода, вызывать стандартные и прикладные библиотеки языка Rust и даже использовать формат байт-кода Wasm для исполнения кода Rust в браузере, а также овладеете навыками создания защищенных приложений с ограниченным потреблением памяти. Для программистов среднего уровня. Опыт работы с языком Rust не требуется.
Мара, Л. Переход на Rust. Рефакторинг исходного кода с других языков : практическое руководство / Л. Мара, Д. Холмс ; пер. с англ. А. В. Логунова. – Москва : ДМК Пресс, 2025. - 346 с. – ISBN 978-5-93700-228-0. - Текст : электронный. - URL: https://znanium.ru/catalog/product/2275279 (дата обращения: 18.11.2026). – Режим доступа: по подписке.
Фрагмент текстового слоя документа размещен для индексирующих роботов
Лили Мара, Джоэл Холмс
Переход на Rust. 
Рефакторинг исходного кода 
с других языков


Refactoring to Rust
Lily Mara
Joel Holmes


Переход на Rust. 
Рефакторинг исходного кода 
с других языков
Лили Мара
Джоэл Холмс
Москва, 2026


УДК 004.438Rust
ББК 32.973.2
М25
Лили Мара, Джоэл Холмс
М25 	 Переход на Rust. Рефакторинг исходного кода с других языков / пер. 
с англ. А. В. Логунова. – М.: ДМК Пресс, 2025. – 344 с.: ил.
ISBN 978-5-93700-228-0
Эта книга научит вас расширять функциональность и повышать производительность приложений за счет поэтапного рефакторинга кодовой 
базы на язык Rust. Вы узнаете, как использовать Rust для обертывания 
опасного исходного кода, вызывать стандартные и прикладные библиотеки языка Rust и даже использовать формат байт-кода Wasm для исполнения кода Rust в браузере, а также овладеете навыками создания 
защищенных приложений с ограниченным потреблением памяти.
Для программистов среднего уровня. Опыт работы с  языком Rust 
не требуется.
УДК 004.438Rust
ББК 32.973.2
Все права защищены. Любая часть этой книги не может быть воспроизведена в какой бы то ни было форме и какими бы то ни было средствами без 
письменного разрешения владельцев авторских прав.
©DMKPress 2025. Authorized translation of the English edition. © 2025 Manning 
Publications. This translation is published and sold by permission of Manning 
Publications, the owner of all rights to publish and sell the same.
©  2025 by Manning Publications Co.  
All rights reserved
©  Оформление, издание, перевод,  
ДМК Пресс, 2025
ISBN  (анг.) 9781617299018
ISBN  (рус.) 978-5-93700-228-0


Посвящается всем тем, кто думал, 
что у них ничего не получится.
– Лили Мара
Посвящается моей бабушке Джози и моей тете Алише, 
которые привили мне любовь к чтению и технологиям.
– Джоэл Холмс


Краткое оглавление
1 
 Зачем перерабатывать исходный код на язык Rust  ............... 19
2 
 Обзор языка Rust .................................................................. 36
3 
 Введение в интерфейс с внешними функциями C (C FFI) 
и незащищенный язык Rust ................................................... 88
4 
 Продвинутый интерфейс с внешними функциями (FFI) ........126
5 
 Структурирование библиотек языка Rust ............................178
6   Интеграция с динамическими языками ...............................206
7 
 Тестирование интеграций с Rust .........................................233
8 
 Асинхронный Python с языком Rust........................................261
 WebAssembly для переработки исходного кода JavaScript.........282
10  Интерфейс с WebAssembly для переработки исходного кода....304


Оглавление
Предисловие.........................................................................................10
Признательности.................................................................................11
О книге...................................................................................................13
Кому стоит прочитать эту книгу..........................................................................13
Как эта книга организована: дорожная карта...................................................13
Об исходном коде..................................................................................................14
Дискуссионный форум liveBook..........................................................................15
Об авторах.............................................................................................16
От издательства....................................................................................17
Об иллюстрации на обложке..............................................................18
1  Зачем перерабатывать исходный код на язык Rust.................... 19
1.1 Что такое переработка исходного кода?......................................................20
1.2 Что из себя представляет язык Rust?............................................................22
1.3 Почему именно язык Rust?.............................................................................23
1.4 Следует ли перерабатывать исходный код на язык Rust?.........................23
1.4.1 Производительность............................................................................24
1.4.2 Защищенность памяти.........................................................................26
1.4.3 Удобство технического сопровождения...........................................27
1.5 Когда не следует перерабатывать исходный код на язык Rust.................28
1.6 Как это работает?.............................................................................................29
1.7 Чему вы научитесь в этой книге?..................................................................30
1.7.1 Вызов функций Rust непосредственно из своей программы........30
1.7.2 Обмен со службой Rust по сети..........................................................33
1.8 Для кого предназначена эта книга?..............................................................34
1.9 Какие инструменты потребуются для начала работы?..............................34
Краткий итог..........................................................................................................35
2  Обзор языка Rust...................................................................... 36
2.1 Владение и заимствование.............................................................................37
2.2 Управление памятью в других языках..........................................................41
2.3 Времена жизни.................................................................................................45
2.3.1 Ссылки и заимствования.....................................................................49
2.3.2 Контроль за мутируемостью...............................................................50
2.3.3 Ссылки и времена жизни.....................................................................53
2.4 Строковые типы в языке Rust........................................................................56
2.4.1 Мутируемые строковые литералы.....................................................58
2.5 Перечисления и обработка ошибок.............................................................61
2.5.1 Перечисления.......................................................................................62
2.5.2 Обработка ошибок с помощью перечислений................................66
2.5.3 Единичный тип.....................................................................................69


2.5.4 Типы ошибки.........................................................................................71
2.5.5 Преобразование ошибок ....................................................................75
2.5.6 Поднятие паники при появлении ошибок.......................................80
Краткий итог..........................................................................................................86
3  Введение в интерфейс с внешними функциями C 
 и незащищенный язык Rust...................................................... 88
3.1 Незащищенный язык Rust..............................................................................89
3.1.1 Обыкновенные указатели....................................................................90
3.2 Интерфейс с внешними функциями C.........................................................92
3.2.1 Включение пакета Rust........................................................................98
3.2.2 Создание динамической библиотеки  
с использованием языка Rust.....................................................................100
3.2.3 Решение арифметических выражений на языке Rust..................108
3.2.4 Общая черта Display.......................................................................... 119
Краткий итог........................................................................................................125
4  Продвинутый интерфейс с внешними функциями....................126
4.1 Скачивание исходного кода веб-сервера NGINX.....................................127
4.2 Создание модуля для веб-сервера NGINX..................................................128
4.3 Связывание языка C с языком Rust.............................................................132
4.3.1 Скрипты сборки..................................................................................134
4.3.2 Инструмент bindgen...........................................................................139
4.4 Чтение запроса веб-сервера NGINX...........................................................145
4.4.1 Аннотации времен жизни.................................................................152
4.4.2 Аннотации времен жизни в плагине для веб-сервера NGINX.....158
4.5 Использование библиотеки-калькулятора............................................... 162
4.6 Написание HTTP-ответа ............................................................................. 167
Краткий итог....................................................................................................... 176
5  Структурирование библиотек языка Rust................................178
5.1 Модули.............................................................................................................178
5.1.1 Какая разница?....................................................................................182
5.1.2 Несколько файлов..............................................................................183
5.2 Пути................................................................................................................ 186
5.2.1 Относительные и абсолютные пути................................................187
5.2.2 Псевдонимы путей............................................................................. 197
5.3. Восходящая видимость................................................................................202
Краткий итог........................................................................................................205
6  Интеграция с динамическими языками...................................206
6.1 Обработка данных в Python........................................................................ 206
6.2 Планирование перемещения на язык Rust................................................207
6.3 Разбор данных JSON.....................................................................................208
6.4. Написание модуля расширения Python на языке Rust............................214
6.5 Измерение и тестирование производительности в Rust....................... 219
6.6 Оптимизированные сборки........................................................................ 229
Краткий итог........................................................................................................231
7  Тестирование интеграций с Rust.............................................233
7.1 Написание тестов на языке Rust.................................................................234
7.1.1 Документарные тесты .......................................................................240
7.1.2 Добавление тестов в существующий исходный код......................245
Оглавление


7.2 Тестирование исходного кода Rust с использованием языка Python....250
7.2.1 Динамическое латание......................................................................254
Краткий итог....................................................................................................... 259
8  Асинхронный Python с языком Rust...........................................261
8.1 Генерирование множества Мандельброта на языке Python.................. 262
8.2 Масштабирование........................................................................................ 265
8.3 Библиотека asyncio....................................................................................... 268
8.4 Многопоточность исполнения....................................................................271
8.5 Глобальная блокировка ................................................................................274
8.6 Библиотека PyO3.......................................................................................... 276
Краткий итог........................................................................................................280
9  WebAssembly для переработки исходного кода JavaScript............282
9.1 Что такое WebAssembly?...............................................................................283
9.2 Перенос из JavaScript в Rust.........................................................................285
9.3 Язык Rust в браузере.................................................................................... 286
9.3.1 Запрос данных.................................................................................... 286
9.3.2 Компиляция в Wasm.......................................................................... 290
9.3.3 Загрузка Wasm в браузер................................................................... 291
9.4. Создание компонента библиотеки React................................................. 292
9.5 Веб-компоненты полностью на языке Rust.............................................. 296
9.6 Еще раз о переработке JavaScript................................................................302
Краткий итог........................................................................................................303
10  Интерфейс с WebAssembly для переработки исходного кода...304
10.1 Универсальная среда исполнения системного интерфейса WASI.......308
10.2 Из браузера на машину...............................................................................312
10.3 Библиотека Wasm........................................................................................318
10.4 Потребление Wasm.....................................................................................320
10.5 Еще о Wasm...................................................................................................326
10.6 Память Wasm................................................................................................329
10.7 Это только начало.......................................................................................335
Краткий итог........................................................................................................335
Предметный указатель.................................................................337
Оглавление


Предисловие
На протяжении всей нашей карьеры разработчиков программного 
обеспечения у нас была возможность участвовать в нескольких проектах по переработке кодовой базы. Их суть нередко состояла в одном 
и том же: нужно было масштабировать продукты и при этом уложиться 
в ограниченное время. Такая ситуация приводит к тому, что разработка занимает месяцы, заполненные обсуждениями шаблонов и языков.
Переработка кодовой базы с использованием языков Java и Go сопряжена со значительными трудностями, включая постоянное перемещение файлов, экспорт пакетов, создание системных оболочек 
и полное переписывание существующих систем. Пути к успеху редко 
были четко определены. Цель этой книги состоит в том, чтобы познакомить вас со многими из этих шаблонов, используя язык, предназначенный для разбивки и переписывания существующих систем. 
Книга «Переход на Rust. Рефакторинг исходного кода с других языков» демонстрирует легкость, с которой указанный язык может легко 
интегрироваться в вашу экосистему, обеспечивая преимущества масштабирования с первого дня благодаря особенностям языка.
Язык Rust привносит такие преимущества, как типобезопасность 
и защищенность памяти, а также связанный с этими свойствами прирост в производительности. Из этой книги вы узнаете, как язык Rust 
может улучшать практически любой проект. Язык Rust, который позиционируется как замена существующим языкам, таким как C и C++, 
отличается своей надежной цепочкой инструментов и функциональными компонентами защиты памяти. Мы  также рассмотрим способы взаимодействия языка Rust с такими языками, как Python, и расскажем об улучшениях производительности при создании библиотек 
и модулей, работающих на обоих языках. Кроме того, мы откроем для 
вас неожиданные области применения языка Rust, например в  веббраузерах и в качестве универсальной среды исполнения.
В целом цель этой книги  – не  только продемонстрировать мощь 
языка и экосистемы языка Rust, но и дать вам навыки уверенной переработки крупных систем.


Доступ онлайн
1 799 ₽
В корзину