 |
-- 會員 / 註冊 --
|
 |
|
|
|
Rust編程之道 ( 簡體 字) |
| 作者：張漢東 | 類別：1. -> 程式設計 -> 綜合 |
| 譯者： |
| 出版社：電子工業出版社 |  3dWoo書號： 50460
詢問書籍請說出此書號！【缺書】
NT售價： 640 元 |
| 出版日：1/1/2019 |
| 頁數：580 |
| 光碟數：0 |
|
站長推薦：  |
| 印刷：黑白印刷 | 語系： ( 簡體 版 ) |
| |
加入購物車  │加到我的最愛
(請先登入會員) |
| ISBN：9787121354854 |
| 作者序 | 譯者序 | 前言 | 內容簡介 | 目錄 | 序 |
| (簡體書上所述之下載連結耗時費功, 恕不適用在台灣, 若讀者需要請自行嘗試, 恕不保證) |
| 作者序： |
| 譯者序： |
前言：序
當我2015 年開始學習Rust 的時候，我絕對沒有想過要寫一本Rust 編程的書。
緣起
當時我剛剛翻譯完《Ruby 原理剖析》一書，開始對底層開發產生了一點點興趣。從2006年入行以來，我就一直和動態語言打交道。雖然自己也想學習底層開發，但能選擇的語言幾乎只有C++。我在學校里淺淺地學過C++這門語言，也許是第一印象作怪，總難以提起對C++的興趣。
當Rust 1.0 發布時，我去官方網站了解了一下Rust 語言，發現它的主要特點有以下幾方面：
? 系統級語言
? 無GC
? 基于LLVM
? 內存安全
? 強類型+靜態類型
? 混合編程范式
? 零成本抽象
? 線程安全
我一下子就被這些鮮明的特性“擊中”了，從此開始了Rust 的學習。
再一次愛上編程
第一次愛上編程是在上小學時。父親給我買回來一臺金字塔學習機，這臺學習機有兩種功能，一種是學習Logo 語言，另一種是玩卡帶游戲。編寫Logo 語言就是用小海龜畫圖，也許是因為太早了，也許是因為沒有人引導，那時的我選擇了痛快地玩游戲。總想著先玩游戲，再去學怎么編程，然后還幻想著能不能用Logo 語言編寫一個游戲。其實這時候的我對編程更多的是一種憧憬，并沒有在學習編程上付出更多的實際行動。
第二次愛上編程是在大學初次學習C 語言的時候。我本可以選擇計算機科學專業，但是最后還是選了電子信息科學與技術專業。這樣選是因為我想把軟硬件都學了。想法是好的，可惜實施起來并不容易。最后的結果就是，軟硬件都沒學好。
第三次愛上編程是在遇到Ruby 語言的時候。當時我在用Java，并且已經完全陷入了Java語言和Web 框架紛繁復雜的細節中，痛苦不堪。Ruby on Rails 框架的橫空出世，把我從這種狀態中解救了出來。Ruby 語言的優雅和自由，以及“讓程序員更快樂”的口號深深地吸引了我。這一次我是真正愛上了編程，并且積極付諸行動去學習和提升自己。此時也恰逢互聯網創業大潮的開始，Ruby 語言的開發效率讓它迅速成為創業公司的寵兒，因此，我也借著Ruby
這門語言參與到了這股創業洪流中。
第四次愛上編程是在遇到Rust 的時候。此時，創業洪流已經退潮。技術圈有句話，叫“十年一輪回”。當年喜歡Ruby 給開發過程帶來的快樂，但是隨著時代的變革和業務規模的增長，我不禁開始重新思考一個問題：何謂快樂？真正的快樂不僅僅是寫代碼時的“酸爽”，更應該是代碼部署到生產環境之后的“安穩”。Rust 恰恰可以給我帶來這種“雙重快樂”體驗。
為什么是Rust
社區中有人模仿阿西莫夫的機器人三大定律，總結了程序的三大定律：
? 程序必須正確。
? 程序必須可維護，但不能違反第一條定律。
? 程序必須高效，但不能違反前兩條定律。
程序的正確性，一方面可以理解為該程序滿足了實際的問題需求，另一方面是指滿足了它自身的程序規約。那么如何保證程序的正確性呢？首先，可以通過對程序的各種測試、斷言和錯誤處理機制，來保證其滿足實際的問題需求。其次，在數學和計算機科學已經融合的今天，通過較為成熟的類型理論即可保證程序自身的規約正確。
以我最熟悉的Ruby 語言為例，程序的正確性必須依賴于開發者的水平，并需要大量的測試代碼來保證正確性。即便在100%測試覆蓋率的條件下，也經常會遇到NilError 之類的空指針問題。也就是說，Ruby 程序自身的正確性還沒有得到保證。以此類推，C、C++、Python、Java、JavaScript 等語言都有同樣的問題。
而函數式編程語言在這方面要好很多，尤其是號稱純函數式的Haskell 語言，它具有融合了范疇理論的類型系統，利用了范疇理論自身的代數性質和定律保證了程序自身的正確性。然而，Haskell 也有比較明顯的缺點，比如它不滿足上述第三條定律，運行效率不高。
反觀Rust 語言，對程序的三定律支持得恰到好處。它借鑒了Haskell 的類型系統，保證了程序的正確性。但還不止于此，在類型系統的基礎上，Rust 借鑒了現代C++的內存管理機制，建立了所有權系統。不僅保證了類型安全，還保證了內存安全。同時，也解決了多線程并發編程中的數據競爭問題，默認線程安全。再來看代碼的可維護性，Rust 代碼的可讀性和抽象能力都是一流的。不僅擁有高的開發效率，還擁有可以和C/C++媲美的性能。當然，沒有銀彈，但Rust 就是我目前想要的語言。
目前Rust 被陸續應用在區塊鏈、游戲、WebAssembly 技術、機器學習、分布式數據庫、網絡服務基礎設施、Web 框架、操作系統和嵌入式等領域。時代在變化，未來的互聯網需要的是安全和性能并重的語言，Rust 必然會在其中大放異彩。
學習Rust 帶來了什么收獲
Rust 是一門現代化的語言，融合了多種語言特性，而且Rust 語言可以應用的領域范圍非常廣泛。在學習Rust 的過程中，我發現自己的編程能力在很多方面存在短板。突破這些短板的過程實際上就是一次自我提升的過程。
Rust 是一門成長中的新語言，學習Rust，跟隨Rust 一起成長，可以體驗并參與到一門真正工業化語言的發展進程中，感覺就像在創造歷史。雖然我并未給Rust 語言提交過PR，但也為Rust 語言和社區多次提交過Bug，以及文檔和工具的改進意見。
Rust 自身作為一個開源項目，算得上是開源社區中的“明星”項目了。學習Rust 的過程加深了我對開源社區的認識，也開拓了我的眼界。
為什么要寫這本書
在學習Rust 一年之后，我寫下了《如何學習一門新語言》一文，其中記錄了我學習Rust的心得，這篇文章頗受好評。也正因為這篇文章，電子工業出版社的劉恩惠編輯找到了我，并詢問是否可以出一本Rust 編程的書籍。我當時也正想通過一本書來完整地表達自己的學習心得，再加上中文社區中沒有較全面系統的Rust 書籍，于是，一拍即合。
寫書的過程可以形容為痛并快樂著。Rust 語言正值成長期，很多語言特性還在不斷地完善。舉一個極端的例子，比如寫下某段代碼示例并成功編譯后，過了三天卻發現它無法編譯通過了。于是，我再一次跟進Rust 的RFC、源碼、ChangeLog 去看它們的變更情況，然后再重新修訂代碼示例。這個過程雖然痛苦，但改完之后會發現Rust 的這個改進確實是有必要的。
在這個過程中，我看到了Rust 的成長，以及Rust 團隊為保證語言一致性和開發者的開發體驗所付出的努力，讓我感覺自己花再多時間和精力去修改本書的內容都是值得的。
話說回來，任何人做事都是有動機或目的的，我也不例外。我寫這本書的目的主要有以下三個。
? 為Rust 中文社區帶來一本真正可以全面系統地學習Rust 的書。
? 以教為學。在寫作的過程中，讓自己所學的知識進一步內化。
? 傳播一種自學方法。本書內容以Rust 語言的設計哲學為出發點，按照從整體到細節的思路逐個闡述每個語言特性，希望讀者可以產生共鳴。
結語
我自己作為本書的第一位讀者，目前對這本書是非常滿意的。衷心希望每一位讀者都能從本書中收獲新知。當然，我也知道不可能讓每一位讀者都滿意。在我看來，寫書不僅是在傳播知識和思想，更是一種交流和溝通。所以，當你不滿意的時候，可以來找我交流，提出更多建設性意見，幫助我成長。我爭取在寫下一本書的時候，讓更多的人滿意。而且，如果你的建議確實中肯，讓我得到了成長，我也為你準備了不錯的小禮物。
前言
在我剛開始學習Rust 的時候，在社區里聽到最多的聲音就是“Rust 學習曲線陡”。已經有一定編程經驗的人在學習一門新語言時，都喜歡直接上手寫代碼，因為這樣可以快速體驗這門語言的特色。對于大多數語言來說，這樣確實可以達到一定的學習目的。但是當他們在初次學習Rust 的時候，就很難通過直接上手來體驗這種快感。
我第一次學習Rust 時就遇到了這樣的情況。我按以往的編程經驗直接寫下了代碼，但是編譯無法通過；可是有時候簡單調換兩行代碼的順序，程序就能順利編譯成功了，這讓我非常困惑。我想這也是大多數人感覺“Rust 學習曲線陡”的原因吧。經過和Rust 編譯器的多次“斗爭”之后，我不得不重新反思自己的學習方法。看樣子，Rust 編譯器暗含了某種規則，只要程序員違反了這些規則，它就會檢查出來并阻止你。這就意味著，作為程序員，你必須主動理解并遵守這些規則，編譯器才能和你“化敵為友”。
所以，我就開始了對Rust 的第二輪學習，忘掉自己以往的所學，抱著初學者的心態，從零開始系統地學習Rust。然而，事情并沒有這么簡單。
Rust 官方雖然提供了Rust Book，但是內容的組織非常不友好，基本就是對知識點的羅列，系統性比較差。后來官方也意識到了這個問題，推出了第2 版的Rust Book，內容組織方面改善了很多，對學習者也非常友好，但系統性還是差了點。后來又看了國內Rust 社區組織群友們合著的Rust Primer，以及國外的Programming Rust，我才對Rust 建立了基本的認知體系。
直到此時，我才意識到一個重要的問題：Rust 學習曲線陡的根本原因在于Rust 語言融合了多種語言特性和多種編程范式。這就意味著，Rust 涉及的知識范圍非常廣泛，涵蓋了面向對象、函數式、泛型、底層內存管理、類型系統、設計模式等知識。從底層到上層抽象，從模式到工程化健壯性，無所不包。可以說，Rust 是編程語言發展至今的集大成者。對于大多數Rust 語言的初學者來說，他掌握的知識體系范圍是小于Rust 所包含的知識量的，所以在學習Rust 的過程中會遇到無法理解的內容。
我在學習Rust 之前，所掌握的編程語言知識體系大多是和擁有GC 的動態語言相關的，對于底層內存管理知之甚少。所以在我學習Rust 所有權的時候，就很難理解這種機制對于內存安全的意義所在；而我所認識的一些擁有C 語言編程經驗的朋友，在學習Rust 時面臨的問題是，難以理解Rust 支持的上層抽象，對他們來說，Rust 中融合的類型系統和編程范式就是他們學習道路上的“攔路虎”；對于擁有Haskell 等函數式編程經驗的朋友，會感覺Rust的類型系統很容易理解，但是底層的內存管理和所有權機制又成了需要克服的學習障礙；來自C++編程圈的朋友，尤其是懂現代C++的朋友，對Rust 所有權機制理解起來幾乎沒有困難，但是類型系統和函數式編程范式可能會阻礙他們的學習。當然，如果正好你沒有上述情況，那說明你的相關知識體系已經很全面了，你在Rust 的學習之路上將會非常順利。
這是不是意味著，在學習Rust 之前需要把其他語言都學一遍呢？答案是否定的。
Rust 編程語言雖然融合了很多其他語言的特性和范式，但它不是進行簡單的內容堆疊，而是有機地融合了它們。也就是說，Rust 遵循著高度的一致性內核來融合這些特性。我們只需要從Rust 的設計哲學出發，牢牢地把握它的設計一致性，就可以把它的所有特性都串起來，從而達到掌握它的目的。這正是本書遵循的寫作邏輯。
本書特點
從設計哲學出發，探索Rust 語言的內在一致性。設計哲學是一門優秀編程語言保持語言一致性的關鍵所在。設計哲學是語言特性和語法要素設計的誘因和準則。理解Rust 語言的設計哲學，有助于把握Rust 語言的內核與一致性，把Rust 看似紛繁復雜的特性都系統地串起來。
從源碼分析入手，探索Rust 地道的編程風格。Rust 是一門自舉的語言，也就是說，Rust語言由Rust 自身實現。通過閱讀Rust 標準庫和一些第三方庫的源碼，不僅可以深入理解Rust提供的數據類型和數據結構，更能體驗和學習地道的Rust 編程風格。
從工程角度著手，探索Rust 對健壯性的支持。Rust 通過類型系統、斷言、錯誤處理等機制保證內存安全的同時，還保證了系統的健壯性。從工程角度去看 Rust，才能看到 Rust對系統健壯性的支持是多么優雅。
從底層原理開始，探索Rust 內存安全的本質。只有深入底層，才能理解Rust 所有權機制對于內存安全的意義。而且可以進一步理解Rust 的類型系統，以及Unsafe Rust 存在的必要性。
讀者群體
適合本書的讀者群體包括：
? 有一定編程經驗，想要學習Rust 的初學者。
? 對Rust 有一定了解，還想對Rust 深入學習的進階者。
本書不適合完全沒有編程基礎的人學習。
如何閱讀本書
對于Rust 初學者，建議按照章節順序去閱讀。因為本書每一章內容基本都依賴于前一章內容的前置知識。
對于Rust 有一定了解的朋友，可以選擇你感興趣的章節去閱讀。因為本書的每一章也是對一個垂直主題的深入探討。
一些章節的開頭羅列出了通用概念，這是為了更通透地講解相關知識的來龍去脈。如果你對這部分內容不了解，那么建議你把這部分內容（屬于前置知識）認真看完再去看后面的內容。如果你對這部分內容已經有了充分的了解，那么完全可以跳過，直接選擇你最關心的內容去閱讀。
章節概述
第1 章 新時代的語言。這一章將從Rust 語言的發展歷史概述開始，引出Rust 的設計哲學，通過設計哲學進一步闡述Rust 的語言架構。該語言架構也是本書組織內容時遵循的準則之一。這一章還將介紹Rust 語言社區的現狀和未來展望。最重要的是，這一章將介紹Rust代碼的執行流程，這對于理解本書后面的章節會有所幫助。
第2 章 語言精要。學習任何一門語言時，首先要做的就是了解其語法。這一章將羅列Rust 語言中的常用語法，但不是簡單羅列，而是遵循一定的邏輯進行羅列。在介紹語法之前，這一章會先對Rust 語言的基本構成做整體概述。然后將介紹一個非常重要的概念：表達式。它是Rust 語法遵循的最簡單的準則之一。接下來才會依次介紹Rust 中最常用的語法，讓讀者對Rust 語言有一個初步的了解。
第3 章 類型系統。類型系統是現代編程語言的重要支柱。這一章首先將以通用概念的形式介紹類型系統相關的概念，目的是幫助不了解類型系統的讀者建立初步認知。接下來將從三方面闡述Rust 的類型系統。為了理解Rust 基于棧來管理資源的思想，有必要先了解Rust中對類型的分類，比如可確定大小類型、動態大小類型和零大小類型等。這一章還將介紹Rust類型推導功能及其不足。接下來將介紹Rust 中的泛型編程。泛型是Rust 類型系統中最重要
的一個概念。最后會介紹Rust 的“靈魂”，trait 系統。對類型系統建立一定的認知，有利于學習后面的內容。
第4 章 內存管理。這一章首先將介紹底層內存管理的通用概念。在此基礎上，圍繞內存安全這個核心，從變量定義到智能指針，逐漸闡述Rust 中資源管理的哲學。這部分內容是真正理解Rust 所有權機制的基礎。
第5 章 所有權系統。這一章首先會介紹關于值和引用語義的通用概念，然后在此基礎上探討Rust 的所有權機制。讀者將看到，Rust 如何結合類型系統和底層內存管理機制，以及上層值和引用的語義形成現在的Rust 所有權系統。然后，進一步圍繞內存安全的核心，闡述借用檢查和生命周期參數的意義。通過這一章的學習，讀者將會對Rust 的所有權系統有全面深入的了解。
第6 章 函數、閉包和迭代器。在對Rust 的類型系統和內存安全機制有了一定了解之后，我們將開始深入學習Rust 編程最常用的語法結構。函數是Rust 中最常用的語法單元。Rust的函數承載了諸多函數式編程范式的特性，比如高階函數、參數模式匹配等，同時也承載了面向對象范式的特性，比如為結構體及其實例實現方法，實際上就是一個函數調用的語法糖。
然后將介紹閉包的用法和特性，幫助讀者對閉包建立全面深入的認知，更重要的是，通過學習閉包的實現原理，進一步了解Rust 中零成本抽象的哲學思想。最后介紹迭代器模式，以及Rust 中的迭代器實現機制。迭代器也是Rust 最常用的特性，通過這一章的學習，你將徹底了解迭代器。
第7 章 結構化編程。這一章將對Rust 混合范式編程進行探討，會重點介紹Rust 中的結構體和枚舉體，以及它們如何在日常編程中以面向對象風格編程。同時，還將介紹三種設計模式，前兩種是Rust 標準庫以及第三方庫常用的設計模式，最后是一種合理利用Rust 資源管理哲學的設計模式。通過學習這一章的內容，有利于掌握地道的Rust 編程風格。
第8 章 字符串與集合類型。字符串是每門編程語言最基本的數據類型，Rust 自然也不例外。出于內存安全的考慮，Rust 中的字符串被分為了多種，并且語言自身沒有自帶正則表達式引擎。這一章將從字符編碼開始，圍繞內存安全，對Rust 中的字符和字符串做徹底梳理，并且闡述如何在沒有正則表達式引擎的情況下，滿足字符串進行匹配搜索等的需求。集合類型也是編程中必不可少的數據結構。這一章將著重介紹動態數組Vector 和Key-Value 映射集HashMap 的使用，而且還會深入挖掘HashMap 底層的實現原理，介紹Rust 標準庫提供的HashMap 安全性，進一步探討如何用Rust 實現一個生產級的數據結構。最后將通過探討一個Rust 安全漏洞的成因，來幫助讀者正確理解容量的概念，從而寫出更安全的代碼。
第9 章 構建健壯的程序。對于如何構建健壯的系統，Rust 給出了非常工程化的解決方案。Rust 將系統中的異常分為了多個層次，分別給出了對應的處理手段。在這一章，讀者將學習Rust 是如何以分層的錯誤處理解決方案來幫助開發者構建健壯系統的。
第10 章 模塊化編程。現代編程語言的一大特色就是可以方便地進行模塊化，這樣有利于系統的設計、維護和協作。Rust 在模塊化編程方面做得很好。這一章首先將介紹Rust 強大的包管理系統Cargo。然后會以真實的代碼實例闡述Rust 的模塊系統，并且將包含Rust 2018版本中模塊系統的重大改進。最后將以一個完整的項目為例闡述如何使用Rust 開發自己的crate。
第11 章 安全并發。Rust 從兩方面支持并發編程。首先，利用類型安全和內存安全的基礎，解決了多線程并發安全中的痛點：數據競爭。Rust 可以在編譯時發現多線程并發代碼中的安全問題。其次，Rust 為了達成高性能服務器開發的目標，開始全面擁抱異步開發。這一章將從線程安全的通用概念開始，從Rust 多線程并發講到異步并發支持，帶領讀者逐步形成全面、深入、通透的理解。
第12 章 元編程。元編程即程序生成程序的能力。Rust 為開發者提供了多種元編程能力。這一章將從反射開始介紹Rust 中的元編程。雖然Rust 的反射功能沒有動態語言的那么強大，但是Rust 提供了強大的宏系統。這一章將從Rust 的編譯過程出發，帶領讀者深入理解Rust的宏系統的工作機制，并且以具體的實例幫助讀者理解編寫宏的技巧。從聲明宏到過程宏，再到編譯器插件，以及第三方庫syn 和quote 最新版的配合使用，都將在本章進行闡述。
第13 章 超越安全的邊界。前面的章節內容基本都是建立在Safe Rust 的基礎上的。而這一章將主要圍繞Unsafe Rust 的內容來構建，主要分為4 大部分。首先將介紹Unsafe Rust 的基本語法和特性。然后，圍繞基于Unsafe 進行安全抽象的核心，闡述Unsafe Rust 開發過程中可能引起未定義行為的地方，以及相應的解決方案。然后介紹FFI，通過具體的實例來闡述Rust 如何和其他語言交互，涉及C、C++、Ruby、Python、Node.js 等語言，還將介紹相關的第三方庫。最后，將介紹未來互聯網的核心技術WebAssembly，以及Rust 如何開發WebAssembly 和相關的工具鏈。
相信通過這13 章的內容，讀者將會對Rust 有全面、深入和系統的認識。
勘誤及更多資源
有人的地方就有Bug，此書當然也不例外。寫書不僅是正確地傳播知識和思想的途徑，更是一種交流和溝通的方式。如果你發現本書中的任何錯誤、遺漏和解釋不清楚的地方，歡迎提出反饋。
勘誤說明：
? 直接提交issues。
? 標明具體的頁碼、行數和錯誤信息。
? 積極提出勘誤者將獲得合金Rust 勛章一枚。
更多的學習資源：
? 官方doc.rust-lang.org 列出了很多學習文檔和資源。
? 訂閱Rust 每日新聞1，了解Rust 社區生態發展，學習Rust。
致謝
首先，我要感謝Rust 社區中每一位幫助過我的朋友，沒有你們的奉獻，就沒有這本書。
感謝Mike 組織社區編寫的免費書籍Rust Primer。感謝Rust 社區中不知名的翻譯者翻譯官方的Rust Book。感謝知乎《Rust 編程》專欄作者辛苦的寫作。感謝KiChjang、ELTON、CrLF0710、F001、Lingo、tennix、iovxw、wayslog、Xidorn、42、黑腹喵等其他社區里的朋友們，你們在我學習的過程中給予了我無私的幫助和解答，Rust 社區有你們真好。感謝知道我寫作并一直鼓勵和支持我的朋友們。衷心希望Rust 社區可以一直這么強大、溫柔和友好。
然后，我要感謝電子工業出版社的劉恩惠編輯。感謝你給了我這個機會，讓這本書從想法成為了現實。
最后，感謝我的妻子宋欣欣，因為她的溫柔、大度、包容、信任和支持，才讓我能夠踏實且滿含信心地做我自己想做的事。感謝我的父母，正是他們的培養，才使我具有積極、堅持不懈做事情的品格。 |
內容簡介：Rust 是一門利用現代化的類型系統，有機地融合了內存管理、所有權語義和混合編程范式的編程語言。它不僅能科學地保證程序的正確性，還能保證內存安全和線程安全。同時，還有能與C/C++語言媲美的性能，以及能和動態語言媲美的開發效率。本書并非對語法內容進行簡單羅列講解，而是從四個維度深入全面且通透地介紹了Rust 語言。從設計哲學出發，探索Rust 語言的內在一致性；從源碼分析入手，探索Rust 地道的編程風格；從工程角度著手，探索Rust 對健壯性的支持；從底層原理開始，探索Rust 內存安全的本質。本書涵蓋了Rust 2018 的特性，適合有一定編程經驗且想要學習Rust 的初學者，以及對Rust 有一定的了解，想要繼續深入學習的進階者。
|
目錄：第1 章 新時代的語言 ............ 1
1.1 緣起 ............... 1
1.2 設計哲學 ............. 3
1.2.1 內存安全............. 3
1.2.2 零成本抽象 ........... 4
1.2.3 實用性 ............ 5
1.3 現狀與未來 ............. 7
1.3.1 語言架構............. 8
1.3.2 開源社區............. 9
1.3.3 發展前景............. 9
1.4 Rust 代碼如何執行 ............ 10
1.5 小結 ............... 10
第2 章 語言精要 ............ 11
2.1 Rust 語言的基本構成 ........... 11
2.1.1 語言規范............. 11
2.1.2 編譯器 ............ 12
2.1.3 核心庫 ............ 12
2.1.4 標準庫 ............ 12
2.1.5 包管理器............. 13
2.2 語句與表達式 ............. 13
2.3 變量與綁定 ............. 14
2.3.1 位置表達式和值表達式 ......... 15
2.3.2 不可變綁定與可變綁定 ......... 15
2.3.3 所有權與引用 ........... 16
2.4 函數與閉包 ............. 17
2.4.1 函數定義............. 17
2.4.2 作用域與生命周期 ........... 18
2.4.3 函數指針............. 19
2.4.5 CTFE 機制 ............ 20
2.4.6 閉包 ............ 20
2.5 流程控制 ............. 22
2.5.1 條件表達式 ........... 22
2.5.2 循環表達式 ........... 23
2.5.3 match 表達式與模式匹配 .......... 24
2.5.4 if let 和while let 表達式 .......... 25
2.6 基本數據類型 ............. 26
2.6.1 布爾類型............. 26
2.6.2 基本數字類型 ........... 26
2.6.3 字符類型............. 27
2.6.4 數組類型............. 28
2.6.5 范圍類型............. 29
2.6.6 切片類型............. 29
2.6.7 str 字符串類型 ............ 30
2.6.8 原生指針............. 31
2.6.9 never 類型 ........... 31
2.7 復合數據類型 ............. 32
2.7.1 元組 ............ 32
2.7.2 結構體 ............ 33
2.7.3 枚舉體 ............ 36
2.8 常用集合類型 ............. 38
2.8.1 線性序列：向量 ........... 38
2.8.2 線性序列：雙端隊列 ......... 39
2.8.3 線性序列：鏈表 ........... 40
2.8.4 Key-Value 映射表：HashMap 和BTreeMap ...... 40
2.8.5 集合：HashSet 和BTreeSet ........ 41
2.8.6 優先隊列：BinaryHeap ......... 42
2.9 智能指針 ............. 42
2.10 泛型和trait ............. 43
2.10.1 泛型 ............ 43
2.10.2 trait ............ 44
2.11 錯誤處理 ............. 47
2.12 表達式優先級 ............. 48
2.13 注釋與打印 ............. 48
2.14 小結 ............... 50
第3 章 類型系統 ............ 51
3.1 通用概念 ............. 51
3.1.1 類型系統的作用 ........... 51
3.1.2 類型系統的分類 ........... 52
3.1.3 類型系統與多態性 ........... 53
3.2 Rust 類型系統概述 ............ 53
3.2.1 類型大小............. 53
3.2.2 類型推導............. 58
3.3 泛型 ............... 60
3.3.1 泛型函數............. 60
3.3.2 泛型返回值自動推導 ......... 62
3.4 深入trait ............. 62
3.4.1 接口抽象............. 63
3.4.2 泛型約束............. 69
3.4.3 抽象類型............. 71
3.4.4 標簽trait ............. 77
3.5 類型轉換 ............. 83
3.5.1 Deref 解引用 ............ 83
3.5.2 as 操作符 ............ 86
3.5.3 From 和Into ........... 88
3.6 當前trait 系統的不足 ............ 89
3.6.1 孤兒規則的局限性 ........... 90
3.6.2 代碼復用的效率不高 ......... 91
3.6.3 抽象表達能力有待改進 ......... 93
3.7 小結 ............... 94
第4 章 內存管理 ............ 95
4.1 通用概念 ............. 95
4.1.1 棧 .............. 96
4.1.2 堆 .............. 99
4.1.3 內存布局........... 101
4.2 Rust 中的資源管理 ...........103
4.2.1 變量和函數 ........... 103
4.2.2 智能指針與RAII ........... 106
4.2.3 內存泄漏與內存安全 ......... 110
4.2.4 復合類型的內存分配和布局 ......... 115
4.3 小結 .............. 117
第5 章 所有權系統 ............ 119
5.1 通用概念 ..............120
5.2 所有權機制 ............123
5.3 綁定、作用域和生命周期 ..........125
5.3.1 不可變與可變 ........... 126
5.3.2 綁定的時間屬性——生命周期 ....... 127
5.4 所有權借用 ............131
5.5 生命周期參數 ............135
5.5.1 顯式生命周期參數 ........... 136
5.5.2 省略生命周期參數 ........... 143
5.5.3 生命周期限定 ........... 145
5.5.4 trait 對象的生命周期 ......... 145
5.6 智能指針與所有權 ............146
5.6.1 共享所有權 Rc＜T＞和Weak＜T＞ ........ 149
5.6.2 內部可變性Cell＜T＞和RefCell＜T＞ ........ 151
5.6.3 寫時復制Cow＜T＞ ........... 153
5.7 并發安全與所有權 ............156
5.8 非詞法作用域生命周期 ..........157
5.9 小結 ..............161
第6 章 函數、閉包與迭代器.......... 162
6.1 函數 ..............162
6.1.1 函數屏蔽........... 164
6.1.2 函數參數模式匹配 ........... 164
6.1.3 函數返回值 ........... 165
6.1.4 泛型函數........... 166
6.1.5 方法與函數 ........... 167
6.1.6 高階函數........... 168
6.2 閉包 ..............171
6.2.1 閉包的基本語法 ........... 172
6.2.2 閉包的實現 ........... 173
6.2.3 閉包與所有權 ........... 178
6.2.4 閉包作為函數參數和返回值 ......... 184
6.2.5 高階生命周期 ........... 190
6.3 迭代器 ..............194
6.3.1 外部迭代器和內部迭代器 ......... 194
6.3.2 Iterator trait ........... 195
6.3.3 IntoIterator trait 和迭代器 ........ 199
6.3.4 迭代器適配器 ........... 202
6.3.5 消費器 ............ 207
6.3.6 自定義迭代器適配器 ......... 211
6.4 小結 ..............214
第7 章 結構化編程 ............ 216
7.1 面向對象風格編程 ............217
7.1.1 結構體 ............ 217
7.1.2 枚舉體 ............ 225
7.1.3 析構順序........... 230
7.2 常用設計模式 ............233
7.2.1 建造者模式 ........... 234
7.2.2 訪問者模式 ........... 236
7.2.3 RAII 模式 ........... 239
7.3 小結 ..............243
第8 章 字符串與集合類型 ........... 244
8.1 字符串 ..............244
8.1.1 字符編碼........... 244
8.1.2 字符 ............ 247
8.1.3 字符串分類 ........... 249
8.1.4 字符串的兩種處理方式 ......... 251
8.1.5 字符串的修改 ........... 253
8.1.6 字符串的查找 ........... 256
8.1.7 與其他類型相互轉換 ......... 265
8.1.8 回顧 ............ 270
8.2 集合類型 ..............271
8.2.1 動態可增長數組 ........... 271
8.2.2 映射集 ............ 281
8.3 理解容量 ..............289
8.4 小結 ..............292
第9 章 構建健壯的程序 ........... 294
9.1 通用概念 ..............294
9.2 消除失敗 ..............295
9.3 分層處理錯誤 ............297
9.3.1 可選值Option＜T＞ .......... 298
9.3.2 錯誤處理Result＜T, E＞ .......... 302
9.4 恐慌（Panic） .............314
9.5 第三方庫 ..............316
9.6 小結 ..............319
第10 章 模塊化編程 ............ 320
10.1 包管理 ..............321
10.1.1 使用Cargo 創建包 ......... 321
10.1.2 使用第三方包 ........... 323
10.1.3 Cargo.toml 文件格式 .......... 331
10.1.4 自定義Cargo .......... 337
10.2 模塊系統 ..............339
10.3 從零開始實現一個完整功能包 ..........344
10.3.1 使用Cargo 創建新項目 ......... 345
10.3.2 使用structopt 解析命令行參數 ....... 345
10.3.3 定義統一的錯誤類型 ......... 347
10.3.4 讀取CSV 文件 ........... 348
10.3.5 替換CSV 文件中的內容 ......... 351
10.3.6 進一步完善包 ........... 353
10.4 可見性和私有性 ............358
10.5 小結 ..............360
第11 章 安全并發 ............ 362
11.1 通用概念 ..............362
11.1.1 多進程和多線程 ........... 363
11.1.2 事件驅動、異步回調和協程 ......... 364
11.1.3 線程安全 ........... 365
11.2 多線程并發編程 ............370
11.2.1 線程管理 ........... 371
11.2.2 Send 和Sync ........... 375
11.2.3 使用鎖進行線程同步 ......... 379
11.2.4 屏障和條件變量 ........... 384
11.2.5 原子類型 ........... 386
11.2.6 使用Channel 進行線程間通信 ........ 388
11.2.7 內部可變性探究 ........... 397
11.2.8 線程池 ............. 399
11.2.9 使用Rayon 執行并行任務 ........ 407
11.2.10 使用Crossbeam .......... 409
11.3 異步并發 ..............412
11.3.1 生成器 ............. 413
11.3.2 Future 并發模式 ........... 418
11.3.3 async/await ............ 421
11.4 數據并行 ..............428
11.4.1 什么是SIMD .......... 429
11.4.2 在Rust 中使用SIMD......... 430
11.5 小結 ..............434
第12 章 元編程 ............. 435
12.1 反射 ..............436
12.1.1 通過is 函數判斷類型 .......... 436
12.1.2 轉換到具體類型 ........... 437
12.1.3 非靜態生命周期類型 ......... 439
12.2 宏系統 ..............440
12.2.1 起源 ............ 440
12.2.2 Rust 中宏的種類 .......... 441
12.2.3 編譯過程 ........... 442
12.2.4 聲明宏 ............ 445
12.2.5 過程宏 ............ 458
12.3 編譯器插件 ............472
12.4 小結 ..............475
第13 章 超越安全的邊界 ........... 477
13.1 Unsafe Rust 介紹 ...........477
13.1.1 Unsafe 語法 ............ 478
13.1.2 訪問和修改可變靜態變量 ......... 480
13.1.3 Union 聯合體 .......... 480
13.1.4 解引用原生指針 ........... 483
13.2 基于Unsafe 進行安全抽象 .........484
13.2.1 原生指針 ........... 484
13.2.2 子類型與型變 ........... 489
13.2.3 未綁定生命周期 ........... 494
13.2.4 Drop 檢查 ........... 495
13.2.5 NonNull＜T＞指針 .......... 505
13.2.6 Unsafe 與恐慌安全 .......... 508
13.2.7 堆內存分配 ........... 508
13.2.8 混合代碼內存安全架構三大原則 ....... 510
13.3 和其他語言交互 ............510
13.3.1 外部函數接口 ........... 510
13.3.2 與C/C++語言交互 ......... 514
13.3.3 使用Rust 提升動態語言性能 ....... 528
13.4 Rust 與WebAssembly ...........532
13.4.1 WebAssembly 要點介紹......... 533
13.4.2 使用Rust 開發WebAssembly ....... 539
13.4.3 打造WebAssembly 開發生態 ........ 541
13.5 小結 ..............543
附錄A Rust 開發環境指南 ........... 544
附錄B Rust 如何調試代碼 ........... 549 |
| 序： |
|
