Переход на Rust. Рефакторинг исходного кода с других языков
Покупка
Новинка
Издательство:
ДМК Пресс
Перевод:
Логунов А. В.
Год издания: 2025
Кол-во страниц: 346
Дополнительно
Вид издания:
Практическое пособие
Уровень образования:
Профессиональное образование
ISBN: 978-5-93700-228-0
Артикул: 890866.01.99
Эта книга научит вас расширять функциональность и повышать производительность приложений за счет поэтапного рефакторинга кодовой базы на язык Rust. Вы узнаете, как использовать Rust для обертывания опасного исходного кода, вызывать стандартные и прикладные библиотеки языка Rust и даже использовать формат байт-кода Wasm для исполнения кода Rust в браузере, а также овладеете навыками создания защищенных приложений с ограниченным потреблением памяти.
Для программистов среднего уровня. Опыт работы с языком Rust не требуется.
Тематика:
ББК:
УДК:
ОКСО:
- ВО - Бакалавриат
- 09.03.01: Информатика и вычислительная техника
- 09.03.02: Информационные системы и технологии
- 09.03.04: Программная инженерия
ГРНТИ:
Скопировать запись
Фрагмент текстового слоя документа размещен для индексирующих роботов
Лили Мара, Джоэл Холмс Переход на 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, но и дать вам навыки уверенной переработки крупных систем.