内容简介

It's easy to write correct Ruby code, but to gain the fluency needed to write great Ruby code, you must go beyond syntax and absorb the "Ruby way" of thinking and problem solving. In Eloquent Ruby, Russ Olsen helps you write Ruby like true Rubyists do-so you can leverage its immense, surprising power. Olsen draws on years of experience internalizing the Ruby culture and teaching Ruby to other programmers. He guides you to the "Ah Ha!" moments when it suddenly becomes clear why Ruby works the way it does, and how you can take advantage of this language's elegance and expressiveness. Eloquent Ruby starts small, answering tactical questions focused on a single statement, method, test, or bug. You'll learn how to write code that actually looks like Ruby (not Java or C#); why Ruby has so many control structures; how to use strings, expressions, and symbols; and what dynamic typing is really good for. Next, the book addresses bigger questions related to building methods and classes. You'll discover why Ruby classes contain so many tiny methods, when to use operator overloading, and when to avoid it. Olsen explains how to write Ruby code that writes its own code-and why you'll want to. He concludes with powerful project-level features and techniques ranging from gems to Domain Specific Languages. A part of the renowned Addison-Wesley Professional Ruby Series, Eloquent Ruby will help you "put on your Ruby-colored glasses" and get results that make you a true believer.

作品目录

Contents

Foreword xix Preface xxi Acknowledgments xxv About the Author xxvii

PART I: The Basics 1

Chapter 1: Write Code That Looks Like Ruby 3

The Very Basic Basics 4 Go Easy on the Comments 6 Camels for Classes, Snakes Everywhere Else 8 Parentheses Are Optional but Are Occasionally Forbidden 9 Folding Up Those Lines 10 Folding Up Those Code Blocks 11 Staying Out of Trouble 12 In the Wild 13 Wrapping Up 15

Chapter 2: Choose the Right Control Structure 17

If, Unless, While, and Until 17 Use the Modifier Forms Where Appropriate 19 Use each, Not for 20 A Case of Programming Logic 21

ix

x Contents

Staying Out of Trouble 23 In the Wild 25 Wrapping Up 27

Chapter 3: Take Advantage of Ruby’s Smart Collections 29

Literal Shortcuts 29 Instant Arrays and Hashes from Method Calls 30 Running Through Your Collection 33 Beware the Bang! 36 Rely on the Order of Your Hashes 38 In the Wild 38 Staying Out of Trouble 40 Wrapping Up 42

Chapter 4: Take Advantage of Ruby’s Smart Strings 43

Coming Up with a String 44 Another API to Master 47 The String: A Place for Your Lines, Characters, and Bytes 49 In the Wild 50 Staying Out of Trouble 51 Wrapping Up 52

Chapter 5: Find the Right String with Regular Expressions 53

Matching One Character at a Time 54 Sets, Ranges, and Alternatives 55 The Regular Expression Star 57 Regular Expressions in Ruby 58 Beginnings and Endings 60

In the Wild 62 Staying Out of Trouble 63 Wrapping Up 64

Chapter 6: Use Symbols to Stand for Something 65

The Two Faces of Strings 65 Not Quite a String 66 Optimized to Stand for Something 67

Contents xi

In the Wild 69 Staying Out of Trouble 70 Wrapping Up 71

Chapter 7: Treat Everything Like an Object—Because Everything Is 73

A Quick Review of Classes, Instances, and Methods 74 Objects All the Way Down 76 The Importance of Being an Object 77 Public, Private, and Protected 79

In the Wild 81 Staying Out of Trouble 82 Wrapping Up 84

Chapter 8: Embrace Dynamic Typing 85

Shorter Programs, But Not the Way You Think 85 Extreme Decoupling 89 Required Ceremony Versus Programmer-Driven Clarity 92 Staying Out of Trouble 93

In the Wild 94 Wrapping Up 96

Chapter 9: Write Specs! 97

Test::Unit: When Your Documents Just Have to Work 98 A Plethora of Assertions 101 Don’t Test It, Spec It! 101 A Tidy Spec Is a Readable Spec 104

Easy Stubs 105 . . . And Easy Mocks 107 In the Wild 108 Staying Out of Trouble 110 Wrapping Up 113

PART II: Classes, Modules, and Blocks 115

Chapter 10: Construct Your Classes from Short, Focused Methods 117

Compressing Specifications 117 Composing Methods for Humans 121

xii Contents

Composing Ruby Methods 122 One Way Out? 123 Staying Out of Trouble 126 In the Wild 127

Wrapping Up 128

Chapter 11: Define Operators Respectfully 129

Defining Operators in Ruby 129 A Sampling of Operators 131 Operating Across Classes 134 Staying Out of Trouble 135

In the Wild 137 Wrapping Up 139

Chapter 12: Create Classes That Understand Equality 141

An Identifier for Your Documents 141 An Embarrassment of Equality 142 Double Equals for Everyday Use 143 Broadening the Appeal of the == Method 145 Well-Behaved Equality 146

Triple Equals for Case Statements 149 Hash Tables and the eql? Method 150 Building a Well-Behaved Hash Key 152 Staying Out of Trouble 153

In the Wild 154 Wrapping Up 156

Chapter 13: Get the Behavior You Need with Singleton and Class Methods 157

A Stubby Puzzle 158 A Hidden, but Real Class 160 Class Methods: Singletons in Plain Sight 162 In the Wild 164 Staying Out of Trouble 165 Wrapping Up 167

