[翻译]Ruby教程6——数据类型

数据类型

在这一章的教程中我们开始讨论数据类型。


所有类别的计算机程序,包括电子表格、文本编辑器、计算器和聊天软件都使用数据。现代计算机语言中各种数据类型是必不可少的。一种数据类型是一些可操作的值的集合。


Ruby中有一些数据类型,这些类型都是基于类的。以下是Ruby中公认的数据类型:



  • 布尔(Booleans)

  • 符号(Symbols)

  • 数字(Numbers)

  • 字符串(Strings)

  • 数组(Arrays)

  • 哈希(Hashes)


下面的例子中我们展示Ruby中所有重要的数据类型。


#!/usr/bin/ruby

h = { :name => “Jane”, :age => 17 }

p true.class, false.class
p “Ruby”.class
p 1.class
p 4.5.class
p 3_463_456_457.class
p :age.class
p [1, 2, 3].class
p h.class

我们将它们的类型名打印出来,类型是用于创建对象的模块。


p true.class, false.class

truefalse对象展示的布尔类型。


p “Ruby”.class

这个是字符串。


p 1.class
p 4.5.class
p 3_463_456_457.class

这些是数字。


p :age.class

这个是符号标志,Ruby的一种特殊数据类型。


p [1, 2, 3].class
p h.class

这是两个容器,数组和哈希表。


$ ./types.rb

TrueClass

FalseClass

String

Fixnum

Float

Bignum

Symbol

Array

Hash


这个程序列出了属于Ruby的类型。


布尔值


在我们的世界里存在着对偶关系。天与地、水与火、男与女、爱与恨。这些就是我们自然中的“布尔”。在Ruby里,布尔类型只有一种,具有两个值:true(真)与false(假)。布尔是一种基本的数据类型,它在计算机程序中非常普遍。


高兴的父母等待着孩子的诞生。他们可能会给孩子取个名字。如果是男孩就叫John,如果是女孩就叫Victoria。


#!/usr/bin/ruby

# kid.rb

bool = [true, false]

male = bool[rand(2)]


if male
puts “We will use name John”
else
puts “We will use name Victoria”
end

在这个程序中我们使用随机数来模拟这种情况。


bool = [true, false]

我们创建一个名为bool的变量,它是一个数组包含了两个布尔值。这个数组是使用方括号创建的。


male = bool[rand(2)]

我们使用rand()方法生成一个随机数。这个方法返回0或1。返回的数用于数组的索引。


if male
puts “We will use name John”
else
puts “We will use name Victoria”
end

根据male变量我们打印一条信息。如果maletrue则名字选择John,否则选择Vactoria。类似is/else的结构控制语句是根据布尔值来选择的。


$ ./kid.rb

We will use name Victoria

$ ./kid.rb

We will use name Victoria

$ ./kid.rb

We will use name John

$ ./kid.rb

We will use name John

$ ./kid.rb

We will use name John


程序运行多次的结果如上。


符号标志


符号标志代表其他对象。使用符号标志而不是字符串,是因为可能保存一些资源。一个符号标志是Symbol类的一个实例对象。符号标志通常是在标识符的前面加上冒号,比如 :name。一些对象具有to_sym方法,用于将这些对象转化为符号标志。


Ruby的符号标志在程序运行时是不可改变的。它通常用于当作哈希表的键,因为一个键不需要完整的字符串功能。


#!/usr/bin/ruby

p :name
p :name.class
p :name.methods.size
p “Jane”.methods.size

p :name.object_id
p :name.object_id
p “name”.object_id
p “name”.object_id

第一个例子展示了符号标志的基本操作。


p :name
p :name.class

在终端上打印一个符号标志和它的类型。符号标志的类型是Symbol


p :name.methods.size
p “Jane”.methods.size

比较字符串实例与符号标志实例分配的方法数量。字符串的方法数是符号标志的两位多。


p :name.object_id
p :name.object_id
p “name”.object_id
p “name”.object_id

相同的符号标志具有相同的id,相同的字符串的id却不同。


$ ./symbols.rb

:name

Symbol

79

162

10328

10328

77344750

77344730


程序输出结果。




符号标志也可以作为常量标志,类似于C/C++中的枚举类型。


#!/usr/bin/ruby

light = :on

if light == :on
puts “The light is on”
else
puts “The light is off”
end

light = :off

