深入探索Ruby编程语言

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

"Ruby程序设计语言" Ruby是一种高级、面向对象的编程语言，由Yukihiro "Matz" Matsumoto在1990年代末创建。它以其简洁、优雅和可读性强的语法而闻名，同时强调程序员的生产力和乐趣。《The Ruby Programming Language》是由David Flanagan和Yukihiro Matsumoto合著的一本书，由O'Reilly在2008年出版，是学习和深入理解Ruby语言的重要资源。这本书详细介绍了Ruby的核心特性，包括： 1. **变量和数据类型**：Ruby支持多种数据类型，如整数、浮点数、字符串、布尔值、符号以及数组和哈希等复合类型。 2. **控制结构**：书中涵盖了条件语句（如if、unless）、循环（如while、for、each）以及流程控制工具（如break、next）。 3. **函数和方法**：Ruby允许定义函数和方法，支持块（block）和 Proc 对象，以及闭包和lambda表达式。 4. **类和对象**：Ruby是完全面向对象的语言，一切皆为对象，每个对象都属于一个类。书中详细讲解了类的定义、继承、模块（module）用于实现多重继承，以及访问控制（public、private、protected）。 5. **动态性**：Ruby支持动态类型和运行时元编程，可以修改类的行为，甚至在运行时创建新类。 6. **异常处理**：书中会介绍如何使用begin-rescue-end来捕获和处理程序中的错误。 7. **正则表达式**：Ruby内置强大的正则表达式引擎，用于文本匹配和操作。 8. **文件和I/O**：涵盖与文件系统交互、读写文件和标准输入/输出流的操作。 9. **线程和并发**：Ruby支持多线程编程，尽管在某些版本中可能存在全局解释器锁（GIL）限制。 10. **Gem和包管理**：Ruby使用Gem来管理和分发库，方便开发者复用和分享代码。 11. **Rails框架**：虽然《The Ruby Programming Language》不专门讲述Ruby on Rails，但书中内容对于理解这个流行的Web开发框架的基础至关重要。 O'Reilly Media是知名的科技图书出版商，除了《The Ruby Programming Language》，还提供了其他相关的Ruby书籍，如《Ruby Cookbook》、《Learning Ruby》、《Advanced Rails》和《Rails Cookbook》等，这些书籍覆盖了从入门到进阶的各个方面，帮助读者逐步提升Ruby编程技能。此外，O'Reilly的网站oreilly.com提供了新闻、事件、文章、博客、样本章节和代码示例，是开发者获取最新技术和资源的平台。O'Reilly还组织技术会议，聚集创新者交流思想，促进行业发展。Safari Bookshelf在线参考图书馆则为程序员和IT专业人士提供了一站式搜索和阅读上千本图书的服务，快速解答技术问题。

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页未读，继续阅读

elmar

粉丝: 1
资源: 1

深入探索Ruby编程语言

权威指南：Ruby编程语言深度解析（1.8 & 1.9）

Ruby基础教程：中文版全面指南

Ruby编程语言入门教程(中文版)

Ruby程序设计语言 (涵盖Ruby 1.8和1.9)源代码

Ruby程序设计

ruby程序设计

Ruby程序设计.rar

Ruby程序设计.doc

Ruby程序设计资料大全

Ruby教程.chm和Ruby程序设计.doc

最新资源