RUBY原理剖析 ＝ RUBY UNDER A MICROSCOPEPDF|Epub|txt|kindle电子书版本网盘下载

RUBY原理剖析 ＝ RUBY UNDER A MICROSCOPEPDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

1 分词与语法解析3

1.1 词条：构成Ruby语言的单词5

1.2 语法解析：Ruby如何理解代码13

1.2.1 理解LALR解析算法14

1.2.2 真实的Ruby语法规则21

1.3 总结31

2 编译33

2.1 Ruby 1.8没有编译器34

2.2 Ruby 1.9和Ruby 2.0引入了编译器35

2.3 Ruby如何编译简单脚本37

2.4 编译块调用41

2.5 本地表49

2.5.1 编译可选参数52

2.5.2 编译关键字参数53

2.6 总结57

3 Ruby如何执行代码59

3.1 YARV内部栈和Ruby调用栈60

3.1.1 逐句查看Ruby如何执行简单脚本62

3.1.2 执行块调用65

3.2 访问Ruby变量的两种方式72

3.2.1 本地变量访问72

3.2.2 方法参数被看成本地变量75

3.2.3 动态变量访问76

3.3 总结86

4 控制结构与方法调度89

4.1 Ruby如何执行if语句90

4.2 作用域之间的跳转93

4.2.1 捕获表94

4.2.2 捕获表的其他用途96

4.3 send指令：Ruby最复杂的控制结构99

4.3.1 方法查找和方法调度99

4.3.2 Ruby方法的11种类型100

4.4 调用普通Ruby方法102

4.4.1 为普通Ruby方法准备参数103

4.5 调用内建的Ruby方法104

4.5.1 调用attr_reader和attr_writer105

4.5.2 方法调度优化attr_reader和attr_writer106

4.6 总结110

5 对象与类113

5.1 Ruby对象内部114

5.1.1 检验klass和ivptr115

5.1.2 观察同一个类的两个实例117

5.1.3 基本类型对象118

5.1.4 简单立即值完全不需要结构体119

5.1.5 基本类型对象有实例变量吗120

5.1.6 基本类型对象的实例变量保存在哪里122

5.2 RClass结构体内部有什么125

5.2.1 继承128

5.2.2 类实例变量vs类变量129

5.2.3 存取类变量131

5.2.4 常量134

5.2.5 真实的RClass结构体135

5.3 总结140

6 方法查找和常量查找143

6.1 Ruby如何实现模块145

6.1.1 模块是类145

6.1.2 将模块include到类中147

6.2 Ruby的方法查找算法148

6.2.1 方法查找示例149

6.2.2 方法查找算法实践151

6.2.3 Ruby中的多继承152

6.2.4 全局方法缓存153

6.2.5 内联方法缓存154

6.2.6 清空Ruby的方法缓存155

6.2.7 在同一个类中include两个模块155

6.2.8 在模块中include模块157

6.2.9 Module＃prepend示例158

6.2.10 Ruby如何实现Module＃prepend161

6.2.11 在已被include的模块中增加方法164

6.2.12 在已被include的模块中include其他模块164

6.2.13 “被include的类”与原始模块共享方法表166

6.3 常量查找168

6.3.1 在超类中查找常量169

6.3.2 Ruby如何在父级命名空间中查找常量170

6.4 Ruby中的词法作用域171

6.4.1 为新类或模块创建常量172

6.4.2 在父命名空间中使用词法作用域查找常量173

6.4.3 Ruby的常量查找算法175

6.4.4 Ruby真实的常量查找算法177

6.5 总结178

7 散列表：Ruby内部的主力军181

7.1 Ruby中的散列表182

7.1.1 在散列表中保存值183

7.1.2 从散列表中检索值185

7.2 散列表如何扩展以容纳更多的值188

7.2.1 散列冲突188

7.2.2 重新散列条目189

7.3 Ruby如何实现散列函数195

7.3.1 Ruby 2.0中的散列优化202

7.4 总结203

8 Ruby如何借鉴Lisp几十年前的理念207