if light == :on
puts “The light is on”
else
puts “The light is off”
end

电灯不是开就是关。对于这两种情况定义了符号标志。


light = :on

灯是开的。


if light == :on
puts “The light is on”
else
puts “The light is off”
end

程序的逻辑依赖于light变量的状态。




符号标志通常在哗然容器中作为键。这比字符串更加有效。


#!/usr/bin/ruby

domains = {:sk => “Slovakia”, :no => “Norway”, :hu => “Hungary”}

puts domains[:sk]
puts domains[:no]
puts domains[:hu]

在这个脚本中创建了一个名为domains的哈希表。它的键全是符号标志。


puts domains[:sk]
puts domains[:no]
puts domains[:hu]

在哈希表中键是用于访问值的。接下来我们打印出这个哈希表的值。


$ ./symbols3.rb

Slovakia

Norway

Hungary


以上是例子的输出结果。




Ruby解释器将内部引用存储为符号标志。


#!/usr/bin/ruby

class Being

def initialize
@is = true
end

def say
“I am being”
end
end

b = Being.new

p b.method :say
p b.instance_variable_get :@is

定义了一个Being类。该类有一个自定义实例变量@is和一个方法say。这两个实体在Ruby中保存为符号标志。


p b.method :say

method方法用于在b对象在查找给定名字的方法。我们查找的是:say符号。


p b.instance_variable_get :@is

使用instance_variable_get检查@is是不是b对象的一个实例变量。在内部变量存储为:@is符号。


$ ./symbols4.rb



true


输出结果。




所有的符号都存储在符号表中。下一个例子我们来看看这个表。Symbol类的all_symbols方法返回了一个数组包含这个表的全部符号。


#!/usr/bin/ruby

def info
“info method”
end

@v = “Ruby”
@@n = “16”

p Symbol.all_symbols.include? :info
p Symbol.all_symbols.include? :@v
p Symbol.all_symbols.include? :@@n

在这个Ruby脚本中创建了一个方法、一个实例变量和一个类变量。我们检查这些实体是否存储在符号表中。


p Symbol.all_symbols.include? :info

检查:info符号是否在符号表中。这行返回的是true


$ ./symbols5.rb

true

true

true


三个符号都在符号表中。


整数


整数是实数的一个子集。它没有分数或者小数。整数属于集合Z = {…, -2, -1, 0, 1, 2, …} 。这个集合是无限的。


在计算机语言中,整数是原始的数据类型。实际中计算机仅支持整数的一个子集,因为计算机的能力有限。整数用于统计离散的实体。我们有3、4、6个人,但是不能有3.33个人。我们有3.33千克。


在Ruby中整数是Fixnum或者Bignum类的实例对象。不同于其他语言,如Java或者C,在Ruby中整数是一个对象。这两种类型的大小不同。Fixnum类型的整数有一些限制,这些限制与机器有关。Bignum的值表示范围比Fixnum大。如果一些操作超出了Fixnum的范围,它会自动的转换成Bignum。程序员通常不需要关心整数的类型。


#!/usr/bin/ruby

p -2
p 121
p 123265
p -34253464356
p 34867367893463476

p 1.class
p 23453246.class
p 234532423563456346.class
p 2345324235632363463456456346.class

p 5 / 2
p 5.div 2

这个例子中我们处理的一些整数。


p -2
p 121
p 123265
p -34253464356
p 34867367893463476

这是一些不同大小的正数和负数。


p 1.class
p 23453246.class
p 234532423563456346.class
p 2345324235632363463456456346.class

打印出这些数的类型。前两个整数是Fixnum类型,其余两个是Bignum类型。


p 5 / 2
p 5.div 2

这两行展示的整数的相除。当两个数相除时我们使用了相除操作符/方法,结果也是一个整数。


$ ./integers.rb

-2

121

123265

-34253464356

34867367893463476

Fixnum

Fixnum

Bignum

Bignum

2

2


例子的输出结果。




在Ruby中整数可以有不同的表现符号。十进制、十六进制、八进制和二进制数都是可用的。十六进制数以0x字符开头,八进制以0字符开头,二进制以0b字符开头。


#!/usr/bin/ruby

puts 122
puts 0x7a
puts 0172
puts 0b1111010

这个例子中我们打印了十进制数122的所有表现形式。


$ ./inotations.rb

122

122

122

122


