Literale

Literale erstellen Objekte, die Sie in Ihrem Programm verwenden können. Literale umfassen

Boolesche und Nil-Literale

nil und false sind beide falsche Werte. nil wird manchmal verwendet, um "kein Wert" oder "unbekannt" anzuzeigen, aber in bedingten Ausdrücken zu false ausgewertet.

true ist ein wahrer Wert. Alle Objekte außer nil und false werden in bedingten Ausdrücken zu einem wahren Wert ausgewertet.

Numerische Literale

Ganzzahl-Literale

Sie können ganze Zahlen beliebiger Größe wie folgt schreiben

1234
1_234

Diese Zahlen haben den gleichen Wert, 1.234. Der Unterstrich kann zur Verbesserung der Lesbarkeit für Menschen verwendet werden. Sie können einen Unterstrich an beliebiger Stelle in der Zahl platzieren.

Sie können ein spezielles Präfix verwenden, um Zahlen in dezimaler, hexadezimaler, oktaler oder binärer Form zu schreiben. Für Dezimalzahlen verwenden Sie das Präfix 0d, für Hexadezimalzahlen das Präfix 0x, für Oktalzahlen das Präfix 0 oder 0o, für Binärzahlen das Präfix 0b. Der alphabetische Teil der Zahl ist nicht case-sensitiv.

Beispiele

0d170
0D170

0xaa
0xAa
0xAA
0Xaa
0XAa
0XaA

0252
0o252
0O252

0b10101010
0B10101010

All diese Zahlen haben denselben Dezimalwert, 170. Wie bei Ganzzahlen und Gleitkommazahlen können Sie einen Unterstrich zur Lesbarkeit verwenden.

Gleitkomma-Literale

Gleitkommazahlen können wie folgt geschrieben werden

12.34
1234e-2
1.234E1

Diese Zahlen haben den gleichen Wert, 12,34. Sie können auch Unterstriche in Gleitkommazahlen verwenden.

Rationale Literale

Sie können ein Rational-Literal mit einem speziellen Suffix, 'r', schreiben.

Beispiele

1r       # => (1/1)
2/3r     # => (2/3)   # With denominator.
-1r      # => (-1/1)  # With signs.
-2/3r    # => (-2/3)
2/-3r    # => (-2/3)
-2/-3r   # => (2/3)
+1/+3r   # => (1/3)
1.2r     # => (6/5)   # With fractional part.
1_1/2_1r # => (11/21) # With embedded underscores.
2/4r     # => (1/2)   # Automatically reduced.

Syntax

<rational-literal> = <numerator> [ '/' <denominator> ] 'r'
<numerator> = [ <sign> ] <digits> [ <fractional-part> ]
<fractional-part> = '.' <digits>
<denominator> = [ sign ] <digits>
<sign> = '-' | '+'
<digits> = <digit> { <digit> | '_' <digit> }
<digit> = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'

Beachten Sie dies, das als Float-Zähler 1.2, geteilt durch Rational-Nenner 3r, interpretiert wird, was zu einem Float führt

1.2/3r  # => 0.39999999999999997

Komplexe Literale

Sie können eine Complex-Zahl wie folgt schreiben (mit dem Suffix i)

1i          #=> (0+1i)
1i * 1i     #=> (-1+0i)

Auch rationale Zahlen können imaginäre Zahlen sein.

12.3ri      #=> (0+(123/10)*i)

i muss nach r stehen; das Gegenteil ist nicht erlaubt.

12.3ir      #=> Syntax error

String-Literale

Doppelwandige String-Literale

Der gebräuchlichste Weg, Strings zu schreiben, ist die Verwendung von "

"This is a string."

Der String kann viele Zeilen lang sein.

Jedes interne " muss maskiert werden

"This string has a quote: \".  As you can see, it is escaped"

Doppelwandige Strings erlauben Escape-Sequenzen, die in Escape-Sequenzen beschrieben sind.

In einem doppelwandigen String wird jedes andere Zeichen nach einem Backslash als das Zeichen selbst interpretiert.

Doppelwandige Strings erlauben die Interpolation anderer Werte mit #{...}

"One plus one is two: #{1 + 1}"

Jeder Ausdruck kann in den interpolierten Abschnitt eingefügt werden, aber es ist am besten, den Ausdruck für die Lesbarkeit klein zu halten.

