POSTS

第七章、ruby中的字符串

February 12, 2019

字符串

在这部分的教程将详细的介绍字符串。

字符串是计算机语言中最重要的数据类型之一，这就是为什么我们决定要用一整章来介绍字符串。

字符串是序列化的unicode字符。它是一种数据类型存储了序列化的值，它的元素通常代表的是根据字符编码的字符。当一个字符串在代码中以字面量出现，它也称为字符串文本。

第一个例子

在Ruby中字符串文本是以单引号或者双引号引起来的。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
# first.rb

puts 'Python language'
puts "Ruby language"

这个例子有两个字符串，第一个是用单引号，另一个是用双引号。

➜  ~ ruby first.rb
Python language
Ruby language

使用引号

如果我们想要显示引号该怎么做，直接引用？这有两种方法实现。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "There are many stars"
puts "He said, \"Which one is your favourite?\""

puts 'There are many stars'
puts 'He said, "Which one is your favourite?"'

我们使用\字符将引号转义。通常双引号是用于划定字符串的范围，然后被转义之后它原始的意义就没有了。它在字符串中被作为一个正常的字符。第二种方法是混合使用单引号和双引号。

➜  ~ ruby quotes.rb
There are many stars
He said, "Which one is your favourite?"
There are many stars
He said, "Which one is your favourite?"

转义序列

转义符是特殊的字符，在字符串中有特殊的含义。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "one two three four"
puts "one\ntwo\nthree\nfour"

最常用一个的转义符是换行符\n。它在许多编程语言中都有效。换行符之后的字符将出现在新的一行。

➜  ~ ruby newline.rb
one two three four
one
two
three
four

以上脚本的输出结果中换行符之后的字符在新的一行。

r、b和t是正常的字符，当前面加上\字符后就具有特殊意义了。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "   bbb\raaa"
puts "Joan\b\b\bane"
puts "Towering\tinferno"

这个例子中我们用到了三个不同的转义字符。

puts "   bbb\raaa"

回车符\r控制之后的字符回到行首。之前打印到终端上的字符串会被处理。这个转义字符会将aaa字符位于bbb之前，输出为aaabbb。

puts "Joan\b\b\bane"

\b是退格控制符，它会删掉前一个字符。这个字符串将在终端上打印’Jane’而不是’Joan’。

puts "Towering\tinferno"

最后\t转义符是用于两个词之间制表空格的。

➜  ~ ruby escapes.rb
aaabbb
Jane
Towering	inferno

反斜杠\是用于创建转义符的特殊字符。当需要打印反斜杠时，则在它前面加上另一个反斜杠。这意味着转义过了可以打印。在Ruby中单引号和双引号用于划定字符串范围的，想要打印它们同样也需要在前面加上\。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "The special character \\"
puts "The special character \'"
puts "The special character \""

这个例子中我们在终端上打印了这三个字符。

➜  ~ ruby specials.rb
The special character \
The special character '
The special character "

访问字符串的元素

在Ruby中我们可以使用方括号[]来访问字符串的元素。在括号内可以使用字符串、范围索引。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
msg = "Ruby language"

puts msg["Ruby"]
puts msg["Python"]

puts msg[0]
puts msg[-1]

puts msg[0, 3]
puts msg[0..9]
puts msg[0, msg.length]

这个例子的代码展示了我们可以访问字符串的一部分。

msg = "Ruby language"

这里是我们将要访问的字符串。

puts msg["Ruby"]

这行代码我们测试字符串’Ruby’是否是msg的子串。如果是将返回该字符串。

puts msg[0]

可以通过索引来访问这个字符串的字符。编号是从0开始的，也就是说0号索引是第1个字符。msg[0]返回字符串的第一个字符R。

puts msg[-1]

这里我们访问最后一个字符。-1代表了最后一个索引。

puts msg[0, 3]

两个用逗号分隔的索引返回了从第1个索引开始到第2个索引的字符，不包括第2个索引。

