Ruby 字符串

最后修改于 2023 年 10 月 18 日

在本 Ruby 教程中，我们将更详细地处理字符串数据。

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

字符串是 Unicode 字符的序列。它是一种数据类型，用于存储一系列数据值，其中元素通常根据字符编码代表字符。当字符串字面量出现在源代码中时，它被称为*字符串字面量*。

Ruby 字符串第一个例子

在 Ruby 中，字符串字面量用单引号或双引号括起来。

#!/usr/bin/ruby

# first.rb

puts 'Python language'
puts "Ruby language"

该示例有两个字符串字面量。第一个用单引号括起来。另一个用双引号括起来。

$ ./first.rb
Python language
Ruby language

Ruby 使用引号

如果我们想显示引号，例如在直接引用中，该怎么办？基本上有两种方法可以做到这一点。

#!/usr/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?"'

我们使用 (\) 字符来转义额外的引号。通常，双引号字符用于分隔字符串字面量。但是，转义后，原始含义被抑制。它显示为普通字符，可以在字符串字面量中使用。在引号中使用引号的第二种方法是混合使用单引号和双引号。

$ ./quotes.rb 
There are many stars
He said, "Which one is your favourite?"
There are many stars
He said, "Which one is your favourite?"

Ruby 转义序列

转义序列是在字符串字面量中使用时具有特定含义的特殊字符。

#!/usr/bin/ruby

puts "one two three four"
puts "one\ntwo\nthree\nfour"

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

$ ./newline.rb
one two three four
one
two
three
four

换行符后的单词将出现在关于脚本的输出的新行上。

r、b 和 t 字符是普通的字母字符。当它们前面加上一个 \ 字符时，它们就有了特殊的含义。

#!/usr/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 转义序列在两个单词之间放置一个制表符空间。

$ ./escapes.rb
aaabbb
Jane
Towering        inferno

反斜杠字符 \ 是一个特殊字符，用于创建转义序列。当需要打印反斜杠本身时，它前面会加上另一个反斜杠。它的默认含义被转义并被打印出来。单引号和双引号用于分隔 Ruby 中的字符串。为了打印它们，它们前面也加上 \。

#!/usr/bin/ruby

puts "The special character \\"
puts "The special character \'"
puts "The special character \""

在这个简单的脚本中，我们将所有三个字符打印到终端。

$ ./specials.rb
The special character \
The special character '
The special character "

Ruby 访问字符串元素

可以在 Ruby 中访问字符串元素。为此，我们使用方括号 []。在方括号内，我们可以放置字符串、索引或范围。

#!/usr/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 是第一个字符的索引。msg[0] 返回字符串的第一个字符，即 R。

puts msg[-1]

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

puts msg[0, 3]

用逗号分隔的两个索引返回从第一个索引开始并以第二个索引结束的字符，不包括第二个索引。

puts msg[0..9]

也可以使用范围运算符。这里我们打印 msg 字符串的前十个字符。

puts msg[0, msg.length]

此行返回整个字符串。msg.length 返回字符串的大小。

$ ./accessing.rb
Ruby

R
e
Rub
Ruby langu
Ruby language

Ruby 多行字符串

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

#!/usr/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 歌曲的歌词。我们展示了三种打印多行字符串的方法。它们可以在双引号中使用。我们可以使用 % 字符来构建一个多行字符串。% 后面的字符也括起字符串。最后，我们可以使用 heredoc 语法。在这种语法中，我们使用 << 后跟一些字符串。字符串括起多行字符串。它也必须左对齐。

Ruby 变量插值

变量插值是在字符串字面量中用它们的值替换变量。要用值替换变量，变量名放在字符串字面量中的 #{ 和 } 字符之间。

#!/usr/bin/ruby

name = "Jane"
age = 17

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

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

$ ./interpolation.rb
Jane is 17 years old

在替换中可以使用表达式。

#!/usr/bin/ruby

x = 5
y = 6

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

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

$ ./interpolation2.rb
The product of 5 and 6 is 30

运行示例。

还有另一种在字符串中替换变量的方法。

#!/usr/bin/ruby

name = "Jane"
age = 17

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

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

我们在使用它之前构建一个字符串。%s 和 %d 是格式化字符，分别期望一个字符串和一个数字。这些值在 % 字符之后的方括号中提供。

Ruby 连接字符串

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

#!/usr/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 方法，该方法添加两个字符串对象。它还返回最终对象，我们可以在其上调用另一个方法。因此，我们可以将这些方法放在一个链中。

$ ./concatenate.rb
Ruby programming languge
Python programming language
Perl programming language
Java programming language

