格式规范¶ ↑

多个 Ruby 核心类具有实例方法 printf 或 sprintf

• ARGF#printf

• IO#printf

• Kernel#printf

• Kernel#sprintf

这些方法中的每一个都需要

• 参数 format_string，其中包含零个或多个嵌入的格式规范（见下文）。

• 参数 *arguments，其中包含零个或多个要格式化的对象。

这些方法中的每一个都会打印或返回字符串，该字符串是通过用 arguments 中的相应参数的字符串形式替换嵌入在 format_string 中的每个格式规范而生成的。

一个简单的示例

sprintf('Name: %s; value: %d', 'Foo', 0) # => "Name: Foo; value: 0"

格式规范具有以下形式

%[flags][width][.precision]type

它包含

• 一个前导百分号字符。

• 零个或多个标志（每个都是一个字符）。

• 一个可选的宽度说明符（一个整数）。

• 一个可选的精度说明符（一个点后跟一个非负整数）。

• 一个类型说明符（一个字符）。

除了前导百分号字符之外，唯一必需的部分是类型说明符，因此我们从那里开始。

类型说明符¶ ↑

本节对每个类型说明符提供简要说明。链接指向详细信息和示例。

整数类型说明符¶ ↑

• b 或 B：将 argument 格式化为二进制整数。请参阅 说明符 b 和 B。

• d、i 或 u（所有这些都是相同的）：将 argument 格式化为十进制整数。请参阅 说明符 d。

• o：将 argument 格式化为八进制整数。请参阅 说明符 o。

• x 或 X：将 argument 格式化为十六进制整数。请参阅 说明符 x 和 X。

浮点类型说明符¶ ↑

• a 或 A：将 argument 格式化为十六进制浮点数。请参阅 说明符 a 和 A。

• e 或 E：以科学记数法格式化 argument。请参阅 说明符 e 和 E。

• f：将argument格式化为小数浮点数。请参阅Specifier f。

• g或G：以“常规”格式格式化argument。请参阅Specifiers g and G。

其他类型说明符¶ ↑

• c：将argument格式化为字符。请参阅Specifier c。

• p：通过argument.inspect将argument格式化为字符串。请参阅Specifier p。

• s：通过argument.to_s将argument格式化为字符串。请参阅Specifier s。

• %：将argument（'%'）格式化为单个百分比字符。请参阅Specifier %。

标志¶ ↑

标志的效果在不同类型说明符中可能大不相同。这些说明本质上是通用的。请参阅特定于类型的详细信息。

可以为单个类型说明符指定多个标志；顺序无关紧要。

' '标志¶ ↑

在非负数前插入空格

sprintf('%d', 10)  # => "10"
sprintf('% d', 10) # => " 10"

为负值插入减号

sprintf('%d', -10)  # => "-10"
sprintf('% d', -10) # => "-10"

'#'标志¶ ↑

使用备用格式；不同类型有所不同

sprintf('%x', 100)  # => "64"
sprintf('%#x', 100) # => "0x64"

'+'标志¶ ↑

为非负数添加前导加号

sprintf('%x', 100)  # => "64"
sprintf('%+x', 100) # => "+64"

'-'标志¶ ↑

在字段中左对齐值

sprintf('%6d', 100)  # => "   100"
sprintf('%-6d', 100) # => "100   "

'0'标志¶ ↑

用零填充左侧，而不是空格

sprintf('%6d', 100)  # => "   100"
sprintf('%06d', 100) # => "000100"

'*'标志¶ ↑

将下一个参数用作字段宽度

sprintf('%d', 20, 14)  # => "20"
sprintf('%*d', 20, 14) # => "                  14"

'n$'标志¶ ↑

将第（基于 1 的）n个参数格式化为该字段

sprintf("%s %s", 'world', 'hello')     # => "world hello"
sprintf("%2$s %1$s", 'world', 'hello') # => "hello world"

宽度说明符¶ ↑

通常，宽度说明符确定格式化字段的最小宽度（以字符为单位）

sprintf('%10d', 100)  # => "       100"

# Left-justify if negative.
sprintf('%-10d', 100) # => "100       "

# Ignore if too small.
sprintf('%1d', 100)   # => "100"

精度说明符¶ ↑

精度说明符是小数点后跟零个或多个小数位。

对于整数类型说明符，精度指定要写入的最小数字数。如果精度短于整数，则结果用前导零填充。如果整数长于精度，则不会修改或截断结果

sprintf('%.3d', 1)    # => "001"
sprintf('%.3d', 1000) # => "1000"

# If the precision is 0 and the value is 0, nothing is written
sprintf('%.d', 0)  # => ""
sprintf('%.0d', 0) # => ""

对于a/A、e/E、f/F说明符，精度指定要写入的小数点后的数字数

sprintf('%.2f', 3.14159)  # => "3.14"
sprintf('%.10f', 3.14159) # => "3.1415900000"

# With no precision specifier, defaults to 6-digit precision.
sprintf('%f', 3.14159)    # => "3.141590"

