深入理解Ruby元编程：英文第二版

需积分: 10 7 浏览量更新于2024-07-20 1 收藏 14.41MB PDF 举报

"ruby元编程第二版英文免费" 《Metaprogramming Ruby 2》是关于Ruby编程语言的一本深入解析元编程技术的书籍。这本书以其独特的视角揭示了Ruby语言工作原理的内在机制，使读者在阅读过程中不断地发出“原来如此”的感叹。元编程是指在程序运行时对程序自身的修改和控制，它让开发者能够以更灵活的方式编写代码，创建出高度定制化的解决方案。书中的核心主题涵盖了Ruby的对象模型、领域特定语言（DSLs）以及块（blocks）等关键概念。作者Paolo Perrotta通过易于理解的方式，解释了这些概念如何协同工作，帮助读者理解Ruby语言深层次的“魔法”。书中详细阐述了如何利用元编程技术提升代码的效率和灵活性，以及如何在现有代码库中更高效地工作。对于软件工程师，尤其是那些在GiltCity、Heroku和Hash工作的开发者们，这本书提供了一个坚实的框架，帮助他们掌握充分利用Ruby能力的基础。无论你是初学者还是经验丰富的程序员，都可以从中受益。例如，Peter Bakhirev提到这本书让他理解了Ruby的工作原理，而Richard Schneeman则表示，即使是在原有版本已经很出色的基础上，Perrotta仍然成功地提升了书籍的质量，使他重新爱上了Ruby。通过阅读《Metaprogramming Ruby 2》，读者可以学习到如何解锁Ruby语言隐藏的潜力，编写出更简洁、更高效的代码。Paul Elliott强调，这本书的知识将有助于开发者更好地处理遗留代码库，提高工作效率。无论是Forge的作者还是应用开发者，都能从这本书中找到提升自己编程技巧的宝贵资源。《Metaprogramming Ruby 2》是一本不容错过的Ruby元编程指南，它将带领读者深入了解这个美丽语言的内在奥秘，并激发他们在编程实践中实现创新和突破。尽管是英文版，但其内容深入浅出，适合所有技能水平的读者。免费获取这本书，意味着你有机会无需花费任何费用就能掌握这些宝贵的编程知识。

previous chapters. The chapter also rounds out your metaprogramming

training with two new topics: the somewhat controversial

eval

method and

the callback methods that you can use to intercept events in the object

model.

Part II of the book, Metaprogramming in Rails, is a case study in metaprogram-

ming. It contains short chapters that focus on different areas of Rails, the

flagship Ruby framework. By looking at Rails’ source code, you’ll see how

master Ruby coders use metaprogramming in the real world to develop great

software, and you’ll also understand how some metaprogramming techniques

evolved in the last few years.

Three appendixes close the book. Appendix 1, Common Idioms, on page 217,

is a grab-bag of common techniques that are not explained anywhere else in

the book. Appendix 2, Domain-Specific Languages, on page 227, is a quick look

at a programming approach that is common among Ruby developers. Appendix

3, Spell Book, on page 231, is a catalog of all the spells in the book, complete

with code examples.

“Wait a minute,” I can hear you saying. “What the heck are spells?” Oh, right,

sorry. Let me explain.

Spells

This book contains a number of metaprogramming techniques that you can

use in your own code. Some people might call these patterns or maybe idioms.

Neither of these terms is very popular among Rubyists, so I’ll call them spells

instead. Even if there’s nothing magical about them, they do look like magic

spells to Ruby newcomers.

You’ll find references to spells everywhere in the book. I reference a spell with

the convention Class Macro (117) or String of Code (141), for example. The

number in parentheses is the page where the spell receives a name. If you

need a quick reference to a spell, you’ll find it in Appendix 3, Spell Book, on

page 231.

Quizzes

Every now and then, this book also throws a quiz at you. You can skip these

quizzes and just read the solution, but you’ll probably want to solve them on

your own just because they’re fun.

Some quizzes are traditional coding exercises; others require you to get off

your keyboard and think. All include a solution, but most quizzes have more

than one possible answer. Please, feel free to go wild and experiment.

report erratum • discuss

About This Book • xix

Notation Conventions

This book is chock full of code examples. To show you that a line of code

results in a value, I print that value as a comment on the same line:

-1.abs # => 1

If a code example is supposed to print a result rather than return it, I show

