松本行弘的程式世界

松本行弘的程式世界

《松本行弘的程式世界》是人民郵電出版社2011年出版的圖書,作者是(日) 松本行弘。

基本信息

內容簡介

本書是探索程式設計思想和方法的經典之作。作者從全局的角度,利用大量的程式示例及圖表,深刻闡述了Ruby程式語言的設計理念,並以獨特的視角對與編程相關的各種技術進行了考察。閱讀本書不僅可以深入了解編程世界各個要素之間的關係,而且能夠學到大師級的程式思考方法。

本書面向各層次程式設計人員和編程愛好者,也可以供相關技術人員參考。

作者簡介

松本行弘 Ruby語言的發明人,在1993年發布了Ruby語言的第一個版本,以後一直從事Ruby的設計與開發。2011年加入著名SaaS廠商Salesforce旗下PaaS公司Heroku,任首席Ruby架構師,致力於加快Ruby Core的開發。他還是NaCI及樂天技術研究所的研究員。著有Ruby in a nutshell和The Ruby Programming Language 等書。

圖書目錄

第1章 我為什麼開發Ruby 1

1.1 我為什麼開發Ruby 2

1.1.1 程式語言的重要性 2

1.1.2 Ruby的原則 3

1.1.3 簡潔性 4

1.1.4 擴展性 5

1.1.5 穩定性 6

1.1.6 一切皆因興趣 7

第2章 面向對象 9

2.1 編程和面向對象的關係 10

2.1.1 顛倒的構造 10

2.1.2 主宰計算機的武器 11

2.1.3 怎樣寫程式 12

2.1.4 面向對象的編程方法 12

2.1.5 面向對象的難點 13

2.1.6 多態性 13

2.1.7 具體的程式 14

2.1.8 多態性的優點 15

2.2 數據抽象和繼承 16

2.2.1 面向對象的歷史 16

2.2.2 複雜性是面向對象的敵人 18

2.2.3 結構化編程 18

2.2.4 數據抽象化 19

2.2.5 雛形 21

2.2.6 找出相似的部分來繼承 22

2.3 多重繼承的缺點 23

2.3.1 為什麼需要多重繼承 23

2.3.2 多重繼承和單一繼承不可分離 24

2.3.3 goto語句和多重繼承比較相似 25

2.3.4 解決多重繼承的問題 25

2.3.5 靜態語言和動態語言的區別 26

2.3.6 靜態語言的特點 26

2.3.7 動態語言的特點 27

2.3.8 靜態語言和動態語言的比較 27

2.3.9 繼承的兩種含義 28

2.3.10 接口的缺點 28

2.3.11 繼承實現的方法 29

2.3.12 從多重繼承變形而來的Mix-in 29

2.3.13 積極支持Mix-in的Ruby 30

2.4 兩個誤解 31

2.4.1 面向對象的編程 31

2.4.2 對象的模板=類 33

2.4.3 利用模組的手段=繼承 33

2.4.4 多重繼承不好嗎 34

2.4.5動態編程語言也需要多重繼承 35

2.4.6 馴服多重繼承的方法 35

2.4.7 Ruby中多重繼承的實現方法 37

2.4.8 Java實現多重繼承的方法 38

2.5 Duck Typing誕生之前 39

2.5.1 為什麼需要類型 39

2.5.2 動態的類型是從Lisp中誕生的 40

2.5.3 動態類型在面向對象中發展起來了 41

2.5.4 動態類型和靜態類型的邂逅 42

2.5.5 靜態類型的優點 42

2.5.6 動態類型的優點 43

2.5.7 只關心行為的Duck Typing 44

2.5.8 避免明確的類型檢查 45

2.5.9 克服動態類型的缺點 46

2.5.10 動態程式語言 46

2.6 元編程 46

2.6.1 元編程 46

2.6.2 反射 47

2.6.3 元編程的例子 48

2.6.4 使用反射功能 48

2.6.5 分散式Ruby的實現 49

2.6.6 資料庫的套用 50

2.6.7 輸出XML 51

