探索2008年经典：Ruby编程语言指南

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

《The Ruby Programming Language》是一本于2008年出版的IT技术书籍，专注于介绍Ruby编程语言。Ruby作为一种动态、面向对象的脚本语言，以其简洁的语法和高度可读性著称，尤其在Web开发领域，特别是与Ruby on Rails框架结合时表现出色。该书可能是初学者入门Ruby的宝贵资源，同时也适合有一定经验的开发者深入理解语言特性和最佳实践。书中可能会涵盖以下知识点： 1. **Ruby基础**：包括Ruby的语法结构、数据类型（如字符串、数组、哈希等）、类和对象、模块、继承与多态等核心概念。 2. **元编程**：Ruby的元编程能力允许开发者操作代码本身，这是其灵活性的一个重要体现。 3. **Ruby on Rails介绍**：Ruby与Rails的集成，如何利用Ruby进行Web开发，MVC架构、路由、控制器、视图以及模型-视图-控制器模式的详细解释。 4. **面向对象编程**：Ruby支持鸭子类型（duck typing），以及如何创建和管理类和对象的方法。 5. **工具与库**：书里可能会提到其他相关的资源，如Ruby Cookbook，它提供了实用的代码片段和解决问题的方法；Learning Ruby则可能详述从入门到精通的学习路径。 6. **进阶主题**：例如Advanced Rails，可能涉及更复杂的Web应用程序开发技巧，如数据库设计、性能优化、测试策略等。 7. **在线资源**：O'Reilly官网oreilly.com不仅提供书籍购买，还有新闻、活动、文章、博客、示例章节和代码示例等丰富的学习资料。oreillynet.com则是开发者关注新技术的平台，如开源平台、编程语言和操作系统更新。 8. **社区与会议**：O'Reilly & Associates组织的会议，汇集了创新者的思想，为Ruby开发者提供了交流和学习新技术的平台。Safari Bookshelf作为在线参考库，订阅者可以迅速找到答案，解决开发中的问题。《The Ruby Programming Language》是一本综合性的资源，旨在帮助读者全面理解和掌握Ruby语言，无论是初学者还是高级开发者都能从中受益。通过阅读这本书，读者将能深入了解Ruby语言的核心理念、应用场景，以及如何利用Ruby生态系统中的各种工具和技术进行高效开发。

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

薛定谔之死猫

粉丝: 724
资源: 66

探索2008年经典：Ruby编程语言指南

下载英文版：The Ruby Programming Language PDF

深入探索Ruby编程语言

The Ruby Programming Language PDF

The Ruby Programming Language 介绍

The Ruby Programming Language 2008 .pdf

The Ruby Programming Language (part 1)

The Ruby Programming Language (part 2)

The Perl Programming Language

The boo programming language

the_ruby_programming_language原版

最新资源