puts msg[0..9]

范围操作符也可以完成同样操作。这里我们打印前10个字符。

puts msg[0, msg.length]

这行返回全部的字符。msg.length返回字符串的长度。

➜  ~ ruby access.rb
Ruby

R
e
Rub
Ruby langu
Ruby language

多行字符串

许多编程语言要创建多行字符串需要额外的努力，在Visual Basic中尤其如此。但是在Ruby中却是很容易。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "I hear Mariachi static on my radio
And the tubes they glow in the dark
And I'm there with her in Ensenada
And I'm here in Echo Park
"

puts %/
Carmelita hold me tighter
I think I'm sinking down
And I'm all strung out on heroin
On the outskirts of town/

puts <<STRING

Well, I'm sittin' here playing solitaire
With my pearl-handled deck
The county won't give me no more methadone
And they cut off your welfare check
STRING

这个例子中我们使用了Carmelita歌曲的歌词。我们展示了使用三种方法打印多行字符串。可以使用双引号；可以使用%字符创建多行字符串，用%后面的字符将字符串包围住；最后我们使用定界符，这和语法是使用<<接着一些字符串，用这个字符串包围住多行字符。它必须左对齐。

变量替换

变量替换是将字符串的变量替换成它们的值。为了将变量替换成值，这个变量在字符串需要放在#{和}之间。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
name = "Jane"
age = 17

puts "#{name} is #{age} years old"

这个例子中我们替换了字符串中的两个变量：name和age。

➜  ~ ruby interpolation.rb
Jane is 17 years old

也可以替换表达式。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
x = 5
y = 6

puts "The product of #{x} and #{y} is #{x*y}"

这是一个表达式替换的例子。

➜  ~ ruby interpolation2.rb
The product of 5 and 6 is 30

这是另一种替换变量的方法。类似于Python 2.x所支持的替换。

name = "Jane"
age = 17

message = "%s is %d years old" % [name, age]
puts message

以上是一个例子。

message = "%s is %d years old" % [name, age]

使用之前先创建一个字符串。%s和%d是格式化字符，分别表示字符串和数字。值由%字符后面的方括号提供。

字符串连接

字符串连接是从多个字符串创建一个字符串。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
lang = "Ruby" + " programming" + " languge"
puts lang

lang = "Python" " programming" " language"
puts lang

lang = "Perl" << " programming" << " language"
puts lang

lang = "Java".concat(" programming").concat(" language")
puts lang

Ruby提供多种方法连接字符串。

lang = "Ruby" + " programming" + " languge"

在计算机语言中加法操作符是最常用的一种。Perl和PHP是用的点操作符(.)。

lang = "Python" " programming" " language"

Ruby自动连接多个后续的字符串。

lang = "Perl" << " programming" << " language"

另一种方法是使用<<操作符。

lang = "Java".concat(" programming").concat(" language")

每个字符串字面符实际上都是一个对象。我们可以对Ruby对象调用很多方法。对于字符串对象可以调用concat方法连接两个字符串。它返回最后的结果对象，再对其调用另一个方法。这样我们就将这些方法链接起来了。

➜  ~ ruby concatenate.rb
Ruby programming languge
Python programming language
Perl programming language
Java programming language

冻结字符串

在Java或者C#中字符串是不可变的，这意味着不能修改已存在的字符串。只能通过已存在的字符串创建一个新的。在Ruby中字符串同样也是不可修改的。

Ruby中字符串对象有一个freeze方法，可以使它们不可变。

msg = "Jane"
msg << " is " 
msg << "17 years old"

puts msg

msg.freeze

#msg << "and she is pretty"

这个例子我们演示了字符串是可变的。然后在调用freeze方法之后我们就不能再作修改了。如果我们取消掉注释将会得到’can’t modify frozen string’错误信息。

字符串比较

