# Ruby 字符串

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

在 Ruby 教程的这一部分中，我们将更详细地处理字符串数据。

字符串是计算机语言中最重要的数据类型之一。 这就是为什么我们将一整章专门讨论在 Ruby 中使用字符串的原因。

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

## Ruby 字符串第一个示例

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

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

# first.rb

puts 'Python language'
puts "Ruby language"

```

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

```ruby
$ ./first.rb 
Python language
Ruby language

```

输出。

## Ruby 使用引号

如果我们想显示报价，例如直接讲话怎么办？ 基本上有两种方法可以做到这一点。

```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?"'

```

我们使用（\）字符转义其他引号。 通常，双引号用于分隔字符串字面值。 但是，当转义时，其原始含义被抑制。 它显示为普通字符，可以在字符串字面值中使用。 在引号中使用引号的第二种方法是混合单引号和双引号。

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

```

Output.

## Ruby 转义序列

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

```ruby
#!/usr/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`字符是普通字母字符。 以`\`字符开头时，它们具有特殊含义。

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

puts "   bbb\raaa" 
puts "Joan\b\b\bane" 
puts "Towering\tinferno" 

```

在上面的示例中，我们使用了三个不同的转义字符。

```ruby
puts "   bbb\raaa"

```

回车`\r`是行尾到行首的控制字符。 在将字符串打印到控制台之前，先对其进行处理。 转义序列使`aaa`字符放置在`bbb`字符之前。 输出为`aaabbb`。

```ruby
puts "Joan\b\b\bane" 

```

`\b`控制字符是一个空格。 删除前一个字符。 打印到控制台的字符串是“`Jane`”而不是“`Joan`”。

```ruby
puts "Towering\tinferno" 

```

最后，`\t`转义序列在两个单词之间放置一个制表符空间。

```ruby
$ ./escapes.rb 
aaabbb
Jane
Towering        inferno

```

示例的输出。

反斜杠字符`\`是用于创建转义序列的特殊字符。 当需要打印反斜杠本身时，它前面会带有另一个反斜杠。 其默认含义被转义并被打印。 单引号和双引号用于在 Ruby 中定界字符串。 为了打印它们，它们之前还带有`\`。

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

```

Output.

## Ruby 访问字符串元素

可以在 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]

```

此代码示例说明如何访问字符串的一部分。

```ruby
msg = "Ruby language"

```

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

```ruby
puts msg["Ruby"]

```

在此代码行中，我们测试字符串`'Ruby'`是否为`msg`字符串的子字符串。 如果为`true`，则返回我们要查找的字符串。

```ruby
puts msg[0]

```

字符串的字符可以通过其索引进行访问。 数字从 0 开始。换句话说，0 是第一个字符的索引。 `msg[0]`返回字符串的第一个字符，即`R`。

```ruby
puts msg[-1]

```

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

```ruby
puts msg[0, 3]

```

用逗号分隔的两个索引返回从第一个索引开始到第二个索引结束的字符（不包括在内）。

```ruby
puts msg[0..9]

```

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

```ruby
puts msg[0, msg.length]

```

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

```ruby
$ ./access.rb
Ruby

R
e
Rub
Ruby langu
Ruby language

```

Output of the example.

## Ruby 多行字符串

在许多编程语言中，创建多行字符串需要付出额外的努力。 在 Visual Basic 中尤其如此。 在 Ruby 中，可以轻松创建多行字符串。

```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 变量插值

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

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

name = "Jane"
age = 17

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

```

在此示例中，我们替换字符串中的两个变量：`name`和`age`。

```ruby
$ ./interpolation.rb 
Jane is 17 years old

```

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

```ruby
#!/usr/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 支持插值的方式。

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

name = "Jane"
age = 17

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

```

例。

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

```

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

## Ruby 连接字符串

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

```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 提供了多种连接字符串的方法。

```ruby
lang = "Ruby" + " programming" + " languge"

```

加号运算符是最常用的运算符，用于添加计算机语言中的字符串。 Perl 和 PHP 使用点`.`运算符来连接字符串。

```ruby
lang = "Python" " programming" " language"

```

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

```ruby
lang = "Perl" << " programming" << " language"

```

可以用来连接字符串的另一个运算符是`<<`。

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

```

实际上，每个字符串字面值都是一个对象。 我们可以在每个 Ruby 对象上调用各种方法。 在字符串对象上，我们可以调用`concat`方法，该方法将添加两个字符串对象。 它还返回最终对象，我们可以在该对象上调用另一个方法。 因此，我们可以将这些方法放在一个链中。

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