2.6.8 元編程和小程式語言 51

2.6.9 聲明的實現 52

2.6.10 上下文相關的實現 52

2.6.11 單位的實現 53

2.6.12 辭彙的實現 53

2.6.13 層次數據的實現 54

2.6.14 適合DSL的語言,不適合DSL的語言 54

第3章 程式塊 57

3.1 程式塊的威力 58

3.1.1 把函式作為參數的高階函式 58

3.1.2 C語言高階函式的局限 59

3.1.3 可以保存外部環境的閉包 60

3.1.4 塊的兩種使用方法 60

3.1.5 最終來看,塊到底是什麼 61

3.1.6 塊在循環處理中的套用 62

3.1.7 內部疊代器和外部疊代器 62

3.1.8 在排序和比較大小中的套用 63

3.1.9 用塊保證程式的後處理 63

3.1.10 用塊實現新的控制結構 64

3.1.11 在回調中使用塊 65

3.1.12 塊處理的特別理由 65

3.2 用塊作循環 66

3.2.1 塊是處理的集合 67

3.2.2 塊套用範圍的擴展 68

3.2.3 高階函式和塊的本質一樣 69

3.2.4 用Enumerable來利用塊 69

3.2.5 Enumerable的局限 74

3.3 精通集合的使用 77

3.3.1 使用Ruby的數組 77

3.3.2 修改指定範圍的元素內容 78

3.3.3 Ruby中的哈希處理 78

3.3.4 支持循環的Enumerable 79

3.3.5 用於循環的each方法 81

3.3.6 使用inject、zip和grep 81

3.3.7 用來指定條件的select方法 82

3.3.8 排序與比較大小的方法 83

3.3.9 在類中包含(include)Enumerable模組 84

3.3.10 List的內部包和塊的區別 85

第4章 設計模式 89

4.1 設計模式(1) 90

4.1.1 設計模式的價值和意義 91

4.1.2 設計模式是程式抽象化的延伸 92

4.1.3 Ruby中的設計模式 92

4.1.4 Singleton模式 92

4.1.5 Proxy模式 94

4.1.6 Iterator模式 95

4.1.7 外部與內部,哪一個更好 96

4.1.8 內部疊代器的缺陷 97

4.1.9 外部疊代器的缺陷 98

4.2 設計模式(2) 98

4.2.1 模式與動態語言的關係 99

4.2.2 重複使用既存對象的Prototype模式99

4.2.3 親身體驗Io語言 100

4.2.4 Ruby中的原型 101

4.2.5 編寫抽象算法的Template Method模式 101

4.2.6 用Ruby來嘗試TemplateMethod 102

4.2.7 動態語言與Template Method模式 104

4.2.8 避免高度依賴性的Observer模式104

4.2.9observable模組 105

4.2.10 Observer模式與動態語言 107

4.3 設計模式(3) 107

4.3.1 軟體開發的悲劇 108

4.3.2 開放-封閉原則 108

4.3.3 面向對象的情況 109

4.3.4 非面向對象的情況 110

4.3.5 OCP與Template Method模式 111

4.3.6 Observer模式 113

4.3.7 使用Strategy模式 114

4.3.8 Strategy模式與OCP 116

第5章 Ajax 119

5.1 Ajax和JavaScript(前篇) 120

5.1.1 通信及異步頁面更新 120

5.1.2 技術要素之一:JavaScript 122

5.1.3 技術要素之二:XML 122

5.1.4 XML以外的數據表現形式 123

5.1.5 技術要素之三:DHTML 124

5.1.6 JavaScript技術基礎 124

5.1.7原型模式面向對象程式語言126

5.1.8 使用prototype.js庫 127

5.1.9 prototype.js的功能 127

5.2 Ajax和JavaScript(後篇) 130

5.2.1 巧妙使用DHTML 131

5.2.2 獲取document節點 132

5.2.3 獲取和更新標籤數據 133

5.2.4 設定事件處理程式 133

5.2.5 追加標籤節點 135

5.2.6 本地HTML套用 135

5.2.7 和伺服器間的通信 137