在编程中字符串比较是件平常的事情。我们可以使用==操作符或者eql?方法来比较两个字符串，如果相等返回true，否则false。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "12" == "12"
puts "17" == "9"
puts "aa" == "ab"

puts "Jane".eql? "Jan"
puts "Jane".eql? "Jane"

这个例子的代码我们比较了一些字符串。

puts "12" == "12"

这两个是相等的，这行返回true。

puts "aa" == "ab"

第一个字符是相等，然后比较下一个字符。它们不同，因此返回false。

puts "Jane".eql? "Jan"

eql?方法用于比较两个字符串。所有对象都内建了eql?方法。这个方法将另一个要比较的字符串作为参数传入。

➜  ~ ruby comparing.rb
true
false
false
false
true

Ruby中有一个“飞船(spaceship)”操作符<=>。这个操作符来自Perl，与以上两个比较方法不同，它不是返回true和false，而是返回1、0或者-1。取决于左参数和右参数的关系。如果左参数大于右参数则返回1；如果左参数小于右参数则返回-1；如果相等返回0。什么才是一个字符大于另一个字符呢？字符在表中是有序的，在表中每个字符有一位位置。当比较字符时实际比较它们在表中的位置。例如ASCII表，字符a在b的前面，因此a<=>b返回-1，因为左参数的位置小于右参数b。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "a" <=> "b"
puts "b" <=> "a"
puts "a" <=> "a"

使用“飞船”操作符比较字符串。

➜  ~ ruby spaceship.rb
-1
1
0

有可能比较字符串不管大小写。在Ruby中有casecmp方法。这个方法与飞船操作符相同。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "Jane".casecmp "Jane"
puts "Jane".casecmp "jane"
puts "Jane".casecmp "Jan"

以上是一个例子。

puts "Jane".casecmp "Jane"
puts "Jane".casecmp "jane"

这两行返回结果都是0.因为我们不考虑字符的大小写。

➜  ~ ruby case.rb
0
0
1

字符串对象

Ruby是面向对象语言。对象是面向对象程序的基本代码块。字符串也是对象。对象由数据和方法组成。在面向对象程序中，创建对象并且相互通信。

website = "google.com"
puts website

website = String.new "zetcode.com"
puts website

以上例子我们展示了两个创建字符串的基本方法。

website = "google.com"

这里是使用字符串字面量创建了一个website字符串变量。

website = String.new "zetcode.com"

这是标准创建字符串对象的方法。然而第一种更常用，因为它更简洁，并且在计算机语言中更普遍。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "zetcode".upcase
puts "zetcode".size
puts "zetcode".reverse

这个例子中我们对字符串字面量调用了三个方法。如果是熟悉Java或者C的人可能会困惑。在Ruby中调用方法时字符串字面量会转化为一个字符串对象。

➜  ~ ruby stringobject2.rb
ZETCODE
7
edoctez

字符串方法

Ruby字符串对象有一些有用的方法。如我们见到过的concat或者eql?。

word = "Determination"

puts "The word #{word} has #{word.size} characters"

puts word.include? "tion"
puts word.include? "tic"

puts

puts word.empty?
word.clear
puts word.empty?

创建一个字符串变量，展示了四个字符串的方法。

puts word.include? "tion"

include?方法判断一个字符串是否为子串。这里返回的是true。

puts word.empty?
word.clear

empty?方法检查字符串是否为空。返回一个布尔值。clear方法清空字符串。

接下来的例子介绍字符串大小写的方法。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
ruby = "Ruby programming language"
puts ruby.upcase
puts ruby.downcase
puts ruby.capitalize
puts ruby.swapcase

Ruby中有四个与大小写相关的方法。upcase方法将字符串全转为大写并返回一个新对象；downcase方法是将字符串全转为小写并返回一个新对象；capitalize方法是将字符串的首字母大写并返回一个新的对象。最后swapcase方法是将大小写反转并返回一个新对象。

