Ruby编程权威指南：1.8版与1.9版详解

需积分: 3 159 浏览量更新于2024-07-28 收藏 4.77MB PDF 举报

《Ruby编程语言》是一本权威的指南，专为Ruby语言的学习者和开发者设计。该书涵盖了Ruby 1.8版和1.9版的深入内容，旨在帮助读者全面理解和掌握这门动态、面向对象的脚本语言。无论你是初次接触Ruby的新手，还是希望深化理解现有知识的资深程序员，这本书都提供了丰富的教学资源和实用案例。书中不仅介绍了Ruby的基础语法、类与对象、模块、异常处理、以及元编程等核心概念，还深入探讨了Ruby的高级特性，如Ruby on Rails框架的使用，这对于Web开发人员来说尤其重要。《Ruby Cookbook》和《Learning Ruby》这两本书是进一步学习的补充，它们提供了丰富的实践经验和深入的理论知识。对于Ruby on Rails的开发者来说，《Advanced Rails》和《Rails Cookbook》则是不可或缺的参考资料，它们聚焦于Web应用程序开发的最佳实践和高级技术。此外，还有《Ruby Pocket Reference》供快速查阅，以及《Ajax on Rails》和《Ruby on Rails: Up and Running》这类实战教程，帮助读者迅速上手并精通该框架。除了纸质书籍，O'Reilly网站oreilly.com是一个综合资源库，包含了该系列的所有图书、新闻更新、活动信息、博客文章、章节样本和代码示例，为开发者提供了广阔的学习平台。对于追求新技术趋势的开发者，oreillynet.com则是一个开放技术社区，关注新兴平台、编程语言和操作系统。 O'Reilly & Associates举办的会议汇集了业界创新者，共同推动技术进步，而Safari Bookshelf（safari.oreilly.com）作为在线参考图书馆，为程序员和IT专业人员提供了超过1000本图书的搜索服务，能够即时解决实际工作中遇到的技术难题。《The Ruby Programming Language》是一本全方位的Ruby学习指南，结合了理论深度和实践应用，适合不同层次的读者，并通过O'Reilly的丰富资源为学习者提供了完整的支持体系。

Ruby is a dynamic programming language with a complex but expressive grammar and

a core class library with a rich and powerful API. Ruby draws inspiration from Lisp,

Smalltalk, and Perl, but uses a grammar that is easy for C and Java™ programmers to

learn. Ruby is a pure object-oriented language, but it is also suitable for procedural and

functional programming styles. It includes powerful metaprogramming capabilities

and can be used to create domain-specific languages or DSLs.

Matz on Ruby

Yukihiro Matsumoto, known as Matz to the English-speaking Ruby community, is the

creator of Ruby and the author of Ruby in a Nutshell (O’Reilly) (which has been updated

and expanded into the present book). He says:

I knew many languages before I created Ruby, but I was never fully satisfied with

them. They were uglier, tougher, more complex, or more simple than I expected. I

wanted to create my own language that satisfied me, as a programmer. I knew a lot

about the language’s target audience: myself. To my surprise, many programmers

all over the world feel very much like I do. They feel happy when they discover and

program in Ruby.

Throughout the development of the Ruby language, I've focused my energies on

making programming faster and easier. All features in Ruby, including object-

oriented features, are designed to work as ordinary programmers (e.g., me) expect

them to work. Most programmers feel it is elegant, easy to use, and a pleasure to

program.

Matz’s guiding philosophy for the design of Ruby is summarized in an oft-quoted

remark of his:

Ruby is designed to make programmers happy.

1.1 A Tour of Ruby

This section is a guided, but meandering, tour through some of the most interesting

features of Ruby. Everything discussed here will be documented in detail later in the

book, but this first look will give you the flavor of the language.

1.1.1 Ruby Is Object-Oriented

We’ll begin with the fact that Ruby is a completely object-oriented language. Every value

is an object, even simple numeric literals and the values

true, false, and nil (nil is a

special value that indicates the absence of value; it is Ruby’s version of null). Here we

invoke a method named class on these values. Comments begin with # in Ruby, and

the => arrows in the comments indicate the value returned by the commented code (this

is a convention used throughout this book):

1.class # => Fixnum: the number 1 is a Fixnum

0.0.class # => Float: floating-point numbers have class Float

2 | Chapter 1: Introduction

true.class # => TrueClass: true is a the singleton instance of TrueClass

false.class # => FalseClass

nil.class # => NilClass

In many languages, function and method invocations require parentheses, but there