5.2.8 使用Prototype.js的優點 138

5.2.9 在伺服器上保存數據 138

5.2.10 Web套用的脆弱性 140

5.2.11 使用JavaScript的感覺 141

第6章 Ruby on Rails 143

6.1 MVC和Ruby on Rails 144

6.1.1 模型、視圖和控制的作用 144

6.1.2 用秒表的例子來學習MVC模式 145

6.1.3 生成視圖和控制部分 147

6.1.4 GUI工具箱與MVC 148

6.1.5 同時使用工具箱和MVC 149

6.1.6 MVC的優缺點 151

6.1.7 Web套用中的MVC 152

6.2 開放類和猴子補丁 153

6.2.1 開放類 154

6.2.2 猴子補丁的目的 154

6.2.3 猴子補丁的技巧 155

6.2.4 靈活使用開放類的庫 159

6.2.5 猴子補丁的幾點問題 161

6.2.6 其他辦法 162

6.2.7 Ruby on Rails和開放類 165

6.2.8 ActiveSupport帶來的擴展 166

6.2.9 位元組單位系列 168

6.2.10 複數形和序數 168

6.2.11 大規模開發和Ruby 169

6.2.12 信賴性模型 170

6.2.13 猴子補丁的未來 170

第7章 文字編碼 173

7.1 文字編碼的種類 174

7.1.1 早期的文字編碼 174

7.1.2 紙帶與文字表現 175

7.1.3 文字是什麼 176

7.1.4 走向英語以外的語言(歐洲篇) 177

7.1.5 英語以外的語言(亞洲篇) 177

7.1.6 Unicode的問世 180

7.1.7 統一編碼成16位的漢字統合 181

7.1.8 Unicode的兩個問題 181

7.1.9 Unicode的文字集 182

7.1.10 文字表示的不確定性 183

7.1.11 Unicode的字元編碼方式 183

7.2 程式中的文字處理 185

7.2.1 文字編碼有多個意思 185

7.2.2 只能處理文字集中包含的文字 185

7.2.3 紛繁複雜的文字編碼方式 186

7.2.4 影響力漸微的Shift_JIS與EUC-JP 186

7.2.5 Unicode有多種字元編碼方式 186

7.2.6 為什麼會發生亂碼 188

7.2.7 字元編碼方式錯誤 188

7.2.8 沒有字型 189

7.2.9 變換為內部碼時出錯 189

7.2.10 發生不完全變換 189

7.2.11 文字集的不同 190

7.2.12位元組順序錯誤 191

7.2.13 從程式語言的角度處理文字 191

7.2.14 以變換為前提的UCS方式 191

7.2.15 原封不動處理的CSI方式 192

7.2.16 使用UTF-16的Java 192

7.2.17 使用UTF-8的Perl 193

7.2.18 用UTF-16的Python 194

7.2.19 採用CSI方式的Ruby 1.8 194

7.2.20 強化了功能的Ruby 1.9 195

7.2.21 是UCS還是CSI 196

第8章 正則表達式 199

8.1 正則表達式基礎 200

8.1.1 檢索“像那樣的東西” 200

8.1.2 正則表達式的語法 200

8.1.3 3個陷阱 203

8.1.4 正則表達式對象 204

8.1.5 選項 205

8.1.6 正則表達式匹配的方法 206

8.1.7 特殊變數 207

8.1.8 字元串與正則表達式 207

8.1.9 split的本質 207

8.1.10 字元串的掃描 208

8.1.11 置換 208

8.2 正則表達式的套用實例與“鬼車” 210

8.2.1 解析日誌檔案的方法 211

8.2.2 避免使用$的方法 213

8.2.3 從郵件中取出日期的方法 215

8.2.4 典型拼寫錯誤的檢索方法 216

8.2.5 Ruby 1.9的新功能“鬼車” 216

第9章 整數和浮點小數 219

9.1 深奧的整數世界 220

9.1.1 整數是有範圍的 221

9.1.2 嘗試位運算 222

9.1.3 操作特定的位 223