以上是输出结果。




我们使用整数的话,那么就是用于处理离散的实体。也许我们用于统计苹果的数量。


#!/usr/bin/ruby

baskets = 16
apples_in_basket = 24

total = baskets apples_in_basket

puts “There are total of #{total} apples”

在这个程序中我们使用整数统计苹果的总数。


$ ./apples.rb

There are total of 384 apples


以上是程序的输出。




大数字读起来比较困难。如果我们有一个数245342395423452,我们发现很难快速的将它读出来。计算机之外大的数字是用空格或者逗号分隔开来。为了可读性,Ruby允许数字包含下划线。Ruby解释器会忽略整数中的下划线。


#!/usr/bin/ruby

p 23482345629
p 23_482_345_629

p 23482345629 == 23_482_345_629

这个例子演示了下划线的使用。


p 23482345629 == 23_482_345_629

这行展示了两个数据是相等的。


$ ./underscore.rb

23482345629

23482345629

true


例子的输出结果。


浮点数


在计算中浮点数表示实数。实例意味着连续的数量,如:重量、高度和速度。Ruby中小数是Float或者BigDecimal类对象。BigDecimal类是Ruby的核心类,是Ruby标准库的一部分。此外我们还可以使用Rational对象。


我们需要理解数字是不业精确的。Ruby的官方文档清楚地说道浮点数对象表示的是不精确的实数。


#!/usr/bin/ruby

p 15.4
p 0.3455
p -343.4563

p 12.5.class
p -12.5.class
p (5.0 / 2).class

p 5.fdiv 2
p 12.to_f

上面的这个例子我们使用了浮点数。


p 15.4
p 0.3455
p -343.4563

这里我们打印三个小数的值。小数包含了小数点字符。


p 12.5.class
p -12.5.class
p (5.0 / 2).class

以上展示的数字的类型,全都是浮点数。最后一个整数与浮点数相除结果为浮点数。


p 5.fdiv 2
p 12.to_f

这里我们创建浮点数除法fdiv和转换方法to_f来创建浮点数。


$ ./decimals.rb

15.4

0.3455

-343.4563

Float

Float

Float

2.5

12.0


以上为转出结果。




一个小数默认最多只显示小数点后16个数字。我们可以使用sprintf或者printf方法来控制浮点数的格式。


#!/usr/bin/ruby

p 1/3.0
p 1.fdiv 2

puts sprintf “%.4f” % (1/3.0)
puts sprintf “%.7f” % (5/3.0)

格式化小数。


p 1/3.0
p 13.fdiv 4
p 1.fdiv 2

第一行打印的小数在小数点后有16个数字。第二行打印的有两个。第三行打印的有一个。


puts sprintf “%.4f” % (1/3.0)
puts sprintf “%.7f” % (5/3.0)

这里我们使用sprintf方法控制小数点后面的数字个数。sprintf方法的格式说明符是精确的。它是一个数字接着%符号。f是一个转换说明符,表示处理的是一个浮点数。


$ ./formatfloat.rb

0.3333333333333333

3.25

0.5

0.3333

1.6666667


以上是输出结果。




Ruby支持使用科学的记数法来表示一个浮点数。这也称为指数记数法,它是将非常大或者非常小的数转换成正常的小数形式。


#!/usr/bin/ruby

p 1.2e-3
p 0.0012

p 1.5E-4
p 0.00015

这个例子展示了两个使用科学记数表示的小数。


$ ./scientific.rb

0.0012

0.0012

0.00015

0.00015


这是以上程序的输出。




前面我们主说过浮点数的值稍微有些不精确。在很多计算中,普通的浮点小数已经足够精确了,如:我们的体重是60kg还是60.000024kg并不重要。对于其他计算,包括科学和工程应用,精确度是非常重要的。


Ruby有一个BigDecimal标准库。这个类对于非常大或者非常精准的浮点数提供了任意的精度。


#!/usr/bin/ruby

require ‘bigdecimal’

sum = 0

1000.times do
sum = sum + 0.0001
end

p sum


sum = BigDecimal.new(“0”)

1000.times do
sum = sum + BigDecimal.new(“0.0001”)
end

puts sum.to_s(‘F’)
puts sum.to_s(‘E’)

在这个例子中我们比较了FloatBigDecimal的精度。


require ‘bigdecimal’

BigDecimal类必须导入。