are no parentheses in any of the code above. In Ruby, parentheses are usually optional

and they are commonly omitted, especially when the method being invoked takes no

arguments. The fact that the parentheses are omitted in the method invocations here

makes them look like references to named fields or named variables of the object. This

is intentional, but the fact is, Ruby is very strict about encapsulation of its objects; there

is no access to the internal state of an object from outside the object. Any such access

must be mediated by an accessor method, such as the class method shown above.

1.1.2 Blocks and Iterators

The fact that we can invoke methods on integers isn’t just an esoteric aspect of Ruby.

It is actually something that Ruby programmers do with some frequency:

3.times { print "Ruby! " } # Prints "Ruby! Ruby! Ruby! "

1.upto(9) {|x| print x } # Prints "123456789"

times and upto are methods implemented by integer objects. They are a special kind of

method known as an iterator, and they behave like loops. The code within curly braces

—known as a block—is associated with the method invocation and serves as the body

of the loop. The use of iterators and blocks is another notable feature of Ruby; although

the language does support an ordinary while loop, it is more common to perform loops

with constructs that are actually method calls.

Integers are not the only values that have iterator methods. Arrays (and similar “enu-

merable” objects) define an iterator named

each, which invokes the associated block

once for each element in the array. Each invocation of the block is passed a single

element from the array:

a = [3, 2, 1] # This is an array literal

a[3] = a[2] - 1 # Use square brackets to query and set array elements

a.each do |elt| # each is an iterator. The block has a parameter elt

print elt+1 # Prints "4321"

end # This block was delimited with do/end instead of {}

Various other useful iterators are defined on top of each:

a = [1,2,3,4] # Start with an array

b = a.map {|x| x*x } # Square elements: b is [1,4,9,16]

c = a.select {|x| x%2==0 } # Select even elements: c is [2,4]

a.inject do |sum,x| # Compute the sum of the elements => 10

sum + x

end

Hashes, like arrays, are a fundamental data structure in Ruby. As their name implies,

they are based on the hashtable data structure and serve to map arbitrary key objects

to value objects. (To put this another way, we can say that a hash associates arbitrary

1.1 A Tour of Ruby | 3

value objects with key objects.) Hashes use square brackets, like arrays do, to query

and set values in the hash. Instead of using an integer index, they expect key objects

within the square brackets. Like the Array class, the Hash class also defines an each

iterator method. This method invokes the associated block of code once for each key/

value pair in the hash, and (this is where it differs from Array) passes both the key and

the value as parameters to the block:

h = { # A hash that maps number names to digits

:one => 1, # The "arrows" show mappings: key=>value

:two => 2 # The colons indicate Symbol literals

}

h[:one] # => 1. Access a value by key

h[:three] = 3 # Add a new key/value pair to the hash

h.each do |key,value| # Iterate through the key/value pairs

print "#{value}:#{key}; " # Note variables substituted into string

end # Prints "1:one; 2:two; 3:three; "

Ruby’s hashes can use any object as a key, but Symbol objects are the most commonly

used. Symbols are immutable, interned strings. They can be compared by identity

rather than by textual content (because two distinct Symbol objects will never have the

same content).

The ability to associate a block of code with a method invocation is a fundamental and

very powerful feature of Ruby. Although its most obvious use is for loop-like constructs,

it is also useful for methods that only invoke the block once. For example:

File.open("data.txt") do |f| # Open named file and pass stream to block

line = f.readline # Use the stream to read from the file

end # Stream automatically closed at block end

t = Thread.new do # Run this block in a new thread

File.read("data.txt") # Read a file in the background

end # File contents available as thread value

As an aside, notice that the Hash.each example previously included this interesting line

of code:

print "#{value}:#{key}; " # Note variables substituted into string

Double-quoted strings can include arbitrary Ruby expressions delimited by #{ and }.

The value of the expression within these delimiters is converted to a string (by calling

its to_s method, which is supported by all objects). The resulting string is then used to

replace the expression text and its delimiters in the string literal. This substitution of

expression values into strings is usually called string interpolation.

1.1.3 Expressions and Operators in Ruby

Ruby’s syntax is expression-oriented. Control structures such as if that would be called

statements in other languages are actually expressions in Ruby. They have values like

other simpler expressions do, and we can write code like this:

minimum = if x < y then x else y end

4 | Chapter 1: Introduction

Although all “statements” in Ruby are actually expressions, they do not all return

meaningful values. while loops and method definitions, for example, are expressions

that normally return the value nil.