9.1.4 表示負數的辦法 225

9.1.5 Ruby的整數 226

9.1.6 挑戰公開密鑰方式 227

9.2 撲朔迷離的浮點小數世界 228

9.2.1 計算機對小數的處理 229

9.2.2 固定小數點數不易使用 229

9.2.3科學計數法也有問題 229

9.2.4 小數不能完全表示 230

9.2.5 有不能比較的時候 231

9.2.6 誤差積累 232

9.2.7 不是數的特別“數” 232

9.2.8 計算誤差有多種 233

9.2.9 誤差導致的嚴重問題 235

9.2.10 BigDecimal是什麼 236

9.2.11 能夠表示分數的Rational類 236

第10章 高速執行和並行處理 239

10.1 讓程式高速執行(前篇) 240

10.1.1 是不是越快越好 240

10.1.2 高速執行的樂趣與效率 240

10.1.3 以數據為基礎作出判斷 241

10.1.4 改善系統調用 241

10.1.5 數據可靠嗎 243

10.1.6 只需改善瓶頸 243

10.1.7 profiler本身成了累贅 245

10.1.8 算法與數據結構 245

10.1.9 理解O記法 245

10.1.10 選擇算法 246

10.1.11 調查算法的性能 246

10.1.12 高速執行的悲哀 247

10.1.13 性能最佳化的格言 248

10.2 讓程式高速執行(後篇) 248

10.2.1 確認程式概要 249

10.2.2 發現瓶頸 250

10.2.3 使用更好的profiler 251

10.2.4 高速最佳化之一:削減對象 252

10.2.5 高速最佳化之二:利用立即值 254

10.2.6 高速最佳化之三:利用C語言 255

10.2.7 高速最佳化之四:採用合適的數據結構 256

10.2.8 全部以C語言計算 257

10.2.9 還存在其他技巧 257

10.3 並行編程 258

10.3.1 使用執行緒的理由 258

10.3.2 生成執行緒 259

10.3.3 執行緒的執行狀態 260

10.3.4 傳遞值給執行緒的方法 261

10.3.5 信息共有所產生的問題 262

10.3.6 數據完整性的喪失 262

10.3.7 死鎖 263

10.3.8 用鎖來實現對資源的獨占 264

10.3.9 二級互斥 265

10.3.10 用佇列協調執行緒 265

10.3.11 鎖模型與佇列模型的比較 267

10.4 前景可期的並行編程技術,Actor 268

10.4.1 何謂Actor 268

10.4.2 操作Actor的3種處理系統 269

10.4.3 Erlang的程式 270

10.4.4 Pingpong處理的開始 270

10.4.5 啟動pingpong程式 271

10.4.6 Erlang的錯誤處理 272

10.4.7 Erlang的使用場所 273

10.4.8 面向Ruby的庫“Revactor” 273

10.4.9 Revactor的套用場合 274

10.4.10 另一個庫Dramatis 275

第11章 程式安全性 279

11.1 程式的漏洞與攻擊方法 280

11.1.1 4種軟體漏洞 280

11.1.2 因許可權被竊取而成為重大問題 281

11.1.3 安全問題的根源 281

11.1.4 “守護神”引起的問題 282

11.1.5 多 樣化的攻擊手段 282

11.1.6 緩衝區溢出 283

11.1.7 整數溢出 284

11.1.8 SQL注入 285

11.1.9 Shell注入 286

11.1.10 跨站點腳本攻擊 287

11.1.11 跨站點偽造請求 288

11.1.12 社會工程 289

11.2 用異常進行錯誤處理 290

11.2.1 異常的歷史 292

11.2.2 Java的受控異常 292

11.2.3 Icon的面向目標判斷 293

11.2.4 Ruby的異常 294

11.2.5 異常發生 295

11.2.6 異常類 296

11.2.7 異常處理的設計方針 297

11.2.8 異常發生的設計原則 298

第12章 關於時間的處理 301

12.1 用程式處理時刻與時間 302

12.1.1 時差與時區 302

12.1.2世界協調時間 302