➜  ~ ruby rubylang.rb
RUBY PROGRAMMING LANGUAGE
ruby programming language
Ruby programming language
rUBY PROGRAMMING LANGUAGE

接下来展示两个Ruby字符串的方法：start_with? 和end_with?。这两个方法都是返回布尔值。它们判断一个字符串是否分别以另一个字符串开头或结尾。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
ws1 = "zetcode.com"
ws2 = "www.gnome.org"

puts ws1.start_with? "www."
puts ws2.start_with? "www."

puts

puts ws1.end_with? ".com"
puts ws2.end_with? ".com"

这是一个上述方法的例子。

puts ws1.start_with? "www."

这里检查一个字符串是否以”www.“开头。如果不是则在终端打印false

puts ws1.end_with? ".com"

检查字符串ws1是否以”.com”结尾。如果是则在终端打印true。

➜  ~ ruby startend.rb
false
true

true
false

接下来我们介绍inspect方法。这个方法返回被引号包围原始的字符串，对于特殊字符不处理。对于想要检查字符串由哪些字符组成的比较有用。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
msg = "Jane\t17\nThomas\t23"

puts msg
puts msg.inspect

inspect方法的一个例子。

msg = "Jane\t17\nThomas\t23"

这个字符串有一些特殊的字符。

puts msg
puts msg.inspect

第一种情况，字符串中的制表符和换行符被解释了。第二种情况我们得到了一个原始格式的字符串。

➜  ~ ruby inspectmethod.rb
Jane	17
Thomas	23
"Jane\t17\nThomas\t23"

chomp方法是将字符串尾部的分隔符去掉并返回一个新对象。默认的分隔符是换行符(\n)。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
print "Are you sure to download? (Yes/No) "

response = gets

if (response.downcase == "yes")
    puts "Downloaded"
else
    puts "Download cancelled"
end

puts response.inspect

上面的脚本我们从用户输入一些内容，然后再返回给用户。

➜  ~ ruby chomp.rb
Are you sure to download? (Yes/No) yes
Download cancelled
"yes\n"

这个脚本没有正确的工作。原因很清晰，由inspect返回了。用户输入的内容以回车键结尾，因此换行符也被包含其中了。”Yes”与”Yes\n”不相等。要使用脚本正确运行，我们使用chomp方法移除掉换行符。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
print "Are you sure to download? (Yes/No) "

response = gets

if (response.downcase.chomp == "yes")
    puts "Downloaded"
else
    puts "Download cancelled"
end

puts response.inspect

这个是正确的脚本。

if (response.downcase.chomp == "yes")

这里我们在比”Yes”比较之前对输入内容进行了处理。

➜  ~ ruby chomp.rb
Are you sure to download? (Yes/No) yes
Downloaded
"yes\n"

格式化字符串

Ruby中有格式化说明符。格式化说明符决定了如何显示一个字符串。它以%字符开始。格式化说明符放在单引号或者双引号内。

格式化说明符有以下字段。

%[flags][field width][precision]conversion specifier

方括号内的字段是可选的。

转换说明符表明数据将如何进行转换。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "There are %d oranges in the basket." % 12
puts "There are %d oranges and %d apples in the basket." % [12, 10]

这是一个格式化说明符的例子。

puts "There are %d oranges in the basket" % 12

当我们在字符串中使用%d，我们在这个位置将期望一个数字。d是十进制数的转换说明符。这个数据在%字符后面给出。

puts "There are %d oranges and %d apples in the basket" % [12, 10]

当我们在一个字符串中使用多个格式化说明符时，每个都以%开始。多个值放在[]之间并以逗号分隔。

➜  ~ ruby formatspecifiers.rb
There are 12 oranges in the basket.
There are 12 oranges and 10 apples in the basket.

接下来是一个实践的例子。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
website = "zetcode.com"

website.each_char do |c|
    print "#{c} has ASCII code %d\n" % c.ord
end

