没有合适的资源?快使用搜索试试~ 我知道了~
Programming Ruby The Pragmatic Programmer's Guide
需积分: 10 41 下载量 29 浏览量
2008-09-24
23:43:53
上传
评论
收藏 1.85MB PDF 举报
温馨提示
试读
554页
The Pickaxe book, named for the tool on the cover, is the definitive reference to Ruby, a highly-regarded, fully object-oriented programming language. This Second Edition has more than 200 pages of new content, and substantial enhancements to the original, covering all the new and improved language features of Ruby 1.8 and standard library modules.
资源推荐
资源详情
资源评论
1
Programming Ruby: A Pragmatic Programmer's Guide
by David Thomas, Andrew Hunt, Dave Thomas
2
Chapter 1 Roadmap........................................................................................................... 11
Chapter 2 Ruby.new.......................................................................................................... 13
Chapter 3 Classes, Objects, and Variables........................................................................ 24
Chapter 4 Containers, Blocks, and Iterators ..................................................................... 39
Chapter 5 Standard Types................................................................................................. 52
Chapter 6 More about methods......................................................................................... 70
Chapter 7 Expressions....................................................................................................... 76
Chapter 8 Exceptions, Catch, and Throw ......................................................................... 93
Chapter 9 Modules.......................................................................................................... 100
Chapter 10 Basic Input and Output................................................................................. 107
Chapter 11 Threads and Processes.................................................................................. 112
Chapter 12 When Trouble Strikes................................................................................... 123
Chapter 13 Ruby and Its World ...................................................................................... 131
Chapter 14 Ruby and the Web........................................................................................ 137
Chapter 15 Ruby Tk........................................................................................................ 145
Chapter 16 Ruby and Microsoft Windows ..................................................................... 155
Chapter 17 Extending Ruby............................................................................................ 159
Chapter 18 The Ruby Language ..................................................................................... 186
Chapter 19 Classes and Objects...................................................................................... 225
Chapter 20 Locking Ruby in the Safe............................................................................. 237
Chapter 21 Reflection, ObjectSpace, and Distributed Ruby........................................... 242
Chapter 22 Built-in Classes ............................................................................................ 255
Chapter 23 Built-in Modules .......................................................................................... 413
Chapter 24 Standard Library........................................................................................... 455
Chapter 25 Object-Oriented Design Libraries ................................................................ 486
Chapter 26 Network and Web Libraries ......................................................................... 492
Chapter 27 Microsoft Windows Support ........................................................................ 536
Appendix A Embedded Documentation ......................................................................... 541
Appendix B Interactive Ruby Shell ................................................................................ 545
Appendix C Support ....................................................................................................... 553
3
This book is a tutorial and reference for the Ruby programming language. Use Ruby, and you'll
write better code, be more productive, and enjoy programming more.
These are bold claims, but we think that after reading this book you'll agree with them. And
we have the experience to back up this belief.
As Pragmatic Programmers we've tried many, many languages in our search for tools to make
our lives easier, for tools to help us do our jobs better. Until now, though, we'd always been
frustrated by the languages we were using.
Our job is to solve problems, not spoonfeed compilers, so we like dynamic languages that
adapt to us, without arbitrary, rigid rules. We need clarity so we can communicate using our
code. We value conciseness and the ability to express a requirement in code accurately and
efficiently. The less code we write, the less that can go wrong. (And our wrists and fingers are
thankful, too.)
We want to be as productive as possible, so we want our code to run the first time; time spent
in the debugger is time stolen from the development clock. It also helps if we can try out code
as we edit it; if you have to wait for a 2-hour make cycle, you may as well be using punch
cards and submitting your work for batch compilation.
We want a language that works at a high level of abstraction. The higher level the language,
the less time we spend translating our requirements into code.
When we discovered Ruby, we realized that we'd found what we'd been looking for. More than
any other language with which we have worked, Ruby stays out of your way. You can
concentrate on solving the problem at hand, instead of struggling with compiler and language
issues. That's how it can help you become a better programmer: by giving you the chance to
spend your time creating solutions for your users, not for the compiler.
Ruby Sparkles
Take a true object-oriented language, such as Smalltalk. Drop the unfamiliar syntax and move
to more conventional, file-based source code. Now add in a good measure of the flexibility and
convenience of languages such as Python and Perl.
You end up with Ruby.
OO aficionados will find much to like in Ruby: things such as pure object orientation
(everything's an object), metaclasses, closures, iterators, and ubiquitous heterogeneous
collections. Smalltalk users will feel right at home (and C++ and Java users will feel jealous).
At the same time, Perl and Python wizards will find many of their favorite features: full regular
expression support, tight integration with the underlying operating system, convenient
shortcuts, and dynamic evaluation.
Ruby is easy to learn. Everyday tasks are simple to code, and once you've done them, they
are easy to maintain and grow. Apparently difficult things often turn out not to have been
difficult after all. Ruby follows the Principle of Least Surprise—things work the way you would
4
expect them to, with very few special cases or exceptions. And that really does make a
difference when you're programming.
We call Ruby a transparent language. By that we mean that Ruby doesn't obscure the
solutions you write behind lots of syntax and the need to churn out reams of support code just
to get simple things done. With Ruby you write programs close to the problem domain. Rather
than constantly mapping your ideas and designs down to the pedestrian level of most
languages, with Ruby you'll find you can express them directly and express them elegantly.
This means you code faster. It also means your programs stay readable and maintainable.
Using Ruby, we are constantly amazed at how much code we can write in one sitting, code
that works the first time. There are very few syntax errors, no type violations, and far fewer
bugs than usual. This makes sense: there's less to get wrong. No bothersome semicolons to
type mechanically at the end of each line. No troublesome type declarations to keep in sync
(especially in separate files). No unnecessary words just to keep the compiler happy. No error-
prone framework code.
So why learn Ruby? Because we think it will help you program better. It will help you to focus
on the problem at hand, with fewer distractions. It will make your life easier.
What Kind of Language Is Ruby?
In the old days, the distinction between languages was simple: they were either compiled, like
C or Fortran, or interpreted, like BASIC. Compiled languages gave you speed and low-level
access; interpreted languages were higher-level but slower.
Times change, and things aren't that simple anymore. Some language designers have taken to
calling their creations "scripting languages." By this, we guess they mean that their languages
are interpreted and can be used to replace batch files and shell scripts, orchestrating the
behavior of other programs and the underlying operating system. Perl, TCL, and Python have
all been called scripting languages.
What exactly is a scripting language? Frankly we don't know if it's a distinction worth making.
In Ruby, you can access all the underlying operating system features. You can do the same
stuff in Ruby that you can in Perl or Python, and you can do it more cleanly. But Ruby is
fundamentally different. It is a true programming language, too, with strong theoretical roots
and an elegant, lightweight syntax. You could hack together a mess of "scripts" with Ruby, but
you probably won't. Instead, you'll be more inclined to engineer a solution, to produce a
program that is easy to understand, simple to maintain, and a piece of cake to extend and
reuse in the future.
Although we have used Ruby for scripting jobs, most of the time we use it as a general-
purpose programming language. We've used it to write GUI applications and middle-tier server
processes, and we're using it to format large parts of this book. Others have used it for
managing server machines and databases. Ruby is serving Web pages, interfacing to
databases and generating dynamic content. People are writing artificial intelligence and
machine learning programs in Ruby, and at least one person is using it to investigate natural
evolution. Ruby's finding a home as a vehicle for exploratory mathematics. And people all over
the world are using it as a way of gluing together all their different applications. It truly is a
great language for producing solutions in a wide variety of problem domains.
5
Is Ruby for Me?
Ruby is not the universal panacea for programmers' problems. There will always be times
when you'll need a particular language: the environment may dictate it, you may have special
libraries you need, performance concerns, or simply an issue with training. We haven't given
up languages such as Java and C++ entirely (although there are times when we wish we
could).
However, Ruby is probably more applicable than you might think. It is easy to extend, both
from within the language and by linking in third-party libraries. It is portable across a number
of platforms. It's relatively lightweight and consumes only modest system resources. And it's
easy to learn; we've known people who've put Ruby code into production systems within a day
of picking up drafts of this book. We've used Ruby to implement parts of an X11 window
manager, a task that's normally considered severe C coding. Ruby excelled, and helped us
write code in hours that would otherwise have taken days.
Once you get comfortable with Ruby, we think you'll keep coming back to it as your language
of choice.
Why Did We Write This Book?
So we'd just finished writing The Pragmatic Programmer, our families had just started talking
to us again, and suddenly we felt the need to write another book. Why? We guess it comes
down to a kind of missionary zeal.
Ruby was created by Yukihiro Matsumoto (Matz) in Japan. Since 1995, its popularity in Japan
has grown at an astounding rate; there are rumors that Ruby is more popular than Python in
Japan. But to date, much of the detailed Ruby documentation is in Japanese. It probably isn't
a programming language you'd just stumble across.
We wanted to spread the word, to have more people outside Japan using Ruby and enjoying
the benefits, so we decided to document Ruby in English. And what started out as a small
project just sort of grew....
Ruby Versions
This book documents Version 1.6 of Ruby, which was released in September 2000.
Ruby version numbering follows the same scheme used for many other open source projects.
Releases with even subversion numbers (1.0, 1.2, 1.4, and so on) are stable, public releases.
These are the releases that are prepackaged and made available on the various Ruby Web
sites.
Development versions of the software have odd subversion numbers, such as 1.1 and 1.3.
These you'll have to download and build for yourself, as described in the box on page xxvii.
Installing Ruby
剩余553页未读,继续阅读
资源评论
dewpark
- 粉丝: 6
- 资源: 84
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功