Contents xiii

Chapter 14: Use Class Instance Variables 169

A Quick Review of Class Variables 169 Wandering Variables 171 Getting Control of the Data in Your Class 174 Class Instance Variables and Subclasses 175 Adding Some Convenience to Your Class Instance Variables 176 In the Wild 177

Staying Out of Trouble 179 Wrapping Up 179

Chapter 15: Use Modules as Name Spaces 181

A Place for Your Stuff, with a Name 181 A Home for Those Utility Methods 184 Building Modules a Little at a Time 185 Treat Modules Like the Objects That They Are 186 Staying Out of Trouble 189

In the Wild 190 Wrapping Up 191

Chapter 16: Use Modules as Mixins 193

Better Books with Modules 193 Mixin Modules to the Rescue 195 Extending a Module 197 Staying Out of Trouble 198

In the Wild 202 Wrapping Up 205

Chapter 17: Use Blocks to Iterate

207

A Quick Review of Code Blocks One Word after Another 209 As Many Iterators as You Like 210 Iterating over the Ethereal 211 Enumerable: Your Iterator on Steroids 213 Staying Out of Trouble 215 In the Wild 217 Wrapping Up 218

207

xiv Contents

Chapter 18: Execute Around with a Block 219

Add a Little Logging 219 When It Absolutely Must Happen 224 Setting Up Objects with an Initialization Block 225 Dragging Your Scope along with the Block 225 Carrying the Answers Back 227 Staying Out of Trouble 228 In the Wild 229 Wrapping Up 231

Chapter 19: Save Blocks to Execute Later 233

Explicit Blocks 233 The Call Back Problem 234 Banking Blocks 236 Saving Code Blocks for Lazy Initialization 237 Instant Block Objects 239 Staying Out of Trouble 240 In the Wild 243 Wrapping Up 244

PART III: Metaprogramming 247

Chapter 20: Use Hooks to Keep Your Program Informed 249

Waking Up to a New Subclass 250

Modules Want To Be Heard Too Knowing When Your Time Is Up . . . And a Cast of Thousands 256 Staying Out of Trouble 257 In the Wild 259 Wrapping Up 261

253 255

Chapter 21: Use method_missing for Flexible Error Handling 263

Meeting Those Missing Methods 264 Handling Document Errors 266 Coping with Constants 267 In the Wild 268

Contents xv

Staying Out of Trouble 270 Wrapping Up 271

Chapter 22: Use method_missing for Delegation 273

The Promise and Pain of Delegation 274 The Trouble with Old-Fashioned Delegation 275 The method_missing Method to the Rescue 277 More Discriminating Delegation 278 Staying Out of Trouble 279 In the Wild 281 Wrapping Up 283

Chapter 23: Use method_missing to Build Flexible APIs 285

Building Form Letters One Word at a Time 286 Magic Methods from method_missing 287 It’s the Users That Count—All of Them 289 Staying Out of Trouble 289

In the Wild 290 Wrapping Up 292

Chapter 24: Update Existing Classes with Monkey Patching 293

Wide-Open Classes 294 Fixing a Broken Class 295 Improving Existing Classes 296 Renaming Methods with alias_method 297 Do Anything to Any Class, Anytime 299 In the Wild 299 Staying Out of Trouble 303 Wrapping Up 303

Chapter 25: Create Self-Modifying Classes 305

Open Classes, Again 305 Put Programming Logic in Your Classes 308 Class Methods That Change Their Class 309 In the Wild 310

xvi Contents

Staying Out of Trouble 314 Wrapping Up 315

Chapter 26: Create Classes That Modify Their Subclasses 317

A Document of Paragraphs 317 Subclassing Is (Sometimes) Hard to Do 319 Class Methods That Build Instance Methods 321 Better Method Creation with define_method 324 The Modification Sky Is the Limit 324 In the Wild 327 Staying Out of Trouble 330 Wrapping Up 332

PART IV: Pulling It All Together 333

Chapter 27: Invent Internal DSLs 335

Little Languages for Big Problems 335 Dealing with XML 336 Stepping Over the DSL Line 341 Pulling Out All the Stops 344

In the Wild 345 Staying Out of Trouble 347 Wrapping Up 349

Chapter 28: Build External DSLs for Flexible Syntax 351

The Trouble with the Ripper 352 Internal Is Not the Only DSL 353 Regular Expressions for Heavier Parsing 356 Treetop for Really Big Jobs 358 Staying Out of Trouble 360 In the Wild 362 Wrapping Up 364

Chapter 29: Package Your Programs as Gems 367

Consuming Gems 367 Gem Versions 368

Contents xvii

The Nuts and Bolts of Gems 369 Building a Gem 370 Uploading Your Gem to a Repository 374 Automating Gem Creation 375

In the Wild 376 Staying Out of Trouble 377 Wrapping Up 380

Chapter 30: Know Your Ruby Implementation 381

A Fistful of Rubies 381 MRI: An Enlightening Experience for the C Programmer 382 YARV: MRI with a Byte Code Turbocharger 385 JRuby: Bending the “J” in the JVM 387 Rubinius 388 In the Wild 389 Staying Out of Trouble 389 Wrapping Up 390

Chapter 31: Keep an Open Mind to Go with Those Open Classes 391 Appendix: Going Further 393

Index 397