本书的赞誉

译者序

序

前言

致谢

第一部分 设计模式和Ruby

第1章 使用设计模式创建更好的程序

1.1 四人组

1.2 模式的模式

1.2.1 把变和不变的事物分开

1.2.2 针对接口编程而不对实现编程

1.2.3 组合优先于继承

1.2.4 委托、委托、委托

1.2.5 你不会用到它

1.3 23种模式中的14种

1.4 Ruby中的设计模式

第2章 从Ruby起步

2.1 交互式Ruby

2.2 说helloworld

2.3 变量

2.4 Fixnums和Bignums

2.5 浮点数

2.6 这里没有原始类型

2.7 但是有时没有对象

2.8 true、false和til

2.9 判定、判定

2.10 循环

2.11 更多关于字符串

2.12 符号

2.13 数组

2.14 散列

2.15 正则表达式

2.16 自己的类

2.17 获取一个实例变量

2.18 对象问：我是谁

2.19 继承、子类和超类

2.20 参数选项

2.21 模组

2.22 异常

2.23 线程

2.24 管理分散的源文件

2.25 本章回顾

第二部分 Ruby中的模式

第3章 使用模板方法变换算法

3.1 迎接现实中的挑战

3.2 将不变的部分独立出来

3.3 探究模板方法模式

3.4 钩子方法

3.5 但是类型声明都去哪里了

3.6 类型、安全和灵活性

3.7 单元测试并非可有可无

3.8 使用和滥用模板方法模式

3.9 模板方法模式的实际应用

3.10 本章回顾

第4章 使用策略替换算法

4.1 委托、委托、还是委托

4.2 在策略和环境中共享数据

4.3 再说鸭子类型

4.4 Proc和代码块

4.5 快速而随性的策略对象

4.6 使用和滥用策略模式

4.7 策略模式的实际应用

4.8 本章回顾

第5章 通过观察器保持协调

5.1 随时待命

5.2 更好的随时待命方法

5.3 提取可被观察能力支持的代码

5.4 使用代码块作为观察器

5.5 观察器模式的异体

5.6 使用和滥用观察器模式

5.7 观察器模式的实际应用

5.8 本章回顾

第6章 使用组合模式将各部分组成整体

6.1 整体和部分

6.2 创建组合

6.3 使用运算符将组合模式打扮整齐

6.4 给予数组的组合类

6.5 一种不方便的差异

6.6 给各层次指明方向

6.7 使用和滥用组合模式

6.8 组合模式的实际应用

6.9 本章回顾

第7章 通过迭代器遍历集合

7.1 外部迭代器

7.2 内部迭代器

7.3 比较内部迭代器和外部迭代器

7.4 无可比拟的Enumerable

7.5 使用和滥用迭代器模式

7.6 迭代器的实际应用

7.7 本章回顾

第8章 使用命令模式完成任务

8.1 子类大泛滥

8.2 一个更简便的方法

8.3 代码块即命令

8.4 用于记录操作的命令

8.5 使用命令取消一个操作

8.6 命令队列

8.7 使用和滥用命令模式

8.8 命令模式的实际应用

8.8.1 ActiveRecord数据移植

8.8.2 Madeleine

8.9 本章回顾

第9章 使用适配器填补空隙

9.1 软件适配器

9.2 几乎错过

9.3 适配器的另一种选择

9.4 修改单个实例

9.5 适配还是修改

9.6 使用和滥用适配器模式

9.7 适配器模式的实际应用

9.8 本章回顾

第10章 通过代理来到对象面前

10.1 使用代理进行拯救

10.2 保护代理

10.3 远程代理

10.4 虚拟代理让人变懒

10.5 取消代理的苦差事

10.5.1 消息传递和方法

10.5.2 method_missing方法

10.5.3 发送消息

10.5.4 无痛的代理

10.6 使用和滥用代理

10.7 代理模式的实际应用

10.8 本章回顾

第11章 使用装饰器改善对象

11.1 装饰器：丑陋代码的解药

11.2 正式装饰

11.3 减轻代理的郁闷

11.4 实现装饰器模式的另一种动态方法

11.4.1 装饰方法

11.4.2 使用模组进行装饰

11.5 使用和滥用装饰器模式

11.6 装饰器的实际应用

11.7 本章回顾

第12章 使用单例确保仅有一个

12.1 一个对象，全局访问

12.2 类变量和类方法

12.2.1 类变量

12.2.2 类方法

12.3 Ruby单例应用的第一次尝试

12.3.1 管理单个实例

12.3.2 确保只有一个

12.4 单例模组

12.5 勤性单例和惰性单例

12.6 其他单例模式的实现方法

12.6.1 使用全局变量作为单例

12.6.2 使用类作为单例

12.6.3 使用模组作为单例

12.7 安全带还是拘束衣

12.8 使用和滥用单例模式

12.8.1 实际上就是全局变量

12.8.2 到底需要多少这样的单例

12.8.3 在需要知道的基础上的单例

12.8.4 减轻测试的郁闷

12.9 单例模式的实际应用

12.10 本章回顾

第13章 使用工厂模式挑选正确的类

13.1 一种不同的鸭子类型

13.2 模板方法再露一手

13.3 参数化的工厂方法

13.4 类也是对象

13.5 坏消息：你的程序搞大了

13.6 对象创建的组合

13.7 再论类就是对象

13.8 协调名字

13.9 使用和滥用工厂模式

13.10 工厂模式的实际应用

13.11 本章回顾

第14章 通过生成器简化对象创建

14.1 制造计算机

14.2 多态生成器

14.3 生成器能保证产生健全的对象

14.4 可重用的生成器

14.5 使用魔术方法制作更好的生成器

14.6 使用和滥用生成器模式

14.7 生成器模式的实际应用

14.8 本章回顾

第15章 使用解释器组建系统

15.1 用以完成任务的正确语言

15.2 构建一个解释器

15.3 一个文件查找解释器

15.3.1 查找所有文件

15.3.2 根据文件名查找文件

15.3.3 大文件和可写文件

15.3.4 加入Not、And和Or的更复杂的检索

15.4 创建AST

15.4.1 一个简单的分析器

15.4.2 没有分析器的解释器

15.4.3 让XML和YAML进行分析工作

15.4.4 为更复杂的分析器使用Racc

15.4.5 让Ruby作分析

15.5 使用和滥用解释器模式

15.6 解释器模式的实际应用

15.7 本章回顾

第三部分 Ruby的设计模式

第16章 采用域指定语言打开系统

16.1 特定语言的域

16.2 备份文件的DSL

16.3 是数据文件，更是程序

16.4 构建PackRat

16.5 将DSL合成一体

16.6 评估PackRat

16.7 改进PackRat

16.8 使用和滥用内部DSL

16.9 内部DSL的实际应用

16.10 本章回顾

第17章 使用元编程创建自定义对象

17.1 通过方法度身定制的对象和方法

17.2 通过模块自定义对象和模块

17.3 召唤出崭新的方法

17.4 到对象的内部看看

17.5 使用和滥用元编程

17.6 元编程的实际应用

17.7 本章回顾

第18章 惯例优于配置

18.1 一个优秀的用户界面—对于开发者

18.1.1 预期需求

18.1.2 让他们说一次

18.1.3 提供一个模板

18.2 一个消息中转器

18.3 选择适配器

18.4 载入类

18.5 增加一些安全性

18.6 帮助用户开始使用

18.7 评估消息中转器

18.8 使用和滥用惯例优于配置模式

18.9 惯例优于配置的实际应用

18.10 本章回顾

第19章 总结

附录