that result after the code:

puts 'Testing... testing...'

Testing... testing...

❮

In most cases, the text uses the same code syntax that Ruby uses:

My-

Class.my_method

is a class method,

MyClass::MY_CONSTANT

is a constant defined

within a class, and so on. There are a couple of exceptions to this rule. First,

I identify instance methods with the hash notation, like the Ruby documen-

tation does (

MyClass#my_method

). This is useful to distinguish class methods

and instance methods. Second, I use a hash prefix to identify singleton

classes (

#MySingletonClass

Ruby has a flexible syntax, so few universal rules exist for things like inden-

tation and the use of parentheses. Programmers tend to adopt the syntax

that they find most readable in each specific case. In this book, I try to follow

the most common conventions. For example, I skip parentheses when I call

a method without parameters (as in

my_string.reverse

), but I tend to use paren-

theses when I pass parameters (as in

my_string.gsub("x", "y")

Some of the code in this book comes straight from existing open-source

libraries. Some of these are standard Ruby libraries, so you should already

have them. You can install the others with the

gem

command. For example,

if I show you a piece of code from Builder 3.2.2, and you want to install the

entire library to explore its source by yourself, then you can use

gem install

builder -v 3.2.2

. Be aware of the version, because the code might have changed

in more recent versions of Builder.

To avoid clutter (and make the code easier to understand in isolation), I’ll

sometimes take the liberty of editing the original code slightly. However, I’ll

do my best to keep the spirit of the original source intact.

Unit Tests

This book follows two developers as they go about their day-to-day work. As

the story unfolds, you may notice that these two characters rarely write tests.

Does this book condone untested code?

Introduction • xx

report erratum • discuss

Please rest assured that it doesn’t. In fact, the original draft of this book

included unit tests for all code examples. In the end, I found that those tests

distracted from the metaprogramming techniques that are the meat of the

book, so the tests fell on the cutting-room floor. This doesn’t mean you

shouldn’t write tests for your own metaprogramming endeavors.

On those occasions where I did show test code in this book, I used the

test-

unit

library. Until Ruby 2.1,

test-unit

was a standard library. From Ruby 2.2

onward, you need to install it as a gem, with the command

gem install test-unit

Ruby Versions

Ruby is continuously changing and improving. However, this very fluidity

can be problematic when you try a piece of code on the latest version of the

language, only to find that it doesn’t work anymore. This is not overly common,

but it can happen with metaprogramming, which pushes Ruby to its limits.

This book is written for Ruby 2. As I write, Ruby 2.1 is the most recent stable

version of the language, and it’s mostly compatible with Ruby 2.0. Some

people still run older versions of Ruby, which miss a few important features

from 2.x—notably, Refinements and

Module#prepend

. In the text, I’ll refer to

Ruby 2.x, and I’ll tell you which features were introduced either in Ruby 2.1

or in Ruby 2.0.

When I talk about Ruby versions, I’m talking about the “official” interpreter

(sometimes called MRI for Matz’s Ruby Interpreter

). There are many alternate

Ruby implementations. Two of the most popular ones are JRuby, which runs

on the Java Virtual Machine,

and Rubinius.

Alternate implementations

usually take a few versions to catch up with MRI — so if you use one of them,

be aware that some of the examples in this book might not yet work on your

interpreter.

Book Editions

The first edition of this book focused on Ruby 1.8, which has since been

deprecated. I updated the text to reflect the new features in Ruby, especially

the ones that have been introduced by Ruby 2.x.

The chapters in Part II use the Rails source code as a source of examples.

Rails has changed a lot since the first edition, so these chapters are almost

a complete rewrite of the first edition’s content.

http://www.ruby-lang.org

http://jruby.codehaus.org

http://rubini.us/

report erratum • discuss

About This Book • xxi

剩余261页未读，继续阅读

baisung

粉丝: 24
资源: 26

深入理解Ruby元编程：英文第二版

Ruby元编程第二版中文

ruby元编程.pdf

programming+ruby中文版第二版

深入探索：Ruby元编程第二版

深入理解Ruby元编程：第二版

深入理解Ruby元编程：第二版解析

精通Ruby编程：第二版

Ruby元编程深入解析：第二版（针对ruby2.1）

《The Ruby Way》第二版：Ruby编程入门与实践

《The Ruby Way》第二版：Ruby编程解惑与实践技巧

最新资源