8.1 块：Ruby中的闭包208

8.1.1 Ruby如何调用块210

8.1.2 借用1975年的理念212

8.2 Lambda和Proc：把函数当做一等公民219

8.2.1 栈内存vs堆内存220

8.2.2 深入探索Ruby如何保存字符串的值220

8.2.3 Ruby如何创建Lambda223

8.2.4 Ruby如何调用Lambda226

8.2.5 Proc对象227

8.2.6 在同一个作用域中多次调用lambda232

8.3 总结234

9 元编程237

9.1 定义方法的多种方式239

9.1.1 Ruby的普通方法定义过程239

9.1.2 使用对象前缀定义类方法241

9.1.3 使用新的词法作用域定义类方法242

9.1.4 使用单类定义方法244

9.1.5 在单类的词法作用域中定义方法245

9.1.6 创建Refinement246

9.1.7 使用Refinement248

9.1.8 顶级作用域中的self250

9.1.9 类作用域中的self251

9.1.10 元类作用域中的self252

9.1.11 类方法中的self253

9.2 元编程与闭包：eval、instance_eval和binding255

9.2.1 能写代码的代码255

9.2.2 使用binding参数调用eval257

9.2.3 instance_eval示例259

9.2.4 Ruby闭包的另一个重点260

9.2.5 instance_eval改变接收者的self262

9.2.6 instance_eval为新的词法作用域创建单类262

9.2.7 使用define_method266

9.2.8 充当闭包的方法266

9.3 总结268

10 JRuby：基于JVM的Ruby271

10.1 使用MRI和JRuby运行程序272

10.1.1 JRuby如何解析和编译代码274

10.1.2 JRuby如何执行代码276

10.1.3 用Java类实现Ruby类278

10.1.4 使用-J-XX：＋PrintCompilation选项281

10.1.5 JIT是否提升了JRuby程序的性能283

10.2 JRuby和MRI中的字符串284

10.2.1 JRuby和MRI如何保存字符串数据284

10.2.2 写时复制286

10.2.3 创建唯一且非共享的字符串288

10.2.4 可视化写时复制290

10.2.5 修改共享字符串更慢291

10.3 总结293

11 Rubinius：用Ruby实现的Ruby295

11.1 Rubinius内核和虚拟机296

11.1.1 词法分析和解析298

11.1.2 使用Ruby编译Ruby299

11.1.3 Rubinius字节码指令300

11.1.4 Ruby和C＋＋一起工作302

11.1.5 使用C＋＋对象实现Ruby 对象303

11.1.6 Rubinius中的（栈）回溯305

11.2 Rubinius和MRI中的数组307

11.2.1 MRI中的数组307

11.2.2 Rubinius中的数组309

11.2.3 阅读Array＃shift源码311

11.2.4 修改Array＃shift方法312

11.3 总结315

12 MRI、JRuby、Rubinius垃圾回收317

12.1 垃圾回收器解决三个问题319

12.2 MRI中的垃圾回收：标记与清除320

12.2.1 空闲列表320

12.2.2 标记321

12.2.3 MRI如何标记存活对象323

12.2.4 清除323

12.2.5 延迟清除324

12.2.6 标记-清除的缺点325

12.2.7 观察MRI执行延迟清除327

12.2.8 观察MRI执行全回收328

12.2.9 解读GC分析报告329

12.3 JRuby和Rubinius中的垃圾回收332

12.4 复制垃圾回收333

12.4.1 碰撞分配333

12.4.2 半空间算法334

12.4.3 伊甸堆336

12.5 分代垃圾回收337

12.5.1 弱代假说337

12.5.2 为新生代使用半空间算法338

12.5.3 晋升对象338

12.5.4 成熟代对象垃圾回收339

12.6 并发垃圾回收341

12.6.1 当对象图改变时进行标记341

12.6.2 三色标记343

12.6.3 JVM中的三种垃圾收集器344

12.6.4 触发主收集347

12.7 延伸阅读348

12.8 总结349

索引351