As in most languages, expressions in Ruby are usually built out of values and operators.

For the most part, Ruby’s operators will be familiar to anyone who knows C, Java,

JavaScript, or any similar programming language. Here are examples of some

commonplace and some more unusual Ruby operators:

1 + 2 # => 3: addition

1 * 2 # => 2: multiplication

1 + 2 == 3 # => true: == tests equality

2 ** 1024 # 2 to the power 1024: Ruby has arbitrary size ints

"Ruby" + " rocks!" # => "Ruby rocks!": string concatenation

"Ruby! " * 3 # => "Ruby! Ruby! Ruby! ": string repetition

"%d %s" % [3, "rubies"] # => "3 Rubies": Python-style, printf formatting

max = x > y ? x : y # The conditional operator

Many of Ruby’s operators are implemented as methods, and classes can define (or

redefine) these methods however they want. (They can’t define completely new oper-

ators, however; there is only a fixed set of recognized operators.) As examples, notice

that the + and * operators behave differently for integers and strings. And you can define

these operators any way you want in your own classes. The << operator is another good

example. The integer classes Fixnum and Bignum use this operator for the bitwise left-

shift operation, following the C programming language. At the same time (following

C++), other classes—such as strings, arrays, and streams—use this operator for an

append operation. If you create a new class that can have values appended to it in some

way, it is a very good idea to define

<<.

One of the most powerful operators to override is

[]. The Array and Hash classes use

this operator to access array elements by index and hash values by key. But you can

define [] in your classes for any purpose you want. You can even define it as a method

that expects multiple arguments, comma-separated between the square brackets. (The

Array class accepts an index and a length between the square brackets to indicate a

subarray or “slice” of the array.) And if you want to allow square brackets to be used

on the lefthand side of an assignment expression, you can define the corresponding

[]= operator. The value on the righthand side of the assignment will be passed as the

final argument to the method that implements this operator.

1.1.4 Methods

Methods are defined with the def keyword. The return value of a method is the value

of the last expression evaluated in its body:

def square(x) # Define a method named square with one parameter x

x*x # Return x squared

end # End of the method

1.1 A Tour of Ruby | 5

When a method, like the one above, is defined outside of a class or a module, it is

effectively a global function rather than a method to be invoked on an object. (Tech-

nically, however, a method like this becomes a private method of the Object class.)

Methods can also be defined on individual objects by prefixing the name of the method

with the object on which it is defined. Methods like these are known as singleton

methods, and they are how Ruby defines class methods:

def Math.square(x) # Define a class method of the Math module

x*x

end

The Math module is part of the core Ruby library, and this code adds a new method to

it. This is a key feature of Ruby—classes and modules are “open” and can be modified

and extended at runtime.

Method parameters may have default values specified, and methods may accept

arbitrary numbers of arguments.

1.1.5 Assignment

The (nonoverridable) = operator in Ruby assigns a value to a variable:

x = 1

Assignment can be combined with other operators such as + and -:

x += 1 # Increment x: note Ruby does not have ++.

y -= 1 # Decrement y: no -- operator, either.

Ruby supports parallel assignment, allowing more than one value and more than one

variable in assignment expressions:

x, y = 1, 2 # Same as x = 1; y = 2

a, b = b, a # Swap the value of two variables

x,y,z = [1,2,3] # Array elements automatically assigned to variables

Methods in Ruby are allowed to return more than one value, and parallel assignment

is helpful in conjunction with such methods. For example:

# Define a method to convert Cartesian (x,y) coordinates to Polar

def polar(x,y)

theta = Math.atan2(y,x) # Compute the angle

r = Math.hypot(x,y) # Compute the distance

[r, theta] # The last expression is the return value

end

# Here's how we use this method with parallel assignment

distance, angle = polar(2,2)

Methods that end with an equals sign (=) are special because Ruby allows them to be

invoked using assignment syntax. If an object o has a method named x=, then the

following two lines of code do the very same thing:

6 | Chapter 1: Introduction

剩余445页未读，继续阅读

MartinHong

粉丝: 0
资源: 2

Ruby编程权威指南：1.8版与1.9版详解

The Ruby Programming Language

The Ruby Programming Language 介绍

The Ruby Programming Language PDF

The Ruby Programming Language 2008 .pdf

The Ruby Programming Language (part 2)

The Ruby Programming Language (part 1)

下载英文版：The Ruby Programming Language PDF

The Perl Programming Language

The boo programming language

the_ruby_programming_language原版

最新资源