深入探索Ruby编程语言

需积分: 9 5 浏览量更新于2024-07-18 收藏 4.81MB PDF 举报

"The Ruby Programming Language" "The Ruby Programming Language" 是一本深入介绍Ruby语言的书籍，旨在帮助读者全面理解和掌握这种动态、灵活的编程语言。Ruby由Yukihiro "Matz" Matsumoto创建，它强调简洁、清晰的语法以及代码的可读性，使得程序员能更高效地编写软件。 Ruby是一种面向对象的语言，其核心特性包括： 1. **面向对象**：Ruby将一切视为对象，允许开发者对基本数据类型进行方法调用，提供强大的类和模块系统，支持继承、封装和多态。 2. **动态性**：Ruby支持动态类型，类型在运行时自动确定，这使得代码更加灵活，但也可能导致一些运行时错误。 3. **块、迭代器和闭包**：Ruby中的块是代码片段，可以与方法一起使用，通过`do..end`或`{..}`定义。块可以转化为匿名函数（Proc对象）并作为参数传递，体现了闭包特性。 4. **元编程**：Ruby提供了丰富的元编程能力，允许在运行时修改或创建类和方法，这极大地增强了代码的灵活性和可扩展性。 5. **Gem生态系统**：Ruby拥有一个庞大的开源库集合——RubyGems，其中包含数千个预构建的工具和框架，如Ruby on Rails，用于快速开发Web应用。 6. **Ruby on Rails框架**：Ruby的一个重要应用领域是Web开发，Ruby on Rails（简称Rails）是一个基于MVC架构的Web应用框架，它遵循“约定优于配置”原则，大大简化了开发流程。 7. **错误处理和调试**：Ruby支持异常处理机制，通过`begin..rescue..end`来捕获和处理错误。同时，它提供了丰富的调试工具，如 pry 和 byebug，便于开发者进行交互式调试。 8. **性能**：虽然Ruby在处理大规模并发和计算密集型任务时可能不如其他静态类型的系统级语言（如C++或Java）快，但通过优化和使用如JRuby（Java平台上的Ruby实现）或TruffleRuby等高性能实现，性能可以得到提升。 9. **社区支持**：Ruby有一个活跃的开发者社区，他们共享代码、解决问题，并通过博客、论坛和会议（如RubyConf）进行交流。 10. **学习资源**：除了"The Ruby Programming Language"，还有其他相关书籍如"Ruby Cookbook"、"Learning Ruby"、"Advanced Rails"等，提供不同层次的学习材料。此外，O'Reilly Media和oreilly.com提供了丰富的在线资源，包括文章、示例章节和代码片段。通过深入阅读"The Ruby Programming Language"，读者将能够掌握Ruby的基本概念、语法和高级特性，从而成为一名熟练的Ruby程序员。对于希望从事Web开发或者寻求一种富有表达力和创新性的编程语言的人来说，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

www.allitebooks.com

剩余445页未读，继续阅读

kernelkoder

粉丝: 57
资源: 317

深入探索Ruby编程语言

The Ruby Programming Language 介绍

replace python

how to install chatgpt-3

有关面向对象思想的文献

dynamic type

python tfidf 余弦相似度的代码

java如何简化多个contains()

技术栈和编程语言的区别

编辑器和编程语言有什么区别

讲解一下面向对象的编程语言

最新资源