对于g/G说明符，精度指定要写入的有效数字数

sprintf('%.2g', 123.45)  # => "1.2e+02"
sprintf('%.3g', 123.45)  # => "123"
sprintf('%.10g', 123.45) # =>  "123.45"

# With no precision specifier, defaults to 6 significant digits.
sprintf('%g', 123.456789) # => "123.457"

对于s、p说明符，精度指定要写入的字符数

sprintf('%s', Time.now)    # => "2022-05-04 11:59:16 -0400"
sprintf('%.10s', Time.now) # => "2022-05-04"

类型说明符详细信息和示例¶ ↑

说明符a和A¶ ↑

将argument格式化为十六进制浮点数

sprintf('%a', 3.14159)   # => "0x1.921f9f01b866ep+1"
sprintf('%a', -3.14159)  # => "-0x1.921f9f01b866ep+1"
sprintf('%a', 4096)      # => "0x1p+12"
sprintf('%a', -4096)     # => "-0x1p+12"

# Capital 'A' means that alphabetical characters are printed in upper case.
sprintf('%A', 4096)      # => "0X1P+12"
sprintf('%A', -4096)     # => "-0X1P+12"

说明符b和B¶ ↑

两个说明符b和B的行为相同，除非使用标志'#'+。

将argument格式化为二进制整数

sprintf('%b', 1)  # => "1"
sprintf('%b', 4)  # => "100"

# Prefix '..' for negative value.
sprintf('%b', -4) # => "..100"

# Alternate format.
sprintf('%#b', 4)  # => "0b100"
sprintf('%#B', 4)  # => "0B100"

说明符c¶ ↑

将argument格式化为单个字符

sprintf('%c', 'A') # => "A"
sprintf('%c', 65)  # => "A"

说明符d¶ ↑

将argument格式化为十进制整数

sprintf('%d', 100)  # => "100"
sprintf('%d', -100) # => "-100"

标志'#'不适用。

说明符e和E¶ ↑

以科学记数法格式化argument

sprintf('%e', 3.14159)  # => "3.141590e+00"
sprintf('%E', -3.14159) # => "-3.141590E+00"

说明符f¶ ↑

将argument格式化为浮点数

sprintf('%f', 3.14159)  # => "3.141590"
sprintf('%f', -3.14159) # => "-3.141590"

标志'#'不适用。

说明符g和G¶ ↑

如果指数小于 -4 或大于或等于精度，则使用指数形式（e/E说明符）格式化argument。否则，使用浮点形式（f说明符）格式化argument

sprintf('%g', 100)  # => "100"
sprintf('%g', 100.0)  # => "100"
sprintf('%g', 3.14159)  # => "3.14159"
sprintf('%g', 100000000000)  # => "1e+11"
sprintf('%g', 0.000000000001)  # => "1e-12"

# Capital 'G' means use capital 'E'.
sprintf('%G', 100000000000)  # => "1E+11"
sprintf('%G', 0.000000000001)  # => "1E-12"

# Alternate format.
sprintf('%#g', 100000000000)  # => "1.00000e+11"
sprintf('%#g', 0.000000000001)  # => "1.00000e-12"
sprintf('%#G', 100000000000)  # => "1.00000E+11"
sprintf('%#G', 0.000000000001)  # => "1.00000E-12"

说明符o¶ ↑

将argument格式化为八进制整数。如果argument为负数，则将其格式化为以..7为前缀的二进制补码

sprintf('%o', 16)   # => "20"

# Prefix '..7' for negative value.
sprintf('%o', -16)  # => "..760"

# Prefix zero for alternate format if positive.
sprintf('%#o', 16)  # => "020"
sprintf('%#o', -16) # => "..760"

说明符p¶ ↑

通过argument.inspect将argument格式化为字符串

t = Time.now
sprintf('%p', t)   # => "2022-05-01 13:42:07.1645683 -0500"

说明符s¶ ↑

通过argument.to_s将argument格式化为字符串

t = Time.now
sprintf('%s', t) # => "2022-05-01 13:42:07 -0500"

标志'#'不适用。

说明符x和X¶ ↑

将argument格式化为十六进制整数。如果argument为负数，则将其格式化为以..f为前缀的二进制补码

sprintf('%x', 100)   # => "64"

# Prefix '..f' for negative value.
sprintf('%x', -100)  # => "..f9c"

# Use alternate format.
sprintf('%#x', 100)  # => "0x64"

# Alternate format for negative value.
sprintf('%#x', -100) # => "0x..f9c"

说明符%¶ ↑

将argument（'%'）格式化为单个百分比字符

sprintf('%d %%', 100) # => "100 %"

标志不适用。

按名称引用¶ ↑

对于更复杂的格式化，Ruby 支持按名称引用。%<name>s 样式使用格式样式，但 %{name} 样式不使用。

示例

sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 }) # => 1 : 2.000000
sprintf("%{foo}f", { :foo => 1 })                      # => "1f"