Sie können auch #@foo, #@@foo und #$foo als Abkürzung für #{ @foo }, #{ @@foo } bzw. #{ $foo } verwenden.

Siehe auch

Einfachwandige String-Literale

Interpolation kann durch Maskieren des „#“-Zeichens oder durch die Verwendung von einfachwandigen Strings deaktiviert werden

'#{1 + 1}' #=> "\#{1 + 1}"

Zusätzlich zur Deaktivierung der Interpolation deaktivieren einfachwandige Strings alle Escape-Sequenzen außer dem einfachen Anführungszeichen (\') und dem Backslash (\\).

In einem einfachwandigen String wird jedes andere Zeichen nach einem Backslash so interpretiert, wie es ist: ein Backslash und das Zeichen selbst.

Siehe auch

Literale String Verkettung

Nebeneinander liegende String-Literale werden vom Interpreter automatisch verkettet

"con" "cat" "en" "at" "ion" #=> "concatenation"
"This string contains "\
"no newlines."              #=> "This string contains no newlines."

Jede Kombination aus nebeneinander liegenden einfachwandigen, doppelwandigen und prozentualen Strings wird verkettet, solange kein prozentualer String der letzte ist.

%q{a} 'b' "c" #=> "abc"
"a" 'b' %q{c} #=> NoMethodError: undefined method 'q' for main

Zeichen-Literal

Es gibt auch eine Zeichen-Literal-Notation zur Darstellung einzelner Zeichen-Strings, deren Syntax ein Fragezeichen (?) gefolgt von einem einzelnen Zeichen oder einer Escape-Sequenz (außer Zeilenfortsetzung) ist, die einem einzelnen Codepoint in der Skriptkodierung entspricht

?a       #=> "a"
?abc     #=> SyntaxError
?\n      #=> "\n"
?\s      #=> " "
?\\      #=> "\\"
?\u{41}  #=> "A"
?\C-a    #=> "\x01"
?\M-a    #=> "\xE1"
?\M-\C-a #=> "\x81"
?\C-\M-a #=> "\x81", same as above
?あ      #=> "あ"

Escape-Sequenzen

Einige Zeichen können als Escape-Sequenzen in doppelwandigen Strings, Zeichen-Literalen, Here Document Literalen (nicht zitiert, doppelzitiert und mit Backticks), doppelzitierten Symbolen, doppelzitierten Symbolschlüsseln in Hash-Literalen, Regexp-Literalen und mehreren Prozent-Literalen (%, %Q, %W, %I, %r, %x) dargestellt werden.

Sie erlauben Escape-Sequenzen wie \n für Zeilenumbruch, \t für Tabulator usw. Die vollständige Liste der unterstützten Escape-Sequenzen lautet wie folgt

\a             bell, ASCII 07h (BEL)
\b             backspace, ASCII 08h (BS)
\t             horizontal tab, ASCII 09h (TAB)
\n             newline (line feed), ASCII 0Ah (LF)
\v             vertical tab, ASCII 0Bh (VT)
\f             form feed, ASCII 0Ch (FF)
\r             carriage return, ASCII 0Dh (CR)
\e             escape, ASCII 1Bh (ESC)
\s             space, ASCII 20h (SPC)
\\             backslash, \
\nnn           octal bit pattern, where nnn is 1-3 octal digits ([0-7])
\xnn           hexadecimal bit pattern, where nn is 1-2 hexadecimal digits ([0-9a-fA-F])
\unnnn         Unicode character, where nnnn is exactly 4 hexadecimal digits ([0-9a-fA-F])
\u{nnnn ...}   Unicode character(s), where each nnnn is 1-6 hexadecimal digits ([0-9a-fA-F])
\cx or \C-x    control character, where x is an ASCII printable character
\M-x           meta character, where x is an ASCII printable character
\M-\C-x        meta control character, where x is an ASCII printable character
\M-\cx         same as above
\c\M-x         same as above
\c? or \C-?    delete, ASCII 7Fh (DEL)
\<newline>     continuation line (empty string)

Das Letzte, <newline>, repräsentiert einen leeren String anstelle eines Zeichens. Es wird verwendet, um eine Zeile in einem String umzubrechen.

Here Document Literale

Wenn Sie einen großen Textblock schreiben, können Sie ein „Here Document“ oder „Heredoc“ verwenden

expected_result = <<HEREDOC
This would contain specially formatted text.

That might span many lines
HEREDOC

Der Heredoc beginnt in der Zeile nach <<HEREDOC und endet mit der nächsten Zeile, die mit HEREDOC beginnt. Das Ergebnis enthält den abschließenden Zeilenumbruch.

Sie können jeden Bezeichner mit einem Heredoc verwenden, aber Bezeichner in Großbuchstaben werden typischerweise verwendet.

Sie können den abschließenden Bezeichner einrücken, wenn Sie ein „-“ nach << setzen

  expected_result = <<-INDENTED_HEREDOC
This would contain specially formatted text.

That might span many lines
  INDENTED_HEREDOC

Beachten Sie, dass der abschließende Bezeichner zwar eingerückt sein kann, der Inhalt aber immer so behandelt wird, als wäre er linksbündig. Wenn Sie den Inhalt einrücken, erscheinen diese Leerzeichen in der Ausgabe.

Um eingerückten Inhalt sowie einen eingerückten abschließenden Bezeichner zu haben, können Sie einen „squiggly“ Heredoc verwenden, der ein „~“ anstelle eines „-“ nach << verwendet

expected_result = <<~SQUIGGLY_HEREDOC
  This would contain specially formatted text.

  That might span many lines
SQUIGGLY_HEREDOC

Die Einrückung der am wenigsten eingerückten Zeile wird von jeder Zeile des Inhalts entfernt. Beachten Sie, dass leere Zeilen und Zeilen, die ausschließlich aus literalen Tabs und Leerzeichen bestehen, für die Bestimmung der Einrückung ignoriert werden, aber maskierte Tabs und Leerzeichen gelten als Nicht-Einrückungszeichen.

Für die Messung einer Einrückung wird ein horizontaler Tabulator als eine Sequenz von einem bis acht Leerzeichen betrachtet, so dass die Spaltenposition, die seinem Ende entspricht, ein Vielfaches von acht ist. Der zu entfernende Betrag wird in Leerzeichen gezählt. Wenn die Grenze mitten in einem Tabulator erscheint, wird dieser Tabulator nicht entfernt.

Ein Heredoc erlaubt Interpolation und die in Escape-Sequenzen beschriebenen Escape-Sequenzen. Sie können Interpolation und das Escaping deaktivieren, indem Sie den öffnenden Bezeichner in einfache Anführungszeichen setzen

expected_result = <<-'EXPECTED'
One plus one is #{1 + 1}
EXPECTED

p expected_result # prints: "One plus one is \#{1 + 1}\n"

Der Bezeichner kann auch in doppelte Anführungszeichen (was dasselbe ist wie keine Anführungszeichen) oder in Backticks eingeschlossen werden. Wenn er in Backticks eingeschlossen ist, verhält sich der HEREDOC wie Kernel#`

puts <<-`HEREDOC`
cat #{__FILE__}
HEREDOC

Wenn Sie Anführungszeichen verwenden, kann jedes Zeichen außer diesem Anführungszeichen und dem Zeilenumbruch (CR und/oder LF) als Bezeichner verwendet werden.

Um eine Methode auf einem Heredoc aufzurufen, platzieren Sie sie nach dem öffnenden Bezeichner

expected_result = <<-EXPECTED.chomp
One plus one is #{1 + 1}
EXPECTED

Sie können mehrere Heredocs in derselben Zeile öffnen, dies kann jedoch schwer zu lesen sein

puts(<<-ONE, <<-TWO)
content for heredoc one
ONE
content for heredoc two
TWO

Symbol-Literale

Ein Symbol repräsentiert einen Namen innerhalb des Ruby-Interpreters. Weitere Details darüber, was Symbole sind und wann Ruby sie intern erstellt, finden Sie unter Symbol.

Sie können ein Symbol mit einem Doppelpunkt referenzieren: :my_symbol.

Sie können Symbole auch durch Interpolation und die in Escape-Sequenzen beschriebenen Escape-Sequenzen mit doppelten Anführungszeichen erstellen

:"my_symbol1"
:"my_symbol#{1 + 1}"
:"foo\sbar"

Wie bei Strings kann ein einzelnes Anführungszeichen verwendet werden, um Interpolation und Escape-Sequenzen zu deaktivieren

:'my_symbol#{1 + 1}' #=> :"my_symbol\#{1 + 1}"

Beim Erstellen eines Hash gibt es auch eine spezielle Syntax für die Referenzierung eines Symbol.

Siehe auch

Array-Literale

Ein Array wird erstellt, indem die Objekte zwischen [ und ] platziert werden

[1, 2, 3]

Sie können Ausdrücke in das Array einfügen

[1, 1 + 1, 1 + 2]
[1, [1 + 1, [1 + 2]]]

Siehe auch

Für die mit einem Array verwendbaren Methoden siehe Array.

Hash-Literale

Ein Hash wird erstellt, indem Schlüssel-Wert-Paare zwischen { und } verwendet werden

{ "a" => 1, "b" => 2 }

Sowohl der Schlüssel als auch der Wert können jedes Objekt sein.

Sie können einen Hash mit Symbolschlüsseln mit der folgenden Syntax erstellen

{ a: 1, b: 2 }

Diese gleiche Syntax wird für Schlüsselwortargumente einer Methode verwendet.

Wie bei Symbol-Literalen können Sie auch Symbolschlüssel in Anführungszeichen setzen.

{ "a 1": 1, "b #{1 + 1}": 2 }

ist gleichbedeutend mit

{ :"a 1" => 1, :"b 2" => 2 }

Hash-Werte können weggelassen werden, was bedeutet, dass der Wert aus dem Kontext anhand des Namens des Schlüssels abgerufen wird

x = 100
y = 200
h = { x:, y: }
#=> {:x=>100, :y=>200}

Für die mit einem Hash verwendbaren Methoden siehe Hash.

Bereichs-Literale

Ein Bereich repräsentiert ein Intervall von Werten. Der Bereich kann seinen Endwert einschließen oder ausschließen.

(1..2)  # includes its ending value
(1...2) # excludes its ending value
(1..)   # endless range, representing infinite sequence from 1 to Infinity
(..1)   # beginless range, representing infinite sequence from -Infinity to 1

Sie können einen Bereich aus beliebigen Objekten erstellen. Details zu den zu implementierenden Methoden finden Sie in der Range-Dokumentation.

Regexp-Literale

Ein regulärer Ausdruck kann mit führenden und nachfolgenden Schrägstrich-Zeichen ('/') erstellt werden

re = /foo/ # => /foo/
re.class   # => Regexp

Dem nachfolgenden Schrägstrich können ein oder mehrere Modifikatorzeichen folgen, die Modi für den regulären Ausdruck festlegen. Details finden Sie unter Regexp-Modi.

Interpolation kann innerhalb regulärer Ausdrücke zusammen mit maskierten Zeichen verwendet werden. Beachten Sie, dass ein regulärer Ausdruck möglicherweise zusätzliche maskierte Zeichen als ein String erfordert.

Siehe auch

Eine Beschreibung der Syntax von regulären Ausdrücken finden Sie unter Regexp.

Lambda Proc Literale

Ein Lambda-Proc kann mit -> erstellt werden

-> { 1 + 1 }

Das Aufrufen des obigen Procs ergibt das Ergebnis 2.

Sie können Argumente für den Proc wie folgt anfordern

->(v) { 1 + v }

Dieser Proc addiert eins zu seinem Argument.

Prozentuale Literale

Jedes der in diesem Abschnitt beschriebenen Literale kann diese gepaarten Begrenzer verwenden

Die Begrenzer können mit einem Backslash maskiert werden. Die ersten vier Paare (Klammern, runde Klammern, geschweifte Klammern und spitze Klammern) sind jedoch auch ohne Backslash erlaubt, solange sie korrekt gepaart sind.

Diese werden im nächsten Abschnitt demonstriert.

%q: Nicht interpolierbare String Literale

Sie können einen nicht interpolierbaren String mit %q schreiben. Der erstellte String ist derselbe, als ob Sie ihn mit einfachen Anführungszeichen erstellt hätten

%q[foo bar baz]       # => "foo bar baz" # Using [].
%q(foo bar baz)       # => "foo bar baz" # Using ().
%q{foo bar baz}       # => "foo bar baz" # Using {}.
%q<foo bar baz>       # => "foo bar baz" # Using <>.
%q|foo bar baz|       # => "foo bar baz" # Using two |.
%q:foo bar baz:       # => "foo bar baz" # Using two :.
%q(1 + 1 is #{1 + 1}) # => "1 + 1 is \#{1 + 1}" # No interpolation.
%q[foo[bar]baz]       # => "foo[bar]baz" # brackets can be nested.
%q(foo(bar)baz)       # => "foo(bar)baz" # parenthesis can be nested.
%q{foo{bar}baz}       # => "foo{bar}baz" # braces can be nested.
%q<foo<bar>baz>       # => "foo<bar>baz" # angle brackets can be nested.

Dies ist ähnlich wie bei einfachwandigen Strings, aber nur Backslashes und die angegebenen Begrenzer können mit einem Backslash maskiert werden.

% und %Q: Interpolierbare String Literale

Sie können einen interpolierbaren String mit %Q oder mit seinem Alias % schreiben

%[foo bar baz]       # => "foo bar baz"
%(1 + 1 is #{1 + 1}) # => "1 + 1 is 2" # Interpolation.

Dies ist ähnlich wie bei doppelwandigen Strings. Es erlaubt Escape-Sequenzen, die in Escape-Sequenzen beschrieben sind. Andere maskierte Zeichen (ein Backslash gefolgt von einem Zeichen) werden als das Zeichen interpretiert.

%w und %W: String-Array-Literale

Sie können ein Array von Strings als durch Leerzeichen getrennte Wörter mit %w (nicht interpolierbar) oder %W (interpolierbar) schreiben

%w[foo bar baz]       # => ["foo", "bar", "baz"]
%w[1 % *]             # => ["1", "%", "*"]
# Use backslash to embed spaces in the strings.
%w[foo\ bar baz\ bat] # => ["foo bar", "baz bat"]
%W[foo\ bar baz\ bat] # => ["foo bar", "baz bat"]
%w(#{1 + 1})          # => ["\#{1", "+", "1}"]
%W(#{1 + 1})          # => ["2"]

# The nested delimiters evaluated to a flat array of strings
# (not nested array).
%w[foo[bar baz]qux]   # => ["foo[bar", "baz]qux"]

Die folgenden Zeichen gelten als Leerzeichen zur Trennung von Wörtern

Die Leerzeichen können mit einem Backslash maskiert werden, um sie zu einem Wortteil zu machen.

%W erlaubt Escape-Sequenzen, die in Escape-Sequenzen beschrieben sind. Der Zeilenfortsetzungs-<newline> ist jedoch nicht verwendbar, da er als der maskierte Zeilenumbruch interpretiert wird, der oben beschrieben ist.

%i und %I: Symbol-Array-Literale

Sie können ein Array von Symbolen als durch Leerzeichen getrennte Wörter mit %i (nicht interpolierbar) oder %I (interpolierbar) schreiben

%i[foo bar baz]       # => [:foo, :bar, :baz]
%i[1 % *]             # => [:"1", :%, :*]
# Use backslash to embed spaces in the symbols.
%i[foo\ bar baz\ bat] # => [:"foo bar", :"baz bat"]
%I[foo\ bar baz\ bat] # => [:"foo bar", :"baz bat"]
%i(#{1 + 1})          # => [:"\#{1", :+, :"1}"]
%I(#{1 + 1})          # => [:"2"]

Die Leerzeichen und ihre Maskierungen werden wie bei den String-Array-Literalen interpretiert, die in %w und %W: String-Array-Literale beschrieben sind.

%s: Symbol Literale

Sie können ein Symbol mit %s schreiben

%s[foo]     # => :foo
%s[foo bar] # => :"foo bar"

Dies ist nicht interpolierbar. Keine Interpolation erlaubt. Nur Backslashes und die angegebenen Begrenzer können mit einem Backslash maskiert werden.

%r: Regexp Literale

Sie können einen regulären Ausdruck mit %r schreiben; das als führender und nachfolgender Begrenzer verwendete Zeichen kann (fast) jedes Zeichen sein

%r/foo/             # => /foo/
%r:name/value pair: # => /name\/value pair/

Einige „symmetrische“ Zeichenpaare können als Begrenzer verwendet werden

%r[foo] # => /foo/
%r{foo} # => /foo/
%r(foo) # => /foo/
%r<foo> # => /foo/

Dem nachfolgenden Begrenzer können ein oder mehrere Modifikatorzeichen folgen, die Modi für den regulären Ausdruck festlegen. Details finden Sie unter Regexp-Modi.

%x: Backtick-Literale

Sie können einen Shell-Befehl mit %x schreiben und ausführen

%x(echo 1)      # => "1\n"
%x[echo #{1 + 2}] # => "3\n"
%x[echo \u0030] # => "0\n"

Dies ist interpolierbar. %x erlaubt Escape-Sequenzen, die in Escape-Sequenzen beschrieben sind.