```

Output.

## Ruby 冻结字符串

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

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

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

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

puts "12" == "12"
puts "17" == "9"
puts "aa" == "ab"

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

```

在此代码示例中，我们比较了一些字符串。

```ruby
puts "12" == "12"

```

这两个字符串相等，该行返回`true`。

```ruby
puts "aa" == "ab"

```

两个字符串的前两个字符相等。 接下来比较以下字符。 它们是不同的，因此该行返回`false`。

```ruby
puts "Jane".eql? "Jan"

```

`eql?`方法用于比较两个字符串。 字符串是对象，并且都具有内置的`eql?`方法。 该方法采用一个参数，即我们要与之比较的第一个字符串的字符串。

```ruby
$ ./comparing.rb
true
false
false
false
true

```

程序的输出。

Ruby 具有飞船运算符`<==>`。 该运算符来自 Perl 语言。 与上面两种比较字符串（返回`true`或`false`）的方式不同，此运算符将返回 1、0 或 -1。 取决于左参数相对于右参数的值。 如果左参数大于右参数，则运算符返回 1。如果左参数小于右参数，则运算符返回 -1。 如果两个参数相等，则运算符将返回 0。这意味着一个字符大于另一个字符？ 字符在表中排序。 每个字符在表中都有一个位置。 比较字符时，我们将比较它们在此类表格中的位置。 例如，在 ASCII 表中，字符`a`位于字符`b`之前。 因此比较`<==> b`会返回 -1，因为左侧参数的位置比`b`低。

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

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

```

将角色与太空飞船运算符进行比较。

```ruby
$ ./spaceship.rb
-1
1
0

```

Output of the example.

不管大小写，都可以比较字符串。 为此，Ruby 具有`casecmp`方法。 该方法的工作方式与飞船运算符相同。

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

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

```

Example.

```ruby
puts "Jane".casecmp "Jane"
puts "Jane".casecmp "jane"

```

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

```ruby
$ ./case.rb
0
0
1

```

Output of the example.

## 字符串是 Ruby 中的对象

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

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

website = "google.com"
puts website

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

```

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

```ruby
website = "google.com"

```

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

```ruby
website = String.new "zetcode.com"

```

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

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

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

```

在此代码示例中，我们在字符串字面值上调用三个方法。 对于熟悉 Java，C 和类似语言的人，这可能会令人困惑。 在 Ruby 中，字符串字面值被转换为可以在其上调用方法的字符串对象。

```ruby
$ ./stringobject2.rb
ZETCODE
7
edoctez

```

Output of the example.

## Ruby 字符串方法

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

```ruby
#!/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?

```

我们有一个字符串变量。 提出了四种字符串方法。

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

```

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

```ruby
puts word.include? "tion"

```

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

```ruby
puts word.empty?
word.clear

```

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

```ruby
$ ./basicmethods.rb
The word Determination has 13 characters
true
false

false
true

```

输出。

在下一个示例中，我们将提供适用于字符大小写的方法。

```ruby
#!/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
$ ./rubylang.rb
RUBY PROGRAMMING LANGUAGE
ruby programming language
Ruby programming language
rUBY PROGRAMMING LANGUAGE

```

Output.

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

```ruby
#!/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"

```

这是上述方法的示例。

```ruby
puts ws1.start_with? "www."

```

在这里，我们检查字符串是否以“`www`”开头。 否，因此控制台的输出为布尔值`false`。

```ruby
puts ws1.end_with? ".com"

```

我们检查`ws1`字符串变量是否以“`.com`”后缀结尾。 确实如此，因此我们在控制台中看到了一个真实的结果。

```ruby
$ ./startend.rb
false
true

true
false

```

Output.

在下面的示例中，我们将处理`inspect`方法。 该方法返回一个原始字符串，该字符串用引号引起来，带有未解释的特殊字符。 当我们要检查什么字符组成字符串时，这很有用。

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

msg = "Jane\t17\nThomas\t23"

puts msg
puts msg.inspect

```

`inspect`字符串方法的示例。

```ruby
msg = "Jane\t17\nThomas\t23"

```

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

```ruby
puts msg
puts msg.inspect

```

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

```ruby
$ ./inspectmethod.rb
Jane    17
Thomas  23
"Jane\t17\nThomas\t23"

```

Output of the example.

`chomp`方法返回一个新字符串，其中记录分隔符已从字符串末尾删除。 默认的分隔符是换行符（`\n`）。

```ruby
#!/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

```

在上面的脚本中，我们从用户那里得到了输入。 我们对用户的反应作出反应。

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

