Format-Spezifikationen

Mehrere Ruby-Kernklassen haben Instanzmethoden printf oder sprintf

Jede dieser Methoden nimmt

Jede dieser Methoden gibt die Zeichenkette aus oder gibt sie zurück, die sich aus dem Ersetzen jeder in format_string eingebetteten Format-Spezifikation durch eine Zeichenkettenform des entsprechenden Arguments aus arguments ergibt.

Ein einfaches Beispiel

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

Eine Format-Spezifikation hat die Form

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

Sie besteht aus

Abgesehen vom führenden Prozentzeichen ist der einzige erforderliche Teil der Typ-Spezifizierer, daher beginnen wir damit.

Typ-Spezifizierer

Dieser Abschnitt gibt eine kurze Erklärung für jeden Typ-Spezifizierer. Die Links führen zu den Details und Beispielen.

Ganzzahl-Typ-Spezifizierer

Gleitkomma-Typ-Spezifizierer

Andere Typ-Spezifizierer

Flags

Die Auswirkung eines Flags kann je nach Typ-Spezifizierer stark variieren. Diese Hinweise sind allgemeiner Natur. Siehe typspezifische Details.

Mehrere Flags können mit einem einzelnen Typ-Spezifizierer angegeben werden; die Reihenfolge spielt keine Rolle.

' ' Flag

Fügt vor einer nicht-negativen Zahl ein Leerzeichen ein

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

Fügt ein Minuszeichen für einen negativen Wert ein

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

'#' Flag

Verwendet ein alternatives Format; variiert je nach Typ

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

'+' Flag

Fügt ein führendes Pluszeichen für eine nicht-negative Zahl hinzu

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

'-' Flag

Justiert den Wert linksbündig im Feld aus

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

'0' Flag

Füllt mit Nullen statt Leerzeichen auf der linken Seite auf

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

'n$' Flag

Formatiert das (1-basierte) n-te Argument in dieses Feld

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

Breiten-Spezifizierer

Im Allgemeinen bestimmt ein Breiten-Spezifizierer die Mindestbreite (in Zeichen) des formatierten Feldes

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

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

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

Wenn der Breiten-Spezifizierer '*' anstelle einer Ganzzahl ist, wird die tatsächliche Mindestbreite aus der Argumentliste entnommen

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

Präzisions-Spezifizierer

Ein Präzisions-Spezifizierer ist ein Dezimalpunkt gefolgt von null oder mehr Dezimalziffern.

Für Ganzzahl-Typ-Spezifizierer gibt die Präzision die minimale Anzahl von zu schreibenden Ziffern an. Wenn die Präzision kürzer als die Ganzzahl ist, wird das Ergebnis mit führenden Nullen aufgefüllt. Es erfolgt keine Änderung oder Kürzung des Ergebnisses, wenn die Ganzzahl länger als die Präzision ist.

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) # => ""

Für die Spezifizierer a/A, e/E, f/F gibt die Präzision die Anzahl der Ziffern nach dem Dezimalpunkt an, die geschrieben werden sollen.

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"

Für die Spezifizierer g/G gibt die Präzision die Anzahl der zu schreibenden signifikanten Ziffern an.

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"

Für die Spezifizierer s, p gibt die Präzision die Anzahl der zu schreibenden Zeichen an.

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

Wenn der Präzisions-Spezifizierer '*' anstelle einer nicht-negativen Ganzzahl ist, wird die tatsächliche Präzision aus der Argumentliste entnommen.

sprintf('%.*d', 20, 1)    # => "00000000000000000001"

Details und Beispiele zu Typ-Spezifizierern

Spezifizierer a und A

Formatiert argument als hexadezimale Gleitkommazahl

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"

Spezifizierer b und B

Die beiden Spezifizierer b und B verhalten sich identisch, außer wenn das Flag '#'+ verwendet wird.

Formatiert argument als binäre Ganzzahl

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"

Spezifizierer c

Formatiert argument als einzelnes Zeichen

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

Dies verhält sich wie String#<<, außer dass es ArgumentError anstelle von RangeError auslöst.

Spezifizierer d

Formatiert argument als dezimale Ganzzahl

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

Das Flag '#' ist nicht anwendbar.

Spezifizierer e und E

Formatiert argument in wissenschaftlicher Notation

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

Spezifizierer f

Formatiert argument als Gleitkommazahl

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

Das Flag '#' ist nicht anwendbar.

Spezifizierer g und G

Formatiert argument in Exponentialform (e/E-Spezifizierer), wenn der Exponent kleiner als -4 oder größer oder gleich der Präzision ist. Andernfalls wird argument in Gleitkommaform (f-Spezifizierer) formatiert.

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"

Spezifizierer o

Formatiert argument als Oktalzahl. Wenn argument negativ ist, wird es als Zweierkomplement mit dem Präfix ..7 formatiert.

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"

Spezifizierer p

Formatiert argument als Zeichenkette über argument.inspect

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

Spezifizierer s

Formatiert argument als Zeichenkette über argument.to_s

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

Das Flag '#' ist nicht anwendbar.

Spezifizierer x und X

Formatiert argument als hexadezimale Ganzzahl. Wenn argument negativ ist, wird es als Zweierkomplement mit dem Präfix ..f formatiert.

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"

Spezifizierer %

Formatiert argument ('%') als einzelnes Prozentzeichen

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

Flags sind nicht anwendbar.

Referenzierung nach Name

Für komplexere Formatierungen unterstützt Ruby die Referenzierung nach Name. Der Stil %<name>s verwendet den Formatstil, der Stil %{name} jedoch nicht.

Beispiele

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