sum = 0

1000.times do
sum = sum + 0.0001
end

p sum

通过循环对一个很小的浮点数求和。最后会出现一点误差。


sum = BigDecimal.new(“0”)

1000.times do
sum = sum + BigDecimal.new(“0.0001”)
end

然后再对BigDecimal做同样的事情。


puts sum.to_s(‘F’)
puts sum.to_s(‘E’)

sum浮点数打印为工程记数形式。


$ ./bigdecimal.rb

0.10000000000000184

0.1

0.1E0


输出结果表示BigDecimalFloat更精确。




如果一个短路运动员100m跑9.87s,那么他的时速是多少?


#!/usr/bin/ruby

distance = 0.1
time = 9.87 / 3600

speed = distance / time

puts “The average speed of a sprinter is #{speed} km/h”

这个例子必需使用浮点数。


distance = 0.1

100m等于0.1km。


time = 9.87 / 3600

9.87s等于9.87/6060 h。


speed = distance / time

要计算速度,我们用距离除以时间。


$ ./speed.rb

The average speed of a sprinter is 36.4741641337386 km/h


以上是speed.rb脚本的输出。


有理数


Ruby支持有理数。有理数是一个确切的数。使用有理数可以避免舍入错误。Ruby中有理数是Rational类的对象。我们可以使用某些对象的to_r方法来创建有理数。


有理数可以用于表示两个整数相除的分数,a/b(b!=0)。如果b为1,每个整数都是一个有理数。


#!/usr/bin/ruby

puts 2.to_r
puts “23”.to_r
puts 2.6.to_r

p Rational 0
p Rational 1/5.0
p Rational 0.5

这个例子展示了一些有理数。


puts 2.to_r

变量我们使用to_r方法将整数2转化为有理数2/1。


p Rational 0.5

使用Rational方法创建一个有理数》


$ ./rational.rb

2/1

23/1

5854679515581645/2251799813685248

(0/1)

(3602879701896397/18014398509481984)

(1/2)


例子的输出结果。


空值


Ruby有一个特殊的值nil。它表示空值。nilNilClass类的单实例,仅有一个nil


#!/usr/bin/ruby

puts nil
p nil

p $val

p [1, 2, 3][4]

p $val1 == $val2

nil的一个例子。


puts nil
p nil

在终端上打印nil的值。puts方法打印空字符串,p方法打印‘nil’字符串。


p $val

当我们引用一个没有定义的全局变量时会返回nil值。


p [1, 2, 3][3]

这行代码我们引用了一个3元素数组的第4个元素,结果返回nil。Ruby中的许多方法对于无效的值都返回nil


p $val1 == $val2

这行返回true,这实际上是因为nilNilClass的单实例对象。


$ ./nilvalue.rb


nil

nil

nil

true


输出结果。


字符串


字符串在计算机程序代表文本数据。Ruby字符串是一个序列化的unicode字符。字符串是String的一个对象。字符串的字面量是字符加上双引号或者单引号。


字符串是一个非常重要的数据类型。它需要专门用一章来介绍。这里我们仅包含一个小例子。


#!/usr/bin/ruby

p “Ruby”
p ‘Python’

p “Ruby”.size
p “Ruby”.upcase

p 23.to_s

这个例子中我们使用了Ruby的字符串。我们使用p方法是为了在输出中看到数据类型。


p “Ruby”
p ‘Python’

在终端中打印两个字符串的字面值。第一个字面量是使用双引号,第二个是单引号。


p “Ruby”.size
p “Ruby”.upcase

这两行调用了两个字符串的方法。size方法返回字符串的长度,在这里是4个字符。upcase方法是将字符串转为大写。


p 23.to_s

to_s方法是将整数转为字符串。


$ ./strings.rb

“Ruby”

“Python”

4

“RUBY”

“23”


在输出中我们看到字符串是在引号内。这就是我们使用p方法的结果,printputs方法都不会带上引号。


数组和哈希表


数组和哈希表是对象的集合。他们将对象集合在一起。


数组是对象的有序集合。哈希表是键-值对的集合。我们将会用单独的一章来介绍数组和哈希表。以下仅是一个预览的例子。


#!/usr/bin/ruby

nums = [1, 2, 3, 4]

puts “There are #{nums.size} items in the array”

nums.each do |num|
puts num
end