```

该脚本无法正常运行。 当我们考虑`inspect`返回时，原因就很清楚了。 来自用户的输入以回车键结束。 换行符也包含在响应变量中。 并且“是”不等于“是\ n”。 要更正脚本，我们使用`chomp`方法。 它从变量中删除换行符。

```ruby
#!/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

```

这是更正的示例。

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

```

在这里，我们在将输入与“ yes”字符串进行比较之前先对其进行处理。 `chomp`方法删除换行符。

```ruby
$ ./chomp.rb
Are you sure to download? (Yes/No) Yes
Downloaded
"Yes\n"

```

现在该示例正常工作。

## Ruby 格式化字符串

Ruby 具有格式说明符。 格式说明符确定字符串的外观。 它以`%`字符开头。 格式说明符放在单引号或双引号中。

格式说明符具有以下字段：

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

```

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

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

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

```

这是一些格式说明符的示例。

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

```

当我们在字符串中使用`%d`表示法时，我们期望此时有一个数字。 `d`是十进制数字的转换说明符。 该数字在`%`字符后给出。

```ruby
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.

```

Output of the example.

在下面的示例中，我们将介绍一些基本的转换说明符。

```ruby
#!/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."

```

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

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

```

`d`和`i`均可用于整数。

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

```

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

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

```

`s`字符用于字符串。

```ruby
$ ./basicspecifiers.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.

```

Output of the example.

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

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

website = "zetcode.com"

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

```

在此示例中，我们遍历字符串的所有字符并将其 ASCII 值打印到终端。

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

```

`each_char`方法将网站字符串的每个字符传递到块，每个周期一个字符，而当前字符存储在`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

```

示例的输出。

数字可以以多种形式显示。 转换说明符可用于格式化数字。

```ruby
#!/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)

```

在上面的示例中，我们以十进制，十六进制，八进制，二进制和科学格式打印数字。

```ruby
# hexadecimal
puts "%x" % 300

```

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

```ruby
# binary
puts "%b" % 300

```

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

```ruby
$ ./various.rb
300
12c
454
100101100
1.666667e+00

```

Output.

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

```ruby
#!/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"

```

在此示例中，我们将使用`precision`字段。

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

```

172.3 是浮点数。 如果未指定精度，则小数点后将有 6 个小数位。 在我们的情况下，将有 5 个零。 第二条代码行中的`.1`是精度。 对于浮点值，它将小数位数减少到 1。

```ruby
puts "%d" % 16
puts "%.5d" % 16

```

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

```ruby
puts "%s" % "zetcode"
puts "%.5s" % "zetcode"

```

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

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

```

Output.

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

```ruby
#!/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 个字符。 数字右对齐。

```ruby
puts "%d" % 1
puts "%d" % 16

```

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

```ruby
puts "%10d" % 1
puts "%10d" % 16

```

两种情况下的长度均为 10 个字符。 这两个数字以给定的顺序填充 9 和 8 空格。

```ruby
$ ./fieldwidth.rb
1
16
165
1656
16567
         1
        16
       165
      1656
     16567

```

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

标志限定符修改格式的行为。

`#`标志分别将`0b`，`0`和`0x`前缀添加到二进制，八进制和十六进制格式。 即使精度限制了小数位数，它也会向浮点值添加小数点。

```ruby
#!/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`标志。

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

```

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

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

```

在此，`.0`精度替代数字的小数位。 但是，当与`#`标志一起使用时，即使没有十进制数字，也会显示小数点。

```ruby
$ ./flags1.rb
0xe7
0b11100111
0347
2e+02
2.e+02
231
231.

```

Output.

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

```ruby
#!/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

```

演示格式说明符的`+`标志的示例。

```ruby
puts "%d" % 231
puts "%+d" % 231

```

通常，正数会省略其符号。 如果要显示正数的加号，请指定`+`标志。

```ruby
puts "%d" % -231
puts "%+d" % -231

```

`+`标志对负数无效。 输出是相同的。

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

```

二进制，八进制和十六进制数具有创建负数的自己的方式。

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

```

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

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

```

Output of the example.

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

```ruby
#!/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

```

例。

```ruby
puts "%010d" % 1
puts "%010d" % 16

```

数字将用零填充。

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

```

小于字段宽度的数字被对齐。 并且`-`标志使其左对齐。

```ruby
$ ./fieldwidth2.rb
0000000001
0000000016
0000000165
0000001656
0000016567
1         
16        
165       
1656      
16567

```

示例的输出。

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

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

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

```

*标志的示例。

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

```

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

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

```

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

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

```

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

```ruby
$ ./flags3.rb
1.111
0000000002
000001.111

```

Output of the example.

Ruby 教程的这一部分介绍了字符串。