Ruby 冻结字符串

在 Java 或 C# 中，字符串是不可变的。这意味着我们无法修改现有的字符串。我们只能从现有的字符串创建一个新的字符串。在 Ruby 中，默认情况下字符串不是不可变的。

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

#!/usr/bin/ruby

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

puts msg

msg.freeze

#msg << "and she is pretty"

在这个例子中，我们演示了字符串可以被修改。但是，在对字符串对象调用 freeze 方法后，我们不能再修改字符串了。如果我们取消代码行的注释，我们会得到“无法修改冻结字符串”的错误消息。

Ruby 比较字符串

比较字符串是编程中的一项常见工作。我们可以使用 == 运算符或 eql? 方法来比较两个字符串。如果字符串相等，它们将返回 true，否则返回 false。

#!/usr/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? 方法。该方法接受一个参数，即我们与之比较的第一个字符串。

$ ./comparing.rb
true
false
false
false
true

Ruby 有一个*太空船*运算符 <==>。该运算符来自 Perl 语言。与上述两种比较字符串的方式不同，这两种方式都返回 true 或 false，此运算符将返回 1、0 或 −1。具体取决于左参数相对于右参数的值。如果左参数大于右参数，则运算符返回 1。如果左参数小于右参数，则运算符返回 −1。如果这两个参数相等，则运算符返回 0。

一个字符大于另一个字符是什么意思？字符在表中排序。每个字符在表中都有一个位置。比较字符时，我们比较它们在这样的表中的位置。例如，在 ASCII 表中，字符 a 在字符 b 之前。因此，比较 a <==> b 返回 -1，因为左参数的位置低于 b。

#!/usr/bin/ruby

puts "a" <==> "b"
puts "b" <==> "a"
puts "a" <==> "a"

使用太空船运算符比较字符。

$ ./spaceship.rb
-1
1
0

可以比较字符串，而不考虑大小写。为此，Ruby 有一个 casecmp 方法。该方法的工作方式与太空船运算符相同。

#!/usr/bin/ruby

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

示例。

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

这两行返回相同的结果，0。在这种情况下，我们不考虑字符是大写还是小写。

$ ./case_comp.rb
0
0
1

字符串是 Ruby 中的对象

Ruby 是一种面向对象的语言。对象是 OOP 程序的基本构建块。字符串也是对象。一个对象是数据和方法的组合。在 OOP 程序中，创建对象，它们相互通信。

#!/usr/bin/ruby

website = "webcode.me"
puts website

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

在上面的例子中，我们展示了两种在 Ruby 中创建字符串的基本方法。

website = "webcode.me"

这里一个字符串字面量被分配给一个网站变量。在幕后，Ruby 解释器创建一个字符串对象。

website = String.new "zetcode.com"

这是创建字符串对象的标准方法。但是，在大多数情况下使用第一种方法，因为它不太冗长，而且是大多数计算机语言中创建字符串的常用方法。

#!/usr/bin/ruby

puts "zetcode".upcase
puts "zetcode".size
puts "zetcode".reverse

在这个代码示例中，我们在一个字符串字面量上调用了三种方法。对于熟悉 Java、C 和类似语言的人来说，这可能会让人困惑。在 Ruby 中，字符串字面量在调用方法时会转换为字符串对象。

$ ./string_object.rb
ZETCODE
7
edoctez

Ruby 字符串方法

Ruby 字符串对象具有可用于处理字符串的有用方法。我们已经看到了一些字符串方法，例如 concat 或 eql?。

#!/usr/bin/ruby

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 "The word #{word} has #{word.size} characters"

size 方法返回字符串中的字符数。

puts word.include? "tion"

include? 方法确定测试字符串中是否存在子字符串。在这种情况下，代码行返回 true。

puts word.empty?
word.clear

empty? 方法检查字符串是否为空。它返回一个布尔值 true 或 false。clear 方法使字符串为空。

$ ./basic_methods.rb
The word Determination has 13 characters
true
false

false
true

输出。

在下一个示例中，我们有一些处理字符大小写的方法。

#!/usr/bin/ruby

ruby = "Ruby programming language"

puts ruby.upcase
puts ruby.downcase
puts ruby.capitalize
puts ruby.swapcase

Ruby 有四种字符大小写的方法。upcase 方法返回字符串的副本，其中所有字符均为大写。downcase 方法返回字符串的副本，其中所有字符均为小写。capitalize 方法返回字符串的副本，其中第一个字符转换为大写，其余字符转换为小写。最后，swapcase 方法返回字符串的副本，其中大写字母转换为小写，反之亦然。