domains = { :de => “Germany”, :sk => “Slovakia”,
:us => “United States”, :no => “Norway” }

puts domains.keys
puts domains.values

这是一个Ruby数组和哈希表的例子。


nums = [1, 2, 3, 4]

puts “There are #{nums.size} items in the array”

nums.each do |num|
puts num
end

这里创建一个有4项内容的数组。第二行统计了这个数组数据项的数量,并合并到了消息中。随后我们使用each方法将每个元素打印在终端上。


domains = { :de => “Germany”, :sk => “Slovakia”,
:us => “United States”, :no => “Norway” }

puts domains.keys
puts domains.values

创建了Ruby的哈希表,然后打印它的键和值。


$ ./arrayshashes.rb

There are 4 items in the array

1

2

3

4

de

sk

us

no

Germany

Slovakia

United States

Norway


例子的输出结果。


类型转换


我们经常是一次使用多种数据类型。在编程中从一种数据类型转换为其他类型是很平常的。类型转换或者类型的引用会将一个实体从一个类型转换成另一个类型。有两种类型转换的方式:隐式和显式。隐式类型转换又称为强制转换,是被编译器自动的转换。Ruby只有显式转换。


Ruby有内建的转换方法。如:to_ito_s或者to_f。内核模块有一些公共的方法用来转换,如IntergerString或者Float。这些方法还要与Ruby的类混淆。


#!/usr/bin/ruby


p Array(1..6)
p Complex 6
p Float 12
p Integer “34”
p Rational 6
p String 22

这里我们展示了内核模块的转换方法。


$ ./convertmethods.rb

[1, 2, 3, 4, 5, 6]

(6+0i)

12.0

34

(6/1)

“22”


例子的输出结果。




#!/usr/bin/ruby

p “12”.to_i
p 12.5.to_i
p nil.to_i

p 12.to_f
p “11”.to_f
p nil.to_f

以上例子我们展示了数字的转换。一些对象具有to_ito_f方法将对象转换成整数和浮点数。


p “12”.to_i
p 12.5.to_i
p nil.to_i

这里我们将字符串、小数和nil转换成整数。


p 12.to_f
p “11”.to_f
p nil.to_f

这三行将整数、字符串和nil转换成小数。


$ ./conversions.rb

12

12

0

12.0

11.0

0.0


例子的输出结果。




第二个例子展示了一些字符串的转换。


#!/usr/bin/ruby

p “12”.to_i
p “13”.to_f
p “12”.to_r
p “13”.to_c

p “Jane”.to_sym

v = “Ruby Python Tcl PHP Perl”.split
p v.class

上面的例子中我们将字符串转换为不同类型的对象。


p “12”.to_i
p “13”.to_f
p “12”.to_r
p “13”.to_c

这里将字符串转换成整数、小数、有理数和复数。


p “Jane”.to_sym

将字符串变为符号标志。


v = “Ruby Python Tcl PHP Perl”.split
p v.class

使用字符串的split方法将字符串转换成数组。


$ ./stringconv.rb

12

13.0

(12/1)

(13+0i)

:Jane

Array


输出结果。




下面的小例子展示了数组哈希表的转换。


#!/usr/bin/ruby

h = {:de => “Germany”, :sk => “Slovakia”}
p h.to_a

a = [:de, “Germany”, :sk, “Slovakia”,
:hu, “Hungary”, :no, “Norway”]
p Hash[a]

这个例子的代码我们创建了一个哈希表并转换成数组,创建一个数组并转换成哈希表。


h = {:de => “Germany”, :sk => “Slovakia”}
p h.to_a

哈希表转换为数组使用to_a方法。


a = [:de, “Germany”, :sk, “Slovakia”,
:hu, “Hungary”, :no, “Norway”]
p Hash[a]

将数组转换成哈希表。在这里的上下文中使用了星号操作符。这个风格来自Perl。它将一个数组分割成多个变量。


$ ./h2a.rb

[[:de, “Germany”], [:sk, “Slovakia”]]

{:de=>”Germany”, :sk=>”Slovakia”, :hu=>”Hungary”, :no=>”Norway”}


输出结果。


这章在教程覆盖了数据类型和它们的转换。




原文地址: http://zetcode.com/lang/rubytutorial/datatypes/

翻译:龙昌 admin@longchangjin.cn

完整教程:https://github.com/wusuopu/Ruby-tutorial