# Ruby 中的对象

> 原文： [https://zetcode.com/lang/rubytutorial/objects/](https://zetcode.com/lang/rubytutorial/objects/)

在 Ruby 教程的这一部分中，我们将简要介绍 Ruby 语言中对象的概念。 我们将在 OOP 一章中了解有关对象的更多信息。 我写了有关对象的本章，因为许多 Ruby 功能可能会使新手感到困惑，特别是如果他们已经知道任何其他编程语言的话。

Ruby 是一种面向对象的编程语言。 这意味着在 Ruby 程序中，我们使用对象。 从语言程序员的角度来看，Ruby 程序是令牌流。 这些标记是 Ruby 关键字，运算符，各种分隔符或字面值。 从语义的角度来看，Ruby 程序由对象组成。 这些对象是在 Ruby 脚本的生存期内创建和修改的。

有两种对象：内置对象和自定义对象。 内置对象是所有程序员都可以使用的预定义对象。 它们以 Ruby 语言的核心或各种库提供。 定制对象是由应用程序员为其应用域创建的。

必须先创建所有对象，然后才能使用它们。 我们经常使用术语对象实例化。 它是对象创建的同义词。 对象由数据和方法组成。 数据是对象的静态部分。 方法构成对象的动态部分。 对象被修改并通过方法彼此通信。

```ruby
#!/usr/bin/ruby

puts "Ruby language"

```

我们有一个简单的 Ruby 脚本。 如果我们熟悉某些程序语言（例如 Pascal 或 C），我们可能会看到一个名为`puts`的关键字或函数及其参数“`Ruby language`”（它是一个字符串）。

Ruby 是一种纯粹的面向对象的语言，情况有所不同。 “Ruby 语言”确实是一个字符串，它是一种常见的数据类型。 但这也是一个对象。 与所有对象一样，我们可以调用其方法。 这与其他语言有点不同。 `puts`是一种方法。 方法是在对象中定义的功能。 方法本身并不存在。 实际上，`puts`方法是`Kernel`模块的一部分。

```ruby
#!/usr/bin/ruby

Kernel.puts "Ruby language"
Kernel.puts "Ruby language".size

```

在上面的脚本中，我们有两个代码行。

```ruby
Kernel.puts "Ruby language"

```

在第一个示例中，我们调用的`puts`方法没有`Kernel`部分，可以将其省略。 这样可以节省时间和一些打字。 实际上，这是`Kernel.puts`正式电话的简写。 在 C# 中，我们有`Console.writeln`在 Java 中`System.println`。 想法是一样的。 方法必须与某个对象关联，或者，如果是类方法，则必须与一个类关联。

```ruby
Kernel.puts "Ruby language".size

```

在此代码行中，我们将“Ruby 语言”字符串的大小打印到控制台。 这可能会使使用其他语言编写代码的程序员感到困惑。 在其他语言中，字符串是无法修改的原始数据类型，并且缺少其自己的方法。 在 Ruby 中，字符串是完整对象，并且具有自己的方法。 `size`方法就是其中一种。 它以字符为单位返回字符串的大小。

```ruby
$ ./simple2.rb
Ruby language
13

```

代码示例的输出。

在下面的示例中，我们将看一个整数。 与字符串类似，整数值也是 Ruby 对象。

```ruby
#!/usr/bin/ruby

puts 6.object_id

puts 6.even?
puts 6.zero?

puts 6.class

```

在示例中，我们有一个整数 6。我们在数字上调用了一些方法。

```ruby
puts 6.object_id

```

6 是一个对象。 `object_id`是一种方法。 该方法返回与该对象关联的 ID。 每个对象都有一个 ID。 如果我们在对象上调用方法，则必须始终在两者之间放置点字符。

```ruby
puts 6.even?
puts 6.zero?

```

在这里，我们在 6 个对象上调用两个方法。 如果数字为偶数，则`even?`返回`true`。 如果数字等于零，则`zero?`方法返回`true`。 请注意，这两种方法都以问号结尾。 这是 Ruby 约定。 返回布尔值的方法以问号结尾。

```ruby
puts 6.class

```

`class`方法告诉我们正在处理哪种对象。 在我们的例子中 6 是`Fixnum`

```ruby
$ ./objectnumber.rb
13
true
false
Fixnum

```

代码示例输出。

## Ruby 对象创建

我们已经提到必须先创建 Ruby 对象，然后才能使用它们。 可以隐式或显式创建对象。 隐式对象创建是通过字面值符号创建对象。 显式对象的创建通过使用`new`关键字进行。 始终使用`new`关键字创建自定义对象。 必须从特定的类创建自定义对象。 类是对象的模板。 一个类可以用来创建许多对象。

```ruby
#!/usr/bin/ruby

class Being
end

puts 67
puts "ZetCode"

s = String.new "ZetCode"
puts s

# n1 = Fixnum.new 67
# puts n1

b = Being.new
puts b

```

该代码示例演示了如何在 Ruby 中创建对象。

```ruby
class Being
end

```

这是名为`Being`的自定义对象的模板。 使用`class`关键字创建模板。 自定义对象的模板通常放在源文件的顶部或单独的 Ruby 文件中。

```ruby
puts 67
puts "ZetCode"

```

在这两行中，我们使用两个对象。 `Fixnum`类型的 67 对象和`String`类型的“`ZetCode`”字符串。 67 和“`ZetCode`”是我们所谓的字面值。 字面值是类型的特定值的字面值表示。 这两个对象是由 Ruby 解释器在后台创建的。 Ruby 中的某些对象是通过在源代码中指定其字面值来创建的。

```ruby
s = String.new "ZetCode"
puts s

```

这是创建`String`对象的正式方法。 它等于之前使用字符串字面值的隐式创建。

```ruby
# n1 = Fixnum.new 67
# puts n1

```

并非所有内置对象都可以使用`new`方法创建。 此代码无法编译。 到目前为止，`Fixnum`数字只能用字面值表示法创建。

```ruby
b = Being.new
puts b

```

在这里，我们创建了自定义对象的实例。 `puts`方法为我们简要介绍了该对象。

```ruby
$ ./ocreation.rb
67
ZetCode
ZetCode
#<Being:0x9944d9c>

```

示例的输出。

我们将继续进行一些正式的对象创建。

```ruby
#!/usr/bin/ruby

s1 = String.new "Ruby"
puts s1.size
puts s1.downcase

a1 = Array.new 
a1.push 1, 2, 3
puts a1.include? 3
puts a1.empty?

r1 = Range.new 1, 6
puts r1.class
puts r1.include? 4

```

在示例中，我们创建了三个内置对象并调用了其中的一些方法。

```ruby
s1 = String.new "Ruby"
puts s1.size
puts s1.downcase

```

创建一个`String`对象。 我们调用对象的两种方法。 `size`方法返回字符串的大小。 `downcase`方法将字符串的字符小写。

```ruby
a1 = Array.new 
a1.push 1, 2, 3
puts a1.include? 3
puts a1.empty?

```

在这里，我们创建一个`Array`对象，并向其添加三个数字。 稍后我们调用两个数组方法。 `include?`方法检查特定值（在我们的例子中为 3）是否是数组的一部分。 `empty?`方法返回一个布尔值，指示该数组是否为空。

```ruby
r1 = Range.new 1, 6
puts r1.class
puts r1.include? 4

```

创建`Range`类的实例。 它包含从 1 到 6 的数字。`class`方法返回对象的名称。 `include?`方法检查数字 4 是否在范围内。 就我们而言。

```ruby
$ ./formal.rb
4
ruby
true
false
Range
true

```

运行示例将给出此输出。

## Ruby 对象字面值

正如我们已经提到的，可以使用对象字面值来创建一些内置对象。 以下示例显示了几个对象字面值。

```ruby
#!/usr/bin/ruby

4.times { puts "Ruby" }

puts "Ruby".size
puts "Ruby".downcase

puts [1, 2, 3].include? 3
puts [1, 2, 3].empty?

puts :name.class
puts :name.frozen?

puts (1..6).class
puts (1..6).include? 4

```

在上面的示例中，我们使用字面值符号创建一个`Fixnum`，字符串，数组，符号和范围。

```ruby
4.times { puts "Ruby" }

```

我们可以立即在整数字面值上调用方法。 该行向终端打印四次“ Ruby”字符串。

```ruby
puts "Ruby".size
puts "Ruby".downcase

```

我们在用字符串字面值创建的`String`对象上调用两个方法。

```ruby
puts [1, 2, 3].include? 3
puts [1, 2, 3].empty?

```

在这里，我们使用数组字面值符号创建两个`Array`对象。 我们使用`include?`方法检查特定的数字是否是数组的一部分。 `empty?`方法检查数组对象是否为空。

```ruby
puts :name.class
puts :name.frozen?

```

调用 Symbol 对象的两种方法。 该符号是用一个以冒号开头的符号字面值创建的。

```ruby
puts (1..6).class
puts (1..6).include? 4

```

使用范围字面值创建两个`Range`对象。 我们在那些对象上调用两个方法。 `class`方法返回类的名称，`include?`方法检查给定数字是否在范围内。

```ruby
$ ./literals.rb
Ruby
Ruby
Ruby
Ruby
4
ruby
true
false
Symbol
false
Range
true

```

示例输出。

## Ruby 对象层次结构

在许多面向对象的语言中，对象形成层次结构。 Ruby 也具有对象层次结构。 它是一个树状的层次结构，其中有父对象和子对象。 对象从其父对象继承数据和行为。 在层次结构的顶部，有根对象。 它称为`Object`。 Ruby 中的每个对象都有至少一个父对象。 换句话说，每个对象都继承自基本的`Object`对象。

根据 Ruby 的官方文档，`Object`是 Ruby 类层次结构的根。 除非明确重写，否则它的方法可用于所有类。

```ruby
#!/usr/bin/ruby

puts 4.is_a? Object
puts "Ruby".is_a? Object
puts [2, 3].is_a? Object
puts :name.is_a? Object
puts (1..2).is_a? Object

```

在上面的代码示例中，我们演示了所有对象均从根`Object`继承

```ruby
puts 4.is_a? Object

```

我们使用`is_a?`方法检查数字是否为特定类型：换句话说，数字是否继承自给定的对象类型。

```ruby
$ ./mother.rb 
true
true
true
true
true

```

所有方法均返回`true`，这意味着所有对象均从母对象继承。

即使对于非常基本的 Ruby 对象，继承层次结构也可能非常复杂。

```ruby
#!/usr/bin/ruby

puts 6.class

puts 6.is_a? BasicObject
puts 6.is_a? Object
puts 6.is_a? Numeric
puts 6.is_a? Integer
puts 6.is_a? Fixnum

puts 6.is_a? Bignum
puts 6.is_a? String

```

在此示例中，我们对较小数值的继承层次结构有所了解。

```ruby
puts 6.class

```

我们找出数字值为 6 的对象是什么。该行将`Fixnum`打印到控制台。

```ruby
puts 6.is_a? BasicObject
puts 6.is_a? Object
puts 6.is_a? Numeric
puts 6.is_a? Integer
puts 6.is_a? Fixnum

```

以上所有行均返回`true`。 数字 6 是`Fixnum`。 从 Ruby 文档中，我们发现其他四个对象是`Fixnum`对象的父对象。

```ruby
puts 6.is_a? Bignum
puts 6.is_a? String

```

以上两个对象不是 6 值的父对象。

```ruby
$ ./inheritance.rb
Fixnum
true
true
true
true
true
false
false

```

示例的输出。

我们将以一个示例结束本节，该示例演示自定义用户对象的继承。

```ruby
#!/usr/bin/ruby

class Being

    def to_s
        "This is Being"
    end

    def get_id
        9
    end
end

class Living < Being

    def to_s
        "This is Living"
    end
end

l = Living.new

puts l
puts l.get_id
puts l.is_a? Being
puts l.is_a? Object
puts l.is_a? BasicObject

```

在示例中，我们创建两个对象`Being`和`Living`。 `Living`对象继承自`Being`。 第一个是父对象，第二个是子对象。

```ruby
class Being

    def to_s
        "This is Being"
    end

    def get_id
        9
    end
end

```

这是自定义 Ruby 对象的定义。 定义位于`class`和`end`关键字之间。 在定义内部，我们创建两个方法。 当`puts`方法将对象作为参数时，它将调用其`to_s`方法。 它通常给出对象的字符串表示/描述。

```ruby
class Living < Being

    def to_s
        "This is Living"
    end
end

```

我们创建`Living`对象的定义。 该对象继承自`Being`对象。 `<`运算符用于创建继承关系。 `to_s`方法被覆盖。

```ruby
l = Living.new

```

从上面的`Living`对象模板，我们创建`Living`对象的实例。 使用`new`关键字创建自定义对象的实例。

```ruby
puts l

```

`puts`方法调用`Living`对象的`to_s`方法。 如果`Living`类中未定义`to_s`方法，则将调用`Being`类中的`to_s`方法。

```ruby
puts l.get_id

```

`Living`对象未定义`get_id`方法。 在这种情况下，将检查父类是否存在这种方法。 在我们的情况下，`Being`方法具有这种方法，因此被称为。

```ruby
puts l.is_a? Being

```

该行返回`true`。 `Living`是`Being`的一种； 例如它继承自`Being`类。

```ruby
puts l.is_a? Object
puts l.is_a? BasicObject

```

对于我们的`Living`自定义对象，我们没有明确指定与`Object`或`BasicObject`对象的任何关系。 但是这两行返回`true`。 这是因为 Ruby 中的每个对象自动都是这两个对象的后代。 这是由 Ruby 解释器在后台完成的。

```ruby
$ ./custominher.rb
This is Living
9
true
true
true

```

Output of the example.

## Ruby 顶级

Ruby 有一个特定的对象，称为 Ruby 顶级。 这是在任何其他上下文（例如类或模块定义）之外定义的默认执行环境。 顶级名称为`main`。 它是`Object`类型的实例。 有一个与`main`关联的局部空间，所有局部变量都驻留在该空间中。

```ruby
#!/usr/bin/ruby

n1 = 3
n2 = 5

puts local_variables

Kernel.puts self
puts self.class

```

这是描述 Ruby 顶层的第一个示例。

```ruby
n1 = 3
n2 = 5

```

在这里，我们定义了两个数值变量。 这些变量是本地变量。

```ruby
puts local_variables

```

在这里，我们列出了所有局部变量。 `local_variables`是`Kernel`模块的一种方法，已混入每个`Object`（包括顶层对象）中。

```ruby
Kernel.puts self

```

`self`是 Ruby 伪变量。 它返回当前的对象接收者。 该行将“`main`”打印到控制台。 它是 Ruby 顶层的名称。 `Kernel.puts`代码的`Kernel`部分可以省略。 通过完全指定名称，我们显示`puts`方法属于`Kernel`模块。

```ruby
puts self.class

```

该行显示顶层的`class`。 我们得到顶层的对象类型。 它是`Object`，它是 Ruby 类层次结构的根。

```ruby
$ ./toplevel.rb
n1
n2
main
Object

```

这是示例的输出。 `n1`和`n2`是与顶层关联的局部变量。 主要是为 Ruby 顶级执行环境指定的名称。 最后，`Object`是顶层的类型。

我们将有另一个与 Ruby 顶层相关的示例。

```ruby
#!/usr/bin/ruby

@name = "Jane"
@age = 17

def info
   "#{@name} is #{@age} years old" 
end

puts self.instance_variables
puts self.private_methods.include? :info

puts info

```

我们显示了属于顶级环境的实例变量和方法。

```ruby
@name = "Jane"
@age = 17

```

我们定义了两个实例变量。 实例变量以 Ruby 中的`@`字符开头。 实例变量属于特定的对象实例。 在这种情况下，它们属于 Ruby 顶级。

```ruby
def info
   "#{@name} is #{@age} years old" 
end

```

这是一个方法定义。 每个方法必须属于某个对象。 此方法属于顶级对象。 所有顶级方法都是私有的。 私有方法的访问受到限制。

```ruby
puts self.instance_variables

```

`instance_variables`方法打印出`self`的所有实例变量，在此上下文中指向 Ruby 顶层。

```ruby
puts self.private_methods.include? :info

```

所有顶级方法都是自动私有的。 `private_methods`返回对象的所有私有方法。 由于方法很多，我们调用`include?`方法来检查`info`方法是否在其中。 请注意，我们通过符号名称来引用`info`方法。

```ruby
$ ./toplevel2.rb
@name
@age
true
Jane is 17 years old

```

示例输出。

本章介绍了 Ruby 语言中对象的一些基础知识。