$ ./ruby_lang.rb
RUBY PROGRAMMING LANGUAGE
ruby programming language
Ruby programming language
rUBY PROGRAMMING LANGUAGE

接下来，我们介绍了两个 Ruby 字符串方法：start_with? 和 end_with?。这两个方法都返回一个布尔值 true 或 false。它们分别确定字符串是否以特定字符串开头或结尾。

#!/usr/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。

$ ./start_end.rb
false
true

true
false

在下面的示例中，我们处理 inspect 方法。该方法返回一个原始字符串，用引号括起来，特殊字符不被解释。当我们想要检查构成字符串的字符时，它很有用。

#!/usr/bin/ruby

msg = "Jane\t17\nThomas\t23"

puts msg
puts msg.inspect

inspect 字符串方法的示例。

msg = "Jane\t17\nThomas\t23"

这是一个带有特殊字符的字符串。

puts msg
puts msg.inspect

在第一种情况下，特殊字符被解释。字符串部分之间有一个制表符和一个换行符。在第二种情况下，我们以原始格式获取字符串。

$ ./inspect_method.rb
Jane    17
Thomas  23
"Jane\t17\nThomas\t23"

chomp 方法返回一个新字符串，该字符串从字符串的末尾删除了记录分隔符。默认分隔符是换行符 (\n)。

#!/usr/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

在上面的脚本中，我们从用户那里获取输入。我们对用户的响应做出反应。

$ ./user_input.rb
Are you sure to download? (Yes/No) Yes
Download cancelled
"Yes\n"

该脚本无法正常工作。当我们考虑 inspect 返回什么时，原因就变得清楚了。用户的输入以回车键结束。换行符也包含在 response 变量中。并且“yes”不等于“yes\n”。为了纠正脚本，我们使用 chomp 方法。它从变量中删除换行符。

#!/usr/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”字符串进行比较之前处理输入。chomp 方法删除换行符。

$ ./chomping.rb 
Are you sure to download? (Yes/No) yes
Downloaded
"yes\n"

现在这个例子可以正常工作了。

Ruby 格式化字符串

Ruby 有*格式说明符*。格式说明符决定了字符串的外观。它以 % 字符开头。格式说明符放在单引号或双引号内。

格式说明符具有以下字段

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

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

一个转换说明符指定数据将如何转换为可显示形式。

#!/usr/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]

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

$ ./format_specifiers.rb
There are 12 oranges in the basket.
There are 12 oranges and 10 apples in the basket.

在下面的例子中，我们涵盖了一些基本的转换说明符。

#!/usr/bin/ruby

puts "There are %d apples." % 5
puts "I can see %i oranges." % 3
puts "The width of iPhone 3G is %f mm." % 62.1
puts "This animal is called a %s" % "rhinoceros."

我们有用于整数、浮点数和字符串的转换说明符。

puts "There are %d apples." % 5
puts "I can see %i oranges." % 3

d 和 i 都可以用于整数。

puts "The width of iPhone 3G is %f mm." % 62.1

f 是浮点值的转换说明符。 默认情况下，浮点数有六位小数。

puts "This animal is called a %s" % "rhinoceros."

s 字符用于字符串。

$ ./format_specifiers2.rb
There are 5 apples.
I can see 3 oranges.
The width of iPhone 3G is 62.100000 mm.
This animal is called a rhinoceros.

接下来我们有一个使用格式说明符的实际例子。

#!/usr/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 方法将网站字符串的每个字符传递给块，每个循环一个字符，当前字符存储在 c 变量中。我们使用 ord 方法获取字符的 ASCII 码，该方法返回单字符字符串的序数。

$ ./characters.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/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

x 转换说明符用于将数字转换为二进制格式。

$ ./format_numbers.rb
300
12c
454
100101100
1.666667e+00

精度 是格式说明符中的一个字段。它被指定为小数点后面的一个数字。它对整数、浮点数和字符串有不同的含义。当与整数一起使用时，它表示要打印的最小位数。如果数字的位数少于精度，则前缀为零。整数的默认精度为 1，这意味着不填充零。当与浮点数一起使用时，精度是小数点后显示的位数。最后，对于字符串，精度是打印的最大字符数。

#!/usr/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 个零。 第二行代码中的 .1 是精度。 对于浮点值，它将小数位数减少到 1。

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

整数的默认精度为 1。在第二行中，我们指定了精度 .5，它在数字 16 之前添加（前置）3 个零。

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

第一行打印字符串的所有字符。 第二行只打印其中的五个。 删除了两个字符。