12.1.3 夏令時(DST) 303

12.1.4 改歷 304

12.1.5 日期與時間的類 305

12.1.62038年問題308

12.1.7 DateTime類 309

12.1.8 Time與DateTime的相互變換 310

第13章 關於數據的持久化 313

13.1 持久化數據的方法 314

13.1.1 保存文本 314

13.1.2 變換成文本的Marshal 314

13.1.3 使用Marshal模組 315

13.1.4 複製有兩種方式 316

13.1.5 仔細看Marshal的格式 316

13.1.6 不能保存的3類對象 317

13.1.7 製作面向對象資料庫 318

13.1.8 試用PStore 318

13.1.9 變換為文本的YAML320

13.1.10 用YAML製作資料庫 321

13.2 對象的保存 322

13.2.1 高速的Objectprevalence322

13.2.2 Object Prevalence的問題點 323

13.2.3 使用Madeleine323

13.2.4 訪問時刻信息 325

13.2.5 讓Madeleine更容易使用 326

13.2.6 Madeleine的實用例Instiki 328

13.3 關於XML的考察 328

13.3.1 XML的祖先是SGML 329

13.3.2 XML是樹結構的數據表現 329

13.3.3 優點在於純文本 330

13.3.4 缺點在於冗長 331

13.3.5 不適合重視效率的處理 331

13.3.6 適合於信息交換的格式 332

13.3.7 XML的解析 332

13.3.8 XML處理庫REXML 333

13.3.9 XML的代替 336

第14章 函式式編程 339

14.1 新范型——函式式編程 340

14.1.1 具有多種函式式性質的Lisp 341

14.1.2 徹底的函式式程式語言Haskell 342

14.1.3 延遲計算:不必要的處理就不做 343

14.1.4 靈活的“靜態多態性”類型系統 344

14.1.5 近代函式式語言之父OCaml 345

14.1.6 強於並行計算的Erlang 345

14.1.7 用Ruby進行函式式編程 346

14.1.8 用枚舉器來實現延遲計算 347

14.2 自動生成代碼 348

14.2.1 在商業中利用Ruby 349

14.2.2 使用Ruby自動生成代碼 350

14.2.3 消除重複代碼 350

14.2.4 代碼生成的套用 351

14.2.5 代碼生成的效果 352

14.2.6 編寫代碼生成器 353

14.2.7 也可以使用XML 354

14.2.8 在EJB中使用代碼生成 355

14.3 記憶體管理與垃圾收集 356

14.3.1 記憶體管理的困難 357

14.3.2 垃圾收集亮相之前 358

14.3.3 評價垃圾收集的兩個指標 359

14.3.4 垃圾收集算法 360

14.3.5 引用計數方式 360

14.3.6 標記和掃除方式 361

14.3.7 標記和緊縮方式 362

14.3.8 複製方式 363

14.3.9 多種多樣的垃圾收集算法 364

14.3.10 分代垃圾收集 364

14.3.11 保守垃圾收集 366

14.3.12 增量垃圾收集 366

14.3.13 並行垃圾收集 367

14.3.14 點陣圖標記 367

14.4 用C語言來擴展Ruby 368

14.4.1 開發與執行速度的取捨 368

14.4.2 擴展庫 369

14.4.3 看例題學習擴展模組 370

14.4.4 QDBM函式 372

14.4.5 初始化對象 373

14.4.6 實現方法 374

14.4.7 關於垃圾收集的注意事項 376

14.4.8 其他的Ruby API 376

14.4.9 擴展庫的編譯 376

14.4.10 擴展庫以外的工具 377

14.5 為什麼要開源 380

14.5.1 自由軟體的思想 380

14.5.2 自由軟體的歷史 381

14.5.3 Emacs事件的發生 381

14.5.4 開源的誕生 382

14.5.5 OSS許可證 383

14.5.6 開源的背景 385

14.5.7 企業關注開源的理由 386

14.5.8 Ruby與開源 386

14.5.9 選擇許可證的方法 387

相關詞條

相關搜尋

熱門詞條

聯絡我們