这个例子我们记遍历字符串的所有字符并在终端上打印它的ASCII值。

website.each_char do |c|
    print "#{c} has ASCII code %d\n" % c.ord    
end

each_char方法将website字符串中的每个字符传给代码块，一个字符是一次循环。当前的字符保存在这是c中。我们使用ord方法获取字符的ASCII值。

➜  ~ ruby character.rb
z has ASCII code 122
e has ASCII code 101
t has ASCII code 116
c has ASCII code 99
o has ASCII code 111
d has ASCII code 100
e has ASCII code 101
. has ASCII code 46
c has ASCII code 99
o has ASCII code 111
m has ASCII code 109

数字有多种显示形式。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
#  decimal
 puts "%d" % 300
#  hexadecimal
 puts "%x" % 300

#  octal
 puts "%o" % 300

#  binary
 puts "%b" % 300

#  scientific
 puts "%e" % (5/3.0)

上面的例子中我们打印数字的十进制、十六进制、八进制、二进制和科学记数的形式。

# hexadecimal
puts "%x" % 300

x转换符用于将数字转为十六进制格式。

# binary
puts "%b" % 300

b转换符用于将数字转为二进制格式。

➜  ~ ruby various.rb
300
12c
454
100101100
1.666667e+00

精度是格式化说明符的一个字段。它指明了后面小数点的位数。它对于整数、小数和字符串有不同的意义。当用于整数时表明了最少打印多少个数字。如果数字个数少于精度则前面用0补全。对于整数精度默认为1,表示前面没有0.当用于浮点数时表示小数点后显示多少个数字。最后，用于字符串时精度表示多少个字符会打印。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts 'Height: %f %s' % [172.3, 'cm']
puts 'Height: %.1f %s' % [172.3, 'cm']

puts "%d" % 16
puts "%.5d" % 16

puts "%s" % "zetcode"
puts "%.5s" % "zetcode"

这个例子中我们使用了精度字段。

puts 'Height: %f %s' % [172.3, 'cm']
puts 'Height: %.1f %s' % [172.3, 'cm']

172.3是一个浮点数。如果没有指定精度则会显示6个小数。这里将会显示5个0.第二行的.1是精度，它将小数个数减为1。

puts "%d" % 16
puts "%.5d" % 16

对于整数默认精度为1。第二行中我们指明了精度为.5，这将会在16前面加上3个0。

puts "%s" % "zetcode"
puts "%.5s" % "zetcode"

第一行会打印所有的字符串。第二行仅打印5个，有两个字符将抛弃。

➜  ~ ruby precision.rb
Height: 172.300000 cm
Height: 172.3 cm
16
00016
zetcode
zetco

宽度字段表示数据最小要显示的宽度。它是一个数字，并且在小数点之前。如果输出比较短，则会被用空格填充，且右对齐。如果宽度前面有减号则会左对齐。如果输出比宽度长则会完整输出。

#!/usr/local/rvm/rubies/ruby-2.3.0/bin/ruby
puts "%d" % 1
puts "%d" % 16
puts "%d" % 165
puts "%d" % 1656
puts "%d" % 16567

puts "%10d" % 1
puts "%10d" % 16
puts "%10d" % 165
puts "%10d" % 1656
puts "%10d" % 16567

第一种情况打印5个数字没有指明宽度。输出的宽度即为数字的位数。第二种情况指明宽度为10。则每个都最少输出10字符的长度，数字右对齐。

puts "%d" % 1
puts "%d" % 16

打印两个数字，输出的宽度分别为1、2个字符。

puts "%10d" % 1
puts "%10d" % 16

这里宽度都为10个字符。这两个数被填充了8、9个空格。

➜  ~ ruby fieldwidth.rb
1
16
165
1656
16567
         1
        16
       165
      1656
     16567

我们发现第二种情况数字是右对齐的。

这章的教程介绍的Ruby的字符串。zetcode原文地址

ruby