$ ./precision.rb
Height: 172.300000 cm
Height: 172.3 cm
16
00016
zetcode
zetco

字段宽度 指定要显示数据的最小宽度。它是一个数字，如果存在，则位于小数点之前。如果输出较短，则用空格填充，并右对齐。 如果我们在字段宽度之前放置一个减号，它将左对齐。 如果输出的长度大于字段宽度，则会完整显示。

#!/usr/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

在第一种情况下，我们打印五个数字，但未指定字段宽度。输出的宽度等于显示的字符数。 在第二种情况下，我们的字段宽度为 10。 5 个输出中的每一个的最小长度为 10 个字符。 数字右对齐。

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

我们打印两个数字。 输出的宽度分别为 1 和 2 个字符。

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

在这里，两种情况下的长度都是 10 个字符。 这两个数字分别用 9 和 8 个空格填充。

$ ./field_width.rb
1
16
165
1656
16567
         1
        16
       165
      1656
     16567

我们可以看到在第二种情况下，数字是右对齐的。

标志 修饰符修改格式的行为。

# 标志分别为二进制、八进制和十六进制格式添加 0b、0 和 0x 前缀。它将小数点添加到浮点值，即使小数位数已受到精度的限制。

#!/usr/bin/ruby

puts "%#b" % 231
puts "%#x" % 231
puts "%#o" % 231

puts "%.0e" % 231
puts "%#.0e" % 231

puts "%.0f" % 231
puts "%#.0f" % 231

在代码示例中，我们使用 x 标志。

puts "%#b" % 231
puts "%#x" % 231
puts "%#o" % 231

十进制 231 以二进制、八进制和十六进制格式打印。# 标志为它们添加了前缀。

puts "%.0e" % 231
puts "%#.0e" % 231

在这里，.0 精度会抑制数字的小数位数。但是，当与 # 标志一起使用时，会显示小数点，即使没有小数位。

$ ./flags.rb
0xe7
0b11100111
0347
2e+02
2.e+02
231
231.

+ 标志为正十进制数添加一个加号。 对于二进制、八进制和十六进制负数，它添加一个减号并使用一个绝对值。

#!/usr/bin/ruby

puts "%d" % 231
puts "%+d" % 231
puts "%d" % -231
puts "%+d" % -231

puts "%b" % -231
puts "%o" % -231
puts "%x" % -231

puts "%+b" % -231
puts "%+o" % -231
puts "%+x" % -231

一个示例，演示格式说明符的 + 标志。

puts "%d" % 231
puts "%+d" % 231

通常，正数的符号被省略。 如果我们想为正数显示一个加号，我们指定 + 标志。

puts "%d" % -231
puts "%+d" % -231

+ 标志对负数没有任何影响。 输出相同。

puts "%b" % -231
puts "%o" % -231
puts "%x" % -231

二进制、八进制和十六进制数有它们自己的方式来创建负数。

puts "%+b" % -231
puts "%+o" % -231
puts "%+x" % -231

如果我们为这些负数指定 + 标志，我们将数字转换为不同的格式并添加一个减号。 没有表示负数的特殊方法。

$ ./flags2.rb
231
+231
-231
-231
..100011001
..7431
..f19
-11100111
-347
-e7

在这里，我们介绍了 0 标志和 - 标志。0 标志导致数字用零填充而不是空格。- 标志使输出左对齐。

#!/usr/bin/ruby

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

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

示例。

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

数字将用零填充。

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

数字比字段宽度短，因此对齐。 而 - 标志使其左对齐。

$ ./field_width2.rb
0000000001
0000000016
0000000165
0000001656
0000016567
1
16
165
1656
16567

* 标志可用于精度和宽度。 每当我们使用 * 标志时，我们都必须将精度或宽度指定为参数。

#!/usr/bin/ruby

puts "%.*f" % [3, 1.1111111]
puts "%0*d" % [10, 2]
puts "%0*.*f" % [10, 3, 1.1111]

* 标志的例子。

puts "%.*f" % [3, 1.1111111]

在这里，我们使用 * 标志表示精度。 第一个数字 3 是精度的参数。 它说对于浮点数 1.1111111，将只显示三位小数。

puts "%0*d" % [10, 2]

在此代码行中，我们使用 * 标志表示宽度。 我们必须在 [] 括号之间添加宽度。 第一个数字是宽度，第二个数字是转换说明符的值。

puts "%0*.*f" % [10, 3, 1.1111]

* 标志可以同时用于宽度和精度。 我们必须在 [] 括号中同时指定它们。

$ ./flags3.rb
1.111
0000000002
000001.111

Ruby 教程的这一部分涵盖了字符串。