class String

Rohe Strings sind JSON-Objekte (die rohen Bytes werden in einem Array für den Schlüssel "raw" gespeichert). Der Ruby String kann durch diese Klassenmethode erstellt werden.

Gibt ein neues String-Objekt zurück, das den gegebenen string enthält.

Die options sind optionale Schlüsselwortoptionen (siehe unten).

Ohne Argument und ohne Angabe des Schlüsselworts encoding wird ein leerer String mit der Encoding ASCII-8BIT zurückgegeben.

s = String.new # => ""
s.encoding     # => #<Encoding:ASCII-8BIT>

Mit dem Argument string und ohne Angabe der Schlüsselwortoption encoding wird ein neuer String mit der gleichen Kodierung wie string zurückgegeben.

s0 = 'foo'.encode(Encoding::UTF_16)
s1 = String.new(s0)
s1.encoding # => #<Encoding:UTF-16 (dummy)>

(Im Gegensatz zu String.new hat ein String-Literal wie '' oder ein Heredoc-Literal immer die Skript-Kodierung.)

Mit der Schlüsselwortoption encoding wird ein String mit der angegebenen Kodierung zurückgegeben; die encoding kann ein Encoding-Objekt, ein Kodierungsname oder ein Kodierungsnamensalias sein.

String.new(encoding: Encoding::US_ASCII).encoding        # => #<Encoding:US-ASCII>
String.new('', encoding: Encoding::US_ASCII).encoding    # => #<Encoding:US-ASCII>
String.new('foo', encoding: Encoding::US_ASCII).encoding # => #<Encoding:US-ASCII>
String.new('foo', encoding: 'US-ASCII').encoding         # => #<Encoding:US-ASCII>
String.new('foo', encoding: 'ASCII').encoding            # => #<Encoding:US-ASCII>

Die angegebene Kodierung muss nicht für den Inhalt des Strings gültig sein, und ihre Gültigkeit wird nicht überprüft.

s = String.new('こんにちは', encoding: 'ascii')
s.valid_encoding? # => false

Aber die angegebene encoding selbst wird überprüft.

String.new('foo', encoding: 'bar') # Raises ArgumentError.

Mit der Schlüsselwortoption capacity ist der gegebene Wert nur ein Hinweis und legt möglicherweise die Größe des internen Puffers fest oder auch nicht, was wiederum die Leistung beeinflussen kann.

String.new('foo', capacity: 1)    # Buffer size is at least 4 (includes terminal null byte).
String.new('foo', capacity: 4096) # Buffer size is at least 4;
                                  # may be equal to, greater than, or less than 4096.

Versucht, das gegebene object in einen String zu konvertieren.

Wenn object bereits ein String ist, gibt object unverändert zurück.

Andernfalls, wenn object auf :to_str reagiert, wird object.to_str aufgerufen und das Ergebnis zurückgegeben.

Gibt nil zurück, wenn object nicht auf :to_str reagiert.

Löst eine Ausnahme aus, es sei denn, object.to_str gibt einen String zurück.

Gibt das Ergebnis der Formatierung von object in die Formatangaben zurück, die in self enthalten sind (siehe Format Specifications).

'%05d' % 123 # => "00123"

Wenn self mehrere Formatangaben enthält, muss object ein Array oder ein Hash sein, der die zu formatierenden Objekte enthält.

'%-5s: %016x' % [ 'ID', self.object_id ]                # => "ID   : 00002b054ec93168"
'foo = %{foo}' % {foo: 'bar'}                           # => "foo = bar"
'foo = %{foo}, baz = %{baz}' % {foo: 'bar', baz: 'bat'} # => "foo = bar, baz = bat"

Verwandt: siehe Konvertierung zu neuem String.

Gibt einen neuen String zurück, der n Kopien von self enthält.

'Ho!' * 3 # => "Ho!Ho!Ho!"
'No!' * 0 # => ""

Verwandt: siehe Konvertierung zu neuem String.

Gibt einen neuen String zurück, der other_string an self angehängt enthält.

'Hello from ' + self.to_s # => "Hello from main"

Verwandt: siehe Konvertierung zu neuem String.

Gibt self zurück, wenn self nicht eingefroren ist und ohne Warnung modifiziert werden kann.

Andernfalls wird self.dup zurückgegeben, das nicht eingefroren ist.

Verwandt: siehe Einfrieren/Entfrieren.

Gibt einen eingefrorenen String zurück, der mit self identisch ist.

Der zurückgegebene String ist self, wenn und nur wenn alle folgenden Bedingungen erfüllt sind

• self ist bereits eingefroren.

• self ist eine Instanz von String (nicht von einer Unterklasse von String)

• self hat keine Instanzvariablen gesetzt.

Andernfalls ist der zurückgegebene String eine eingefrorene Kopie von self.

Das Zurückgeben von self, wann immer möglich, vermeidet das Duplizieren von self; siehe Data deduplication.

Es kann auch das Duplizieren anderer, bereits vorhandener Strings vermeiden.

s0 = 'foo'
s1 = 'foo'
s0.object_id == s1.object_id       # => false
(-s0).object_id == (-s1).object_id # => true

Beachten Sie, dass die Methode -@ praktisch für die Definition einer Konstante ist.

FileName = -'config/database.yml'

Während ihr Alias dedup besser zum Verketten geeignet ist.

'foo'.dedup.gsub!('o')

Verwandt: siehe Einfrieren/Entfrieren.

Hängt eine String-Repräsentation von object an self an; gibt self zurück.

Wenn object ein String ist, wird er an self angehängt.

s = 'foo'
s << 'bar' # => "foobar"
s          # => "foobar"

Wenn object eine Ganzzahl ist, wird sein Wert als Codepoint betrachtet; der Wert wird in ein Zeichen umgewandelt, bevor er verkettet wird.

s = 'foo'
s << 33 # => "foo!"

Zusätzlich, wenn der Codepoint im Bereich 0..0xff liegt und die Kodierung von self Encoding::US_ASCII ist, wird die Kodierung zu Encoding::ASCII_8BIT geändert.

s = 'foo'.encode(Encoding::US_ASCII)
s.encoding # => #<Encoding:US-ASCII>
s << 0xff  # => "foo\xFF"
s.encoding # => #<Encoding:BINARY (ASCII-8BIT)>

Löst RangeError aus, wenn dieser Codepoint nicht in der Kodierung von self darstellbar ist.

s = 'foo'
s.encoding              # => <Encoding:UTF-8>
s << 0x00110000         # 1114112 out of char range (RangeError)
s = 'foo'.encode(Encoding::EUC_JP)
s << 0x00800080         # invalid codepoint 0x800080 in EUC-JP (RangeError)

Verwandt: siehe Modifizieren.

Vergleicht self und other, indem deren Inhalte und nicht deren Längen ausgewertet werden.

Gibt zurück

• -1, wenn self kleiner ist.

• 0, wenn die beiden gleich sind.

• 1, wenn self größer ist.

• nil, wenn die beiden nicht vergleichbar sind.

Beispiele

'a'  <=> 'b'  # => -1
'a'  <=> 'ab' # => -1
'a'  <=> 'a'  # => 0
'b'  <=> 'a'  # => 1
'ab' <=> 'a'  # => 1
'a'  <=> :a   # => nil

Die Klasse String enthält das Modul Comparable, dessen Methoden alle String#<=> zum Vergleichen verwenden.

Verwandt: siehe Vergleichen.

Gibt zurück, ob object gleich self ist.

Wenn object ein String ist, wird zurückgegeben, ob object die gleiche Länge und denselben Inhalt wie self hat.

s = 'foo'
s == 'foo'  # => true
s == 'food' # => false
s == 'FOO'  # => false

Gibt false zurück, wenn die Kodierungen der beiden Strings nicht kompatibel sind.

"\u{e4 f6 fc}".encode(Encoding::ISO_8859_1) == ("\u{c4 d6 dc}") # => false

Wenn object kein String ist

• Wenn object die Methode to_str unterstützt, wird object == self aufgerufen und dessen Rückgabewert zurückgegeben.

• Wenn object to_str nicht unterstützt, wird false zurückgegeben.

Verwandt: Vergleichen.

Wenn object ein Regexp ist, gibt den Index des ersten von object gefundenen Teilstrings in self zurück oder nil, wenn keine Übereinstimmung gefunden wird; aktualisiert Regexp-bezogene globale Variablen.

'foo' =~ /f/ # => 0
$~           # => #<MatchData "f">
'foo' =~ /o/ # => 1
$~           # => #<MatchData "o">
'foo' =~ /x/ # => nil
$~           # => nil

Beachten Sie, dass string =~ regexp sich von regexp =~ string unterscheidet (siehe Regexp#=~).

number = nil
'no. 9' =~ /(?<number>\d+)/ # => 4
number                      # => nil # Not assigned.
/(?<number>\d+)/ =~ 'no. 9' # => 4
number                      # => "9" # Assigned.

Wenn object kein Regexp ist, wird der Rückgabewert von object =~ self zurückgegeben.

Verwandt: siehe Abfragen.

Gibt den durch die Argumente angegebenen Teilstring von self zurück.

Form self[index]

Mit einem nicht-negativen ganzzahligen Argument index wird der 1-Zeichen-Teilstring in self an der Zeichenposition index zurückgegeben.

'hello'[0]    # => "h"
'hello'[4]    # => "o"
'hello'[5]    # => nil
'Привет'[2]   # => "и"
'こんにちは'[4] # => "は"

Mit einem negativen ganzzahligen Argument index wird vom Ende von self rückwärts gezählt.

'hello'[-1] # => "o"
'hello'[-5] # => "h"
'hello'[-6] # => nil

Form self[start, length]

Mit den ganzzahligen Argumenten start und length wird ein Teilstring der Größe length Zeichen (sofern verfügbar) beginnend bei der durch start angegebenen Zeichenposition zurückgegeben.

Wenn das Argument start nicht-negativ ist, ist der Offset start.

'hello'[0, 1]  # => "h"
'hello'[0, 5]  # => "hello"
'hello'[0, 6]  # => "hello"
'hello'[2, 3]  # => "llo"
'hello'[2, 0]  # => ""
'hello'[2, -1] # => nil

Wenn das Argument start negativ ist, wird vom Ende von self rückwärts gezählt.

'hello'[-1, 1] # => "o"
'hello'[-5, 5] # => "hello"
'hello'[-1, 0] # => ""
'hello'[-6, 5] # => nil

Sonderfall: Wenn start gleich der Länge von self ist, wird ein neuer leerer String zurückgegeben.

'hello'[5, 3]  # => ""

Form self[range]

Mit einem Range-Argument range wird der Teilstring self[range.start, range.size] gebildet.

'hello'[0..2]  # => "hel"
'hello'[0, 3]  # => "hel"

'hello'[0...2] # => "he"
'hello'[0, 2]  # => "he"

'hello'[0, 0]  # => ""
'hello'[0...0] # => ""

Form self[regexp, capture = 0]

Mit einem Regexp-Argument regexp und capture gleich Null wird nach einem übereinstimmenden Teilstring in self gesucht; aktualisiert Regexp-bezogene globale Variablen.

'hello'[/ell/]     # => "ell"
'hello'[/l+/]      # => "ll"
'hello'[//]        # => ""
'hello'[/nosuch/]  # => nil

Wenn capture eine positive ganze Zahl n ist, wird die +n+-te übereinstimmende Gruppe zurückgegeben.

'hello'[/(h)(e)(l+)(o)/]    # => "hello"
'hello'[/(h)(e)(l+)(o)/, 1] # => "h"
$1                          # => "h"
'hello'[/(h)(e)(l+)(o)/, 2] # => "e"
$2                          # => "e"
'hello'[/(h)(e)(l+)(o)/, 3] # => "ll"
'hello'[/(h)(e)(l+)(o)/, 4] # => "o"
'hello'[/(h)(e)(l+)(o)/, 5] # => nil

Form self[substring]

Mit einem String-Argument substring wird der übereinstimmende Teilstring von self zurückgegeben, falls gefunden.

'hello'['ell']      # => "ell"
'hello'['']         # => ""
'hello'['nosuch']   # => nil
'Привет'['ив']      # => "ив"
'こんにちは'['んにち'] # => "んにち"

Verwandt: siehe Konvertierung zu neuem String.

Gibt self mit allen, einem Teilstring oder keinem seiner Inhalte ersetzt zurück; gibt das Argument other_string zurück.

Form self[index] = other_string

Mit einem nicht-negativen ganzzahligen Argument index wird nach dem 1-Zeichen-Teilstring gesucht, der in self an der Zeichenposition index gefunden wird.

s = 'hello'
s[0] = 'foo' # => "foo"
s            # => "fooello"

s = 'hello'
s[4] = 'foo' # => "foo"
s            # => "hellfoo"

s = 'hello'
s[5] = 'foo' # => "foo"
s            # => "hellofoo"

s = 'hello'
s[6] = 'foo' # Raises IndexError: index 6 out of string.

Mit einem negativen ganzzahligen Argument index wird vom Ende von self rückwärts gezählt.

s = 'hello'
s[-1] = 'foo'  # => "foo"
s              # => "hellfoo"

s = 'hello'
s[-5] = 'foo'  # => "foo"
s              # => "fooello"

s = 'hello'
s[-6] = 'foo'  # Raises IndexError: index -6 out of string.

Form self[start, length] = other_string

Mit den ganzzahligen Argumenten start und length wird nach einem Teilstring der Größe length Zeichen (sofern verfügbar) beginnend bei der durch start angegebenen Zeichenposition gesucht.

Wenn das Argument start nicht-negativ ist, ist der Offset start.

s = 'hello'
s[0, 1] = 'foo'  # => "foo"
s                # => "fooello"

s = 'hello'
s[0, 5] = 'foo'  # => "foo"
s                # => "foo"

s = 'hello'
s[0, 9] = 'foo'  # => "foo"
s                # => "foo"

s = 'hello'
s[2, 0] = 'foo'  # => "foo"
s                # => "hefoollo"

s = 'hello'
s[2, -1] = 'foo' # Raises IndexError: negative length -1.

Wenn das Argument start negativ ist, wird vom Ende von self rückwärts gezählt.

s = 'hello'
s[-1, 1] = 'foo' # => "foo"
s                # => "hellfoo"

s = 'hello'
s[-1, 9] = 'foo' # => "foo"
s                # => "hellfoo"

s = 'hello'
s[-5, 2] = 'foo' # => "foo"
s                # => "foollo"

s = 'hello'
s[-3, 0] = 'foo' # => "foo"
s                # => "hefoollo"

s = 'hello'
s[-6, 2] = 'foo' # Raises IndexError: index -6 out of string.

Sonderfall: Wenn start gleich der Länge von self ist, wird das Argument an self angehängt.

s = 'hello'
s[5, 3] = 'foo' # => "foo"
s               # => "hellofoo"

Form self[range] = other_string

Mit einem Range-Argument range ist dies äquivalent zu self[range.start, range.size] = other_string.

s0 = 'hello'
s1 = 'hello'
s0[0..2] = 'foo' # => "foo"
s1[0, 3] = 'foo' # => "foo"
s0               # => "foolo"
s1               # => "foolo"

s = 'hello'
s[0...2] = 'foo' # => "foo"
s                # => "foollo"

s = 'hello'
s[0...0] = 'foo' # => "foo"
s                # => "foohello"

s = 'hello'
s[9..10] = 'foo' # Raises RangeError: 9..10 out of range

Form self[regexp, capture = 0] = other_string

Mit einem Regexp-Argument regexp und capture gleich Null wird nach einem übereinstimmenden Teilstring in self gesucht; aktualisiert Regexp-bezogene globale Variablen.

s = 'hello'
s[/l/] = 'L'       # => "L"
[$`, $&, $']       # => ["he", "l", "lo"]
s[/eLlo/] = 'owdy' # => "owdy"
[$`, $&, $']       # => ["h", "eLlo", ""]
s[/eLlo/] = 'owdy' # Raises IndexError: regexp not matched.
[$`, $&, $']       # => [nil, nil, nil]

Wenn capture eine positive ganze Zahl n ist, wird nach der +n+-ten übereinstimmenden Gruppe gesucht.

s = 'hello'
s[/(h)(e)(l+)(o)/] = 'foo'    # => "foo"
[$`, $&, $']                  # => ["", "hello", ""]

s = 'hello'
s[/(h)(e)(l+)(o)/, 1] = 'foo' # => "foo"
s                             # => "fooello"
[$`, $&, $']                  # => ["", "hello", ""]

s = 'hello'
s[/(h)(e)(l+)(o)/, 2] = 'foo' # => "foo"
s                             # => "hfoollo"
[$`, $&, $']                  # => ["", "hello", ""]

s = 'hello'
s[/(h)(e)(l+)(o)/, 4] = 'foo' # => "foo"
s                             # => "hellfoo"
[$`, $&, $']                  # => ["", "hello", ""]

s = 'hello'
# => "hello"
s[/(h)(e)(l+)(o)/, 5] = 'foo  # Raises IndexError: index 5 out of regexp.

s = 'hello'
s[/nosuch/] = 'foo'           # Raises IndexError: regexp not matched.

Form self[substring] = other_string

Mit einem String-Argument substring

s = 'hello'
s['l'] = 'foo'  # => "foo"
s  # => "hefoolo"

s = 'hello'
s['ll'] = 'foo'  # => "foo"
s  # => "hefooo"

s = 'Привет'
s['ив'] = 'foo'  # => "foo"
s  # => "Прfooет"

s = 'こんにちは'
s['んにち'] = 'foo'  # => "foo"
s  # => "こfooは"

s['nosuch'] = 'foo' # Raises IndexError: string not matched.

Verwandt: siehe Modifizieren.

Verkettet jedes Objekt in objects an self; gibt self zurück; führt keine Kodierungsüberprüfung oder -konvertierung durch.

s = 'foo'
s.append_as_bytes(" \xE2\x82") # => "foo \xE2\x82"
s.valid_encoding?              # => false
s.append_as_bytes("\xAC 12")
s.valid_encoding?              # => true

Wenn ein gegebenes Objekt eine ganze Zahl ist, wird der Wert als 8-Bit-Byte betrachtet; wenn die ganze Zahl mehr als ein Byte belegt (d.h. größer als 255 ist), wird nur das niederwertige Byte angehängt (ähnlich wie bei String#setbyte).

s = ""
s.append_as_bytes(0, 257) # => "\u0000\u0001"
s.bytesize                # => 2

Verwandt: siehe Modifizieren.

Gibt zurück, ob self nur ASCII-Zeichen enthält.

'abc'.ascii_only?         # => true
"abc\u{6666}".ascii_only? # => false

Verwandt: siehe Abfragen.

Gibt eine Kopie von self zurück, die die Kodierung ASCII-8BIT hat; die zugrunde liegenden Bytes werden nicht geändert.

s = "\x99"
s.encoding   # => #<Encoding:UTF-8>
t = s.b      # => "\x99"
t.encoding   # => #<Encoding:ASCII-8BIT>

s = "\u4095" # => "䂕"
s.encoding   # => #<Encoding:UTF-8>
s.bytes      # => [228, 130, 149]
t = s.b      # => "\xE4\x82\x95"
t.encoding   # => #<Encoding:ASCII-8BIT>
t.bytes      # => [228, 130, 149]

Verwandt: siehe Konvertierung zu neuem String.

Gibt den 0-basierten ganzzahligen Index eines Teilstrings von self zurück, der durch object (ein String oder Regexp) und offset angegeben ist, oder nil, wenn kein solcher Teilstring existiert; der zurückgegebene Index ist die Anzahl der Bytes (nicht Zeichen).

Wenn object ein String ist, wird der Index des ersten gefundenen Teilstrings zurückgegeben, der gleich object ist.

s = 'foo'          # => "foo"
s.size             # => 3 # Three 1-byte characters.
s.bytesize         # => 3 # Three bytes.
s.byteindex('f')   # => 0
s.byteindex('o')   # => 1
s.byteindex('oo')  # => 1
s.byteindex('ooo') # => nil

Wenn object ein Regexp ist, wird der Index des ersten gefundenen Teilstrings zurückgegeben, der mit object übereinstimmt; aktualisiert Regexp-bezogene globale Variablen.

s = 'foo'
s.byteindex(/f/)   # => 0
$~                 # => #<MatchData "f">
s.byteindex(/o/)   # => 1
s.byteindex(/oo/)  # => 1
s.byteindex(/ooo/) # => nil
$~                 # => nil

Das ganzzahlige Argument offset gibt, wenn es gegeben ist, den 0-basierten Index des Bytes an, ab dem die Suche beginnen soll.

Wenn offset nicht-negativ ist, beginnt die Suche bei Byte-Position offset.

s = 'foo'
s.byteindex('o', 1) # => 1
s.byteindex('o', 2) # => 2
s.byteindex('o', 3) # => nil

Wenn offset negativ ist, wird vom Ende von self rückwärts gezählt.

s = 'foo'
s.byteindex('o', -1) # => 2
s.byteindex('o', -2) # => 1
s.byteindex('o', -3) # => 1
s.byteindex('o', -4) # => nil

Löst eine IndexError aus, wenn das Byte bei offset nicht das erste Byte eines Zeichens ist.

s = "\uFFFF\uFFFF"       # => "\uFFFF\uFFFF"
s.size                   # => 2 # Two 3-byte characters.
s.bytesize               # => 6 # Six bytes.
s.byteindex("\uFFFF")    # => 0
s.byteindex("\uFFFF", 1) # Raises IndexError
s.byteindex("\uFFFF", 2) # Raises IndexError
s.byteindex("\uFFFF", 3) # => 3
s.byteindex("\uFFFF", 4) # Raises IndexError
s.byteindex("\uFFFF", 5) # Raises IndexError
s.byteindex("\uFFFF", 6) # => nil

Verwandt: siehe Abfragen.

Gibt den 0-basierten ganzzahligen Index eines Teilstrings von self zurück, der die *letzte* Übereinstimmung für das gegebene object (ein String oder Regexp) und offset ist, oder nil, wenn kein solcher Teilstring existiert; der zurückgegebene Index ist die Anzahl der Bytes (nicht Zeichen).

Wenn object ein String ist, wird der Index des *letzten* gefundenen Teilstrings zurückgegeben, der gleich object ist.

s = 'foo'           # => "foo"
s.size              # => 3 # Three 1-byte characters.
s.bytesize          # => 3 # Three bytes.
s.byterindex('f')   # => 0
s.byterindex('o')   # => 2
s.byterindex('oo')  # => 1
s.byterindex('ooo') # => nil

Wenn object ein Regexp ist, wird der Index des letzten gefundenen Teilstrings zurückgegeben, der mit object übereinstimmt; aktualisiert Regexp-bezogene globale Variablen.

s = 'foo'
s.byterindex(/f/)   # => 0
$~                  # => #<MatchData "f">
s.byterindex(/o/)   # => 2
s.byterindex(/oo/)  # => 1
s.byterindex(/ooo/) # => nil
$~                  # => nil

Die letzte Übereinstimmung bedeutet, dass die Suche an der möglicherweise letzten Position beginnt, nicht die letzte der längsten Übereinstimmungen.

s = 'foo'
s.byterindex(/o+/) # => 2
$~                 #=> #<MatchData "o">

Um die letzte längste Übereinstimmung zu erhalten, verwenden Sie eine negative Lookbehind-Assertion.

s = 'foo'
s.byterindex(/(?<!o)o+/) # => 1
$~                       # => #<MatchData "oo">

Oder verwenden Sie die Methode byteindex mit einer negativen Lookahead-Assertion.

s = 'foo'
s.byteindex(/o+(?!.*o)/) # => 1
$~                       #=> #<MatchData "oo">

Das ganzzahlige Argument offset gibt, wenn es gegeben ist, den 0-basierten Index des Bytes an, an dem die Suche enden soll.

Wenn offset nicht-negativ ist, endet die Suche bei Byte-Position offset.

s = 'foo'
s.byterindex('o', 0) # => nil
s.byterindex('o', 1) # => 1
s.byterindex('o', 2) # => 2
s.byterindex('o', 3) # => 2

Wenn offset negativ ist, wird vom Ende von self rückwärts gezählt.

s = 'foo'
s.byterindex('o', -1) # => 2
s.byterindex('o', -2) # => 1
s.byterindex('o', -3) # => nil

Löst eine IndexError aus, wenn das Byte bei offset nicht das erste Byte eines Zeichens ist.

s = "\uFFFF\uFFFF"        # => "\uFFFF\uFFFF"
s.size                    # => 2 # Two 3-byte characters.
s.bytesize                # => 6 # Six bytes.
s.byterindex("\uFFFF")    # => 3
s.byterindex("\uFFFF", 1) # Raises IndexError
s.byterindex("\uFFFF", 2) # Raises IndexError
s.byterindex("\uFFFF", 3) # => 3
s.byterindex("\uFFFF", 4) # Raises IndexError
s.byterindex("\uFFFF", 5) # Raises IndexError
s.byterindex("\uFFFF", 6) # => nil

Verwandt: siehe Abfragen.

Gibt ein Array der Bytes in self zurück.

'hello'.bytes  # => [104, 101, 108, 108, 111]
'Привет'.bytes # => [208, 159, 209, 128, 208, 184, 208, 178, 208, 181, 209, 130]
'こんにちは'.bytes
# => [227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129, 175]

Verwandt: siehe Konvertierung in Nicht-String.

Gibt die Anzahl der Bytes in self zurück.

Beachten Sie, dass die Byte-Anzahl von der Zeichen-Anzahl (zurückgegeben von size) abweichen kann.

s = 'foo'
s.bytesize # => 3
s.size     # => 3
s = 'Привет'
s.bytesize # => 12
s.size     # => 6
s = 'こんにちは'
s.bytesize # => 15
s.size     # => 5

Verwandt: siehe Abfragen.

Gibt einen Teilstring von self zurück oder nil, wenn der Teilstring nicht konstruiert werden kann.

Mit den ganzzahligen Argumenten offset und length wird der Teilstring beginnend bei dem angegebenen offset und mit der angegebenen length (sofern verfügbar) zurückgegeben.

s = '0123456789'   # => "0123456789"
s.byteslice(2)     # => "2"
s.byteslice(200)   # => nil
s.byteslice(4, 3)  # => "456"
s.byteslice(4, 30) # => "456789"

Gibt nil zurück, wenn length negativ ist oder offset außerhalb von self liegt.

s.byteslice(4, -1) # => nil
s.byteslice(40, 2) # => nil

Zählt vom Ende von self rückwärts, wenn offset negativ ist.

s = '0123456789'   # => "0123456789"
s.byteslice(-4)    # => "6"
s.byteslice(-4, 3) # => "678"

Mit einem Range-Argument range wird byteslice(range.begin, range.size) zurückgegeben.

s = '0123456789'    # => "0123456789"
s.byteslice(4..6)   # => "456"
s.byteslice(-6..-4) # => "456"
s.byteslice(5..2)   # => "" # range.size is zero.
s.byteslice(40..42) # => nil

Die Start- und End-Offsets müssen nicht an Zeichengrenzen liegen.

s = 'こんにちは'
s.byteslice(0, 3) # => "こ"
s.byteslice(1, 3) # => "\x81\x93\xE3"

Die Kodierungen von self und dem zurückgegebenen Teilstring sind immer gleich.

s.encoding                 # => #<Encoding:UTF-8>
s.byteslice(0, 3).encoding # => #<Encoding:UTF-8>
s.byteslice(1, 3).encoding # => #<Encoding:UTF-8>

Aber je nach Zeichengrenzen ist die Kodierung des zurückgegebenen Teilstrings möglicherweise nicht gültig.

s.valid_encoding?                 # => true
s.byteslice(0, 3).valid_encoding? # => true
s.byteslice(1, 3).valid_encoding? # => false

Verwandt: siehe Konvertierung zu neuem String.

Ersetzt *Ziel-Bytes* in self durch *Quell-Bytes* aus dem gegebenen String str; gibt self zurück.

In der ersten Form bestimmen die Argumente offset und length die Ziel-Bytes, und die Quell-Bytes sind alle aus dem gegebenen str.

'0123456789'.bytesplice(0, 3, 'abc')  # => "abc3456789"
'0123456789'.bytesplice(3, 3, 'abc')  # => "012abc6789"
'0123456789'.bytesplice(0, 50, 'abc') # => "abc"
'0123456789'.bytesplice(50, 3, 'abc') # Raises IndexError.

Die Anzahl der Ziel-Bytes und Quell-Bytes kann unterschiedlich sein.

'0123456789'.bytesplice(0, 6, 'abc') # => "abc6789"      # Shorter source.
'0123456789'.bytesplice(0, 1, 'abc') # => "abc123456789" # Shorter target.

Und jede Anzahl kann Null sein (d.h. einen leeren String angeben).

'0123456789'.bytesplice(0, 3, '')    # => "3456789"       # Empty source.
'0123456789'.bytesplice(0, 0, 'abc') # => "abc0123456789" # Empty target.

In der zweiten Form, genau wie in der ersten, bestimmen die Argumente offset und length die Ziel-Bytes; das Argument str *enthält* die Quell-Bytes, und die zusätzlichen Argumente str_offset und str_length bestimmen die tatsächlichen Quell-Bytes.

'0123456789'.bytesplice(0, 3, 'abc', 0, 3) # => "abc3456789"
'0123456789'.bytesplice(0, 3, 'abc', 1, 1) # => "b3456789"      # Shorter source.
'0123456789'.bytesplice(0, 1, 'abc', 0, 3) # => "abc123456789"  # Shorter target.
'0123456789'.bytesplice(0, 3, 'abc', 1, 0) # => "3456789"       # Empty source.
'0123456789'.bytesplice(0, 0, 'abc', 0, 3) # => "abc0123456789" # Empty target.

In der dritten Form bestimmt das Argument range die Ziel-Bytes, und die Quell-Bytes sind alle aus dem gegebenen str.

'0123456789'.bytesplice(0..2, 'abc')  # => "abc3456789"
'0123456789'.bytesplice(3..5, 'abc')  # => "012abc6789"
'0123456789'.bytesplice(0..5, 'abc')  # => "abc6789"       # Shorter source.
'0123456789'.bytesplice(0..0, 'abc')  # => "abc123456789"  # Shorter target.
'0123456789'.bytesplice(0..2, '')     # => "3456789"       # Empty source.
'0123456789'.bytesplice(0...0, 'abc') # => "abc0123456789" # Empty target.

In der vierten Form, genau wie in der dritten, bestimmt das Argument range die Ziel-Bytes; das Argument str *enthält* die Quell-Bytes, und das zusätzliche Argument str_range bestimmt die tatsächlichen Quell-Bytes.

'0123456789'.bytesplice(0..2, 'abc', 0..2)  # => "abc3456789"
'0123456789'.bytesplice(3..5, 'abc', 0..2)  # => "012abc6789"
'0123456789'.bytesplice(0..2, 'abc', 0..1)  # => "ab3456789"     # Shorter source.
'0123456789'.bytesplice(0..1, 'abc', 0..2)  # => "abc23456789"   # Shorter target.
'0123456789'.bytesplice(0..2, 'abc', 0...0) # => "3456789"       # Empty source.
'0123456789'.bytesplice(0...0, 'abc', 0..2) # => "abc0123456789" # Empty target.

In jeder der Formen müssen die Anfänge und Enden von Quelle und Ziel an Zeichengrenzen liegen.

In diesen Beispielen hat self fünf 3-Byte-Zeichen und somit Zeichengrenzen bei den Offsets 0, 3, 6, 9, 12 und 15.

'こんにちは'.bytesplice(0, 3, 'abc') # => "abcんにちは"
'こんにちは'.bytesplice(1, 3, 'abc') # Raises IndexError.
'こんにちは'.bytesplice(0, 2, 'abc') # Raises IndexError.

Gibt einen String zurück, der die Zeichen in self enthält, jeweils mit möglicherweise geänderter Groß-/Kleinschreibung.

• Das erste Zeichen wird großgeschrieben.

• Alle anderen Zeichen werden kleingeschrieben.

Beispiele

'hello'.capitalize  # => "Hello"
'HELLO'.capitalize  # => "Hello"
'straße'.capitalize # => "Straße"  # Lowercase 'ß' not changed.
'STRAẞE'.capitalize # => "Straße"  # Uppercase 'ẞ' downcased to 'ß'.
'привет'.capitalize # => "Привет"
'ПРИВЕТ'.capitalize # => "Привет"

Einige Zeichen (und einige Zeichensätze) haben keine Groß-/Kleinschreibungs-Versionen; siehe Case Mapping.

s = '1, 2, 3, ...'
s.capitalize == s # => true
s = 'こんにちは'
s.capitalize == s # => true

Die Groß-/Kleinschreibung wird von der angegebenen mapping beeinflusst, die :ascii, :fold oder :turkic sein kann; siehe Case Mappings.

Verwandt: siehe Konvertierung zu neuem String.

Wie String#capitalize, außer dass

• die Zeichengroß-/Kleinschreibung in self (nicht in einer Kopie von self) geändert wird.

• self zurückgegeben wird, wenn Änderungen vorgenommen werden, andernfalls nil.

Verwandt: Siehe Ändern.

Ignoriert Groß-/Kleinschreibung, vergleicht self und other_string; gibt zurück:

• -1, wenn self.downcase kleiner als other_string.downcase ist.

• 0, wenn die beiden gleich sind.

• 1, wenn self.downcase größer als other_string.downcase ist.

• nil, wenn die beiden nicht vergleichbar sind.

Siehe Case Mapping.

Beispiele

'foo'.casecmp('goo')  # => -1
'goo'.casecmp('foo')  # => 1
'foo'.casecmp('food') # => -1
'food'.casecmp('foo') # => 1
'FOO'.casecmp('foo')  # => 0
'foo'.casecmp('FOO')  # => 0
'foo'.casecmp(1)      # => nil

Verwandt: siehe Vergleichen.

Gibt true zurück, wenn self und other_string nach Unicode-Case-Faltung gleich sind, false, wenn sie ungleich sind, nil, wenn sie nicht vergleichbar sind.

Siehe Case Mapping.

Beispiele

'foo'.casecmp?('goo')  # => false
'goo'.casecmp?('foo')  # => false
'foo'.casecmp?('food') # => false
'food'.casecmp?('foo') # => false
'FOO'.casecmp?('foo')  # => true
'foo'.casecmp?('FOO')  # => true
'foo'.casecmp?(1)      # => nil

Verwandt: siehe Vergleichen.

Gibt eine zentrierte Kopie von self zurück.

Wenn das ganzzahlige Argument size größer ist als die Größe (in Zeichen) von self, wird ein neuer String der Länge size zurückgegeben, der eine Kopie von self ist, zentriert und auf einer oder beiden Seiten mit pad_string aufgefüllt ist.

'hello'.center(6)             # => "hello "               # Padded on one end.
'hello'.center(10)            # => "  hello   "           # Padded on both ends.
'hello'.center(20, '-|')      # => "-|-|-|-hello-|-|-|-|" # Some padding repeated.
'hello'.center(10, 'abcdefg') # => "abhelloabc"           # Some padding not used.
'  hello  '.center(13)        # => "    hello    "
'Привет'.center(10)           # => "  Привет  "
'こんにちは'.center(10)         # => "  こんにちは   "      # Multi-byte characters.

Wenn size kleiner oder gleich der Größe von self ist, wird eine ungefüllte Kopie von self zurückgegeben.

'hello'.center(5)   # => "hello"
'hello'.center(-10) # => "hello"

Verwandt: siehe Konvertierung zu neuem String.

Gibt ein Array der Zeichen in self zurück.

'hello'.chars     # => ["h", "e", "l", "l", "o"]
'Привет'.chars    # => ["П", "р", "и", "в", "е", "т"]
'こんにちは'.chars # => ["こ", "ん", "に", "ち", "は"]
''.chars          # => []

Verwandt: siehe Konvertierung in Nicht-String.

Gibt einen neuen String zurück, der von self kopiert wurde, wobei nachfolgende Zeichen möglicherweise entfernt wurden.

Wenn line_sep "\n" ist, werden das letzte ein oder zwei Zeichen entfernt, wenn sie "\r", "\n" oder "\r\n" sind (aber nicht "\n\r").

$/                    # => "\n"
"abc\r".chomp         # => "abc"
"abc\n".chomp         # => "abc"
"abc\r\n".chomp       # => "abc"
"abc\n\r".chomp       # => "abc\n"
"тест\r\n".chomp      # => "тест"
"こんにちは\r\n".chomp  # => "こんにちは"

Wenn line_sep '' (ein leerer String) ist, werden mehrere nachfolgende Vorkommen von "\n" oder "\r\n" entfernt (aber nicht "\r" oder "\n\r").

"abc\n\n\n".chomp('')           # => "abc"
"abc\r\n\r\n\r\n".chomp('')     # => "abc"
"abc\n\n\r\n\r\n\n\n".chomp('') # => "abc"
"abc\n\r\n\r\n\r".chomp('')     # => "abc\n\r\n\r\n\r"
"abc\r\r\r".chomp('')           # => "abc\r\r\r"

Wenn line_sep weder "\n" noch '' ist, wird ein einzelner nachfolgender Zeilentrenner entfernt, falls vorhanden.

'abcd'.chomp('cd')   # => "ab"
'abcdcd'.chomp('cd') # => "abcd"
'abcd'.chomp('xx')   # => "abcd"

Verwandt: siehe Konvertierung zu neuem String.

Wie String#chomp, außer dass

• nachfolgende Zeichen aus self entfernt werden (nicht aus einer Kopie von self).

• self zurückgegeben wird, wenn Zeichen entfernt werden, andernfalls nil.

Verwandt: siehe Modifizieren.

Gibt einen neuen String zurück, der von self kopiert wurde, wobei nachfolgende Zeichen möglicherweise entfernt wurden.

Entfernt "\r\n", wenn dies die letzten beiden Zeichen sind.

"abc\r\n".chop      # => "abc"
"тест\r\n".chop     # => "тест"
"こんにちは\r\n".chop # => "こんにちは"

Andernfalls wird das letzte Zeichen entfernt, wenn es vorhanden ist.

'abcd'.chop     # => "abc"
'тест'.chop     # => "тес"
'こんにちは'.chop # => "こんにち"
''.chop         # => ""

Wenn Sie nur den Zeilentrennzeichen am Ende des Strings entfernen müssen, ist String#chomp eine bessere Alternative.

Verwandt: siehe Konvertierung zu neuem String.

Wie String#chop, außer dass

• nachfolgende Zeichen aus self entfernt werden (nicht aus einer Kopie von self).

• self zurückgegeben wird, wenn Zeichen entfernt werden, andernfalls nil.

Verwandt: siehe Modifizieren.

Gibt einen String zurück, der das erste Zeichen von self enthält.

'hello'.chr     # => "h"
'тест'.chr      # => "т"
'こんにちは'.chr # => "こ"
''.chr          # => ""

Verwandt: siehe Konvertierung zu neuem String.

Entfernt den Inhalt von self.

s = 'foo'
s.clear # => ""
s       # => ""

Verwandt: siehe Modifizieren.

Gibt ein Array der Codepunkte in self zurück; jeder Codepunkt ist der ganzzahlige Wert für ein Zeichen.

'hello'.codepoints     # => [104, 101, 108, 108, 111]
'тест'.codepoints      # => [1090, 1077, 1089, 1090]
'こんにちは'.codepoints # => [12371, 12435, 12395, 12385, 12399]
''.codepoints          # => []

Verwandt: siehe Konvertierung in Nicht-String.

Verkettet jedes Objekt in objects an self; gibt self zurück.

'foo'.concat('bar', 'baz') # => "foobarbaz"

Für jedes gegebene Objekt object, das eine ganze Zahl ist, wird der Wert als Codepunkt betrachtet und vor der Verkettung in ein Zeichen umgewandelt.

'foo'.concat(32, 'bar', 32, 'baz') # => "foo bar baz" # Embeds spaces.
'те'.concat(1089, 1090)            # => "тест"
'こん'.concat(12395, 12385, 12399)  # => "こんにちは"

Verwandt: siehe Konvertierung zu neuem String.

Gibt die Gesamtzahl der Zeichen in self zurück, die durch die gegebenen Selektoren angegeben sind.

Für einen 1-Zeichen-Selektor wird die Anzahl der Vorkommen dieses Zeichens zurückgegeben.

s = 'abracadabra'
s.count('a') # => 5
s.count('b') # => 2
s.count('x') # => 0
s.count('')  # => 0

s = 'тест'
s.count('т')  # => 2
s.count('е')  # => 1

s = 'よろしくお願いします'
s.count('よ')  # => 1
s.count('し')  # => 2

Für einen Mehrzeichen-Selektor wird die Anzahl der Vorkommen für alle angegebenen Zeichen zurückgegeben.

s = 'abracadabra'
s.count('ab')     # => 7
s.count('abc')    # => 8
s.count('abcd')   # => 9
s.count('abcdr')  # => 11
s.count('abcdrx') # => 11

Reihenfolge und Wiederholung spielen keine Rolle.

s.count('ba')   == s.count('ab') # => true
s.count('baab') == s.count('ab') # => true

Für mehrere Selektoren wird ein einziger Selektor gebildet, der die Schnittmenge der Zeichen in allen Selektoren ist, und die Anzahl der Vorkommen für diesen Selektor wird zurückgegeben.

s = 'abcdefg'
s.count('abcde', 'dcbfg') == s.count('bcd') # => true
s.count('abc', 'def')     == s.count('')    # => true

In einem Zeichenselektor werden drei Zeichen besonders behandelt.

• Ein Caret ('^') fungiert als Negationsoperator für die unmittelbar folgenden Zeichen.

  s = 'abracadabra'
  s.count('^bc') # => 8  # Count of all except 'b' and 'c'.
  

• Ein Bindestrich ('-') zwischen zwei anderen Zeichen definiert einen Bereich von Zeichen.

  s = 'abracadabra'
  s.count('a-c') # => 8  # Count of all 'a', 'b', and 'c'.
  

• Ein Backslash ('\') dient als Escape-Zeichen für einen Caret, einen Bindestrich oder einen anderen Backslash.

  s = 'abracadabra'
  s.count('\^bc')           # => 3  # Count of '^', 'b', and 'c'.
  s.count('a\-c')           # => 6  # Count of 'a', '-', and 'c'.
  'foo\bar\baz'.count('\\') # => 2  # Count of '\'.
  

Diese Verwendungen können gemischt werden.

s = 'abracadabra'
s.count('a-cq-t') # => 10  # Multiple ranges.
s.count('ac-d')   # => 7   # Range mixed with plain characters.
s.count('^a-c')   # => 3   # Range mixed with negation.

Für mehrere Selektoren können alle Formen verwendet werden, einschließlich Negationen, Bereiche und Escapes.

s = 'abracadabra'
s.count('^abc', '^def') == s.count('^abcdef') # => true
s.count('a-e', 'c-g')   == s.count('cde')     # => true
s.count('^abc', 'c-g')  == s.count('defg')    # => true

Verwandt: siehe Abfragen.

Gibt den String zurück, der durch Aufruf der Standardbibliotheksfunktion crypt(3) mit str und salt_str in dieser Reihenfolge als Argumente generiert wurde. Bitte verwenden Sie diese Methode nicht mehr. Sie ist veraltet und nur zur Abwärtskompatibilität mit Ruby-Skripten aus früheren Zeiten vorhanden. Sie ist aus mehreren Gründen schlecht für die Verwendung in zeitgenössischen Programmen.

• Das Verhalten von C's crypt(3) hängt vom Betriebssystem ab, auf dem es ausgeführt wird. Der generierte String hat keine Datenportabilität.

• Auf einigen Betriebssystemen wie Mac OS schlägt crypt(3) nie fehl (d.h. es kommt stillschweigend zu unerwarteten Ergebnissen).

• Auf einigen Betriebssystemen wie Mac OS ist crypt(3) nicht Thread-sicher.

• Die sogenannte "traditionelle" Verwendung von crypt(3) ist sehr, sehr, sehr schwach. Laut seiner Manpage hat die traditionelle crypt(3)-Ausgabe von Linux nur 2**56 Variationen; heute zu leicht zu bruteforcen. Und das ist das Standardverhalten.

• Um Dinge robust zu machen, implementieren einige Betriebssysteme die sogenannte "modulare" Verwendung. Um dies zu erreichen, müssen Sie eine komplexe Erstellung des Parameters salt_str manuell durchführen. Fehler bei der Erstellung eines richtigen Salt-Strings führen tendenziell nicht zu Fehlern; Tippfehler in Parametern sind normalerweise nicht erkennbar.

  • Zum Beispiel ist im folgenden Beispiel der zweite Aufruf von String#crypt falsch; er hat einen Tippfehler in "round=" (fehlt "s"). Der Aufruf schlägt jedoch nicht fehl und etwas Unerwartetes wird generiert.

    "foo".crypt("$5$rounds=1000$salt$") # OK, proper usage
    "foo".crypt("$5$round=1000$salt$")  # Typo not detected
    

• Selbst im "modularen" Modus gelten einige Hash-Funktionen als archaisch und werden überhaupt nicht mehr empfohlen; zum Beispiel wird das Modul $1$ offiziell von seinem Autor aufgegeben: siehe phk.freebsd.dk/sagas/md5crypt_eol/ . Ein weiteres Beispiel ist das Modul $3$, das als völlig fehlerhaft gilt: siehe die Manpage von FreeBSD.

• Auf einigen Betriebssystemen wie Mac OS gibt es keinen modularen Modus. Dennoch, wie oben geschrieben, schlägt crypt(3) auf Mac OS nie fehl. Das bedeutet, selbst wenn Sie einen richtigen Salt-String erstellen, wird trotzdem ein traditioneller DES-Hash generiert, und es gibt keine Möglichkeit, dies zu erkennen.

  "foo".crypt("$5$rounds=1000$salt$") # => "$5fNPQMxC5j6."
  

Wenn Sie aus irgendeinem Grund nicht zu anderen sicheren zeitgenössischen Passwort-Hashing-Algorithmen migrieren können, installieren Sie das Gem string-crypt und require 'string/crypt', um es weiterhin zu verwenden.

Gibt einen neuen String zurück, der eine Kopie von self ist, wobei bestimmte Zeichen entfernt wurden; die entfernten Zeichen sind alle Vorkommen der durch den gegebenen String selectors angegebenen Zeichen.

Für einen 1-Zeichen-Selektor werden alle Vorkommen dieses Zeichens entfernt.

s = 'abracadabra'
s.delete('a') # => "brcdbr"
s.delete('b') # => "aracadara"
s.delete('x') # => "abracadabra"
s.delete('')  # => "abracadabra"

s = 'тест'
s.delete('т') # => "ес"
s.delete('е') # => "тст"

s = 'よろしくお願いします'
s.delete('よ') # => "ろしくお願いします"
s.delete('し') # => "よろくお願います"

Für einen Mehrzeichen-Selektor werden alle Vorkommen der angegebenen Zeichen entfernt.

s = 'abracadabra'
s.delete('ab')     # => "rcdr"
s.delete('abc')    # => "rdr"
s.delete('abcd')   # => "rr"
s.delete('abcdr')  # => ""
s.delete('abcdrx') # => ""

Reihenfolge und Wiederholung spielen keine Rolle.

s.delete('ba')   == s.delete('ab') # => true
s.delete('baab') == s.delete('ab') # => true

Für mehrere Selektoren wird ein einziger Selektor gebildet, der die Schnittmenge der Zeichen in allen Selektoren ist, und alle Vorkommen der durch diesen Selektor angegebenen Zeichen werden entfernt.

s = 'abcdefg'
s.delete('abcde', 'dcbfg') == s.delete('bcd') # => true
s.delete('abc', 'def')     == s.delete('')    # => true

In einem Zeichenselektor werden drei Zeichen besonders behandelt.

• Ein Caret ('^') fungiert als Negationsoperator für die unmittelbar folgenden Zeichen.

  s = 'abracadabra'
  s.delete('^bc') # => "bcb"  # Deletes all except 'b' and 'c'.
  

• Ein Bindestrich ('-') zwischen zwei anderen Zeichen definiert einen Bereich von Zeichen.

  s = 'abracadabra'
  s.delete('a-c') # => "rdr"  # Deletes all 'a', 'b', and 'c'.
  

• Ein Backslash ('\') dient als Escape-Zeichen für einen Caret, einen Bindestrich oder einen anderen Backslash.

  s = 'abracadabra'
  s.delete('\^bc')           # => "araadara"   # Deletes all '^', 'b', and 'c'.
  s.delete('a\-c')           # => "brdbr"      # Deletes all 'a', '-', and 'c'.
  'foo\bar\baz'.delete('\\') # => "foobarbaz"  # Deletes all '\'.
  

Diese Verwendungen können gemischt werden.

s = 'abracadabra'
s.delete('a-cq-t') # => "d"         # Multiple ranges.
s.delete('ac-d')   # => "brbr"      # Range mixed with plain characters.
s.delete('^a-c')   # => "abacaaba"  # Range mixed with negation.

Für mehrere Selektoren können alle Formen verwendet werden, einschließlich Negationen, Bereiche und Escapes.

s = 'abracadabra'
s.delete('^abc', '^def') == s.delete('^abcdef') # => true
s.delete('a-e', 'c-g')   == s.delete('cde')     # => true
s.delete('^abc', 'c-g')  == s.delete('defg')    # => true

Verwandt: siehe Konvertierung zu neuem String.

Wie String#delete, aber modifiziert self direkt; gibt self zurück, wenn Zeichen gelöscht wurden, andernfalls nil.

Verwandt: siehe Modifizieren.

Gibt eine Kopie von self zurück, bei der der führende Teilstring prefix entfernt wurde.

'oof'.delete_prefix('o')          # => "of"
'oof'.delete_prefix('oo')         # => "f"
'oof'.delete_prefix('oof')        # => ""
'oof'.delete_prefix('x')          # => "oof"
'тест'.delete_prefix('те')        # => "ст"
'こんにちは'.delete_prefix('こん')  # => "にちは"

Verwandt: siehe Konvertierung zu neuem String.

Wie String#delete_prefix, außer dass self direkt modifiziert wird; gibt self zurück, wenn das Präfix entfernt wird, andernfalls nil.

Verwandt: siehe Modifizieren.

Gibt eine Kopie von self zurück, bei der der nachfolgende Teilstring suffix entfernt wurde.

'foo'.delete_suffix('o')           # => "fo"
'foo'.delete_suffix('oo')          # => "f"
'foo'.delete_suffix('foo')         # => ""
'foo'.delete_suffix('f')           # => "foo"
'foo'.delete_suffix('x')           # => "foo"
'тест'.delete_suffix('ст')         # => "те"
'こんにちは'.delete_suffix('ちは')  # => "こんに"

Verwandt: siehe Konvertierung zu neuem String.

Wie String#delete_suffix, außer dass self direkt modifiziert wird; gibt self zurück, wenn das Suffix entfernt wird, andernfalls nil.

Verwandt: siehe Modifizieren.

Gibt einen neuen String zurück, der die kleingeschriebenen Zeichen in self enthält.

'HELLO'.downcase        # => "hello"
'STRAẞE'.downcase       # => "straße"
'ПРИВЕТ'.downcase       # => "привет"
'RubyGems.org'.downcase # => "rubygems.org"

Einige Zeichen (und einige Zeichensätze) haben keine Groß-/Kleinschreibungs-Versionen; siehe Case Mapping.

s = '1, 2, 3, ...'
s.downcase == s # => true
s = 'こんにちは'
s.downcase == s # => true

Die Groß-/Kleinschreibung wird von der angegebenen mapping beeinflusst, die :ascii, :fold oder :turkic sein kann; siehe Case Mappings.

Verwandt: siehe Konvertierung zu neuem String.

Wie String#downcase, außer dass

• die Zeichengroß-/Kleinschreibung in self (nicht in einer Kopie von self) geändert wird.

• self zurückgegeben wird, wenn Änderungen vorgenommen werden, andernfalls nil.

Verwandt: Siehe Ändern.

Für einen gewöhnlichen String gibt diese Methode, +String#dump+, eine druckbare, nur-ASCII-Version von self zurück, eingeschlossen in doppelte Anführungszeichen.

Für einen gedumpten String ist die Methode String#undump die Umkehrung von +String#dump+; sie gibt eine "wiederhergestellte" Version von self zurück, bei der alle Dump-Änderungen rückgängig gemacht wurden.

Im einfachsten Fall enthält der gedumpte String den ursprünglichen String, eingeschlossen in doppelte Anführungszeichen; dieses Beispiel wird in irb (interactive Ruby) gezeigt, das die Methode 'inspect` verwendet, um die Ergebnisse darzustellen.

s = 'hello'   # => "hello"
s.dump        # => "\"hello\""
s.dump.undump # => "hello"

Beachten Sie, dass in der zweiten Zeile oben

• die äußeren doppelten Anführungszeichen von inspect gesetzt werden und nicht Teil der Ausgabe von dump sind.

• Die inneren doppelten Anführungszeichen sind Teil der Ausgabe von dump und werden von inspect escaped, da sie sich innerhalb der äußeren doppelten Anführungszeichen befinden.

Um Verwirrung zu vermeiden, verwenden wir diese Hilfsmethode, um die äußeren doppelten Anführungszeichen wegzulassen.

def dump(s)
  print "String:   ", s, "\n"
  print "Dumped:   ", s.dump, "\n"
  print "Undumped: ", s.dump.undump, "\n"
end

So dass wir für den String 'hello' Folgendes sehen:

String:    hello
Dumped:    "hello"
Undumped:  hello

In einem Dump werden bestimmte Sonderzeichen escaped.

String:    "
Dumped:    "\""
Undumped:  "

String:    \
Dumped:    "\\"
Undumped:  \

In einem Dump werden nicht druckbare Zeichen durch druckbare ersetzt; die nicht druckbaren Zeichen sind die Leerzeichen (außer dem Leerzeichen selbst); hier sehen wir die Ordinalwerte für diese Zeichen zusammen mit erklärendem Text.

h = {
   7 => 'Alert (BEL)',
   8 => 'Backspace (BS)',
   9 => 'Horizontal tab (HT)',
  10 => 'Linefeed (LF)',
  11 => 'Vertical tab (VT)',
  12 => 'Formfeed (FF)',
  13 => 'Carriage return (CR)'
}

In diesem Beispiel wird die gedumpte Ausgabe von der Methode inspect ausgegeben und enthält daher sowohl äußere doppelte Anführungszeichen als auch escaped innere doppelte Anführungszeichen.

s = ''
h.keys.each {|i| s << i } # => [7, 8, 9, 10, 11, 12, 13]
s                         # => "\a\b\t\n\v\f\r"
s.dump                    # => "\"\\a\\b\\t\\n\\v\\f\\r\""

Wenn self in UTF-8 kodiert ist und Unicode-Zeichen enthält, wird jedes Unicode-Zeichen als Unicode-Escape-Sequenz gedumpt.

String:    тест
Dumped:    "\u0442\u0435\u0441\u0442"
Undumped:  тест

String:    こんにちは
Dumped:    "\u3053\u3093\u306B\u3061\u306F"
Undumped:  こんにちは

Wenn die Kodierung von self nicht ASCII-kompatibel ist (d.h. wenn self.encoding.ascii_compatible? false zurückgibt), wird jedes ASCII-kompatible Byte als ASCII-Zeichen gedumpt, und alle anderen Bytes werden als Hexadezimalwerte gedumpt; außerdem wird .dup.force_encoding(\"encoding\") angehängt, wobei <encoding> self.encoding.name ist.

String:    hello
Dumped:    "\xFE\xFF\x00h\x00e\x00l\x00l\x00o".dup.force_encoding("UTF-16")
Undumped:  hello

String:    тест
Dumped:    "\xFE\xFF\x04B\x045\x04A\x04B".dup.force_encoding("UTF-16")
Undumped:  тест

String:    こんにちは
Dumped:    "\xFE\xFF0S0\x930k0a0o".dup.force_encoding("UTF-16")
Undumped:  こんにちは

Mit einem Block wird der Block mit jedem aufeinanderfolgenden Byte aus self aufgerufen; gibt self zurück.

a = []
'hello'.each_byte {|byte| a.push(byte) }     # Five 1-byte characters.
a # => [104, 101, 108, 108, 111]
a = []
'тест'.each_byte {|byte| a.push(byte) }      # Four 2-byte characters.
a # => [209, 130, 208, 181, 209, 129, 209, 130]
a = []
'こんにちは'.each_byte {|byte| a.push(byte) }  # Five 3-byte characters.
a # => [227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129, 175]

Ohne Block wird ein Enumerator zurückgegeben.

Verwandt: siehe Iterieren.

Mit einem Block wird der Block mit jedem aufeinanderfolgenden Zeichen aus self aufgerufen; gibt self zurück.

a = []
'hello'.each_char do |char|
  a.push(char)
end
a # => ["h", "e", "l", "l", "o"]
a = []
'тест'.each_char do |char|
  a.push(char)
end
a # => ["т", "е", "с", "т"]
a = []
'こんにちは'.each_char do |char|
  a.push(char)
end
a # => ["こ", "ん", "に", "ち", "は"]

Ohne Block wird ein Enumerator zurückgegeben.

Verwandt: siehe Iterieren.

Mit einem Block wird der Block mit jedem aufeinanderfolgenden Codepunkt aus self aufgerufen; jeder Codepunkt ist der ganzzahlige Wert für ein Zeichen; gibt self zurück.

a = []
'hello'.each_codepoint do |codepoint|
  a.push(codepoint)
end
a # => [104, 101, 108, 108, 111]
a = []
'тест'.each_codepoint do |codepoint|
  a.push(codepoint)
end
a # => [1090, 1077, 1089, 1090]
a = []
'こんにちは'.each_codepoint do |codepoint|
  a.push(codepoint)
end
a # => [12371, 12435, 12395, 12385, 12399]

Ohne Block wird ein Enumerator zurückgegeben.

Verwandt: siehe Iterieren.

Mit einem Block wird der gegebene Block mit jedem aufeinanderfolgenden Graphem-Cluster aus self aufgerufen (siehe Unicode Grapheme Cluster Boundaries); gibt self zurück.

a = []
'hello'.each_grapheme_cluster do |grapheme_cluster|
  a.push(grapheme_cluster)
end
a  # => ["h", "e", "l", "l", "o"]

a = []
'тест'.each_grapheme_cluster do |grapheme_cluster|
  a.push(grapheme_cluster)
end
a # => ["т", "е", "с", "т"]

a = []
'こんにちは'.each_grapheme_cluster do |grapheme_cluster|
  a.push(grapheme_cluster)
end
a # => ["こ", "ん", "に", "ち", "は"]

Ohne Block wird ein Enumerator zurückgegeben.

Verwandt: siehe Iterieren.

Mit einem Block werden die Teilstrings (Zeilen) gebildet, die sich aus dem Aufteilen von self an jedem Vorkommen des gegebenen record_separator ergeben; jede Zeile wird an den Block übergeben; gibt self zurück.

Mit den Standard-record_separator-Argumentwerten

$/ # => "\n"
s = <<~EOT
This is the first line.
This is line two.

This is line four.
This is line five.
EOT
s.each_line {|line| p line }

Ausgabe

"This is the first line.\n"
"This is line two.\n"
"\n"
"This is line four.\n"
"This is line five.\n"

Mit einem anderen record_separator

record_separator = ' is '
s.each_line(record_separator) {|line| p line }

Ausgabe

"This is "
"the first line.\nThis is "
"line two.\n\nThis is "
"line four.\nThis is "
"line five.\n"

Mit chomp als true werden die nachfolgenden record_separator von jeder Zeile entfernt.

s.each_line(chomp: true) {|line| p line }

Ausgabe

"This is the first line."
"This is line two."
""
"This is line four."
"This is line five."

Mit einem leeren String als record_separator werden "Paragraphen" gebildet, indem an jedem Vorkommen von zwei oder mehr Zeilenumbrüchen aufgeteilt wird.

record_separator = ''
s.each_line(record_separator) {|line| p line }

Ausgabe

"This is the first line.\nThis is line two.\n\n"
"This is line four.\nThis is line five.\n"

Ohne Block wird ein Enumerator zurückgegeben.

Verwandt: siehe Iterieren.

Gibt zurück, ob die Länge von self null ist.

'hello'.empty? # => false
' '.empty? # => false
''.empty? # => true

Verwandt: siehe Abfragen.

Gibt eine Kopie von self zurück, die gemäß dst_encoding transkodiert wurde; siehe Encodings.

Standardmäßig wird eine Ausnahme ausgelöst, wenn self ein ungültiges Byte oder ein Zeichen enthält, das nicht in dst_encoding definiert ist; dieses Verhalten kann durch Kodierungsoptionen geändert werden; siehe unten.

Ohne Argumente

• Verwendet die gleiche Kodierung, wenn Encoding.default_internal nil (Standard) ist.

  Encoding.default_internal # => nil
  s = "Ruby\x99".force_encoding('Windows-1252')
  s.encoding                # => #<Encoding:Windows-1252>
  s.bytes                   # => [82, 117, 98, 121, 153]
  t = s.encode              # => "Ruby\x99"
  t.encoding                # => #<Encoding:Windows-1252>
  t.bytes                   # => [82, 117, 98, 121, 226, 132, 162]
  

• Andernfalls wird die Kodierung Encoding.default_internal verwendet.

  Encoding.default_internal = 'UTF-8'
  t = s.encode              # => "Ruby™"
  t.encoding                # => #<Encoding:UTF-8>
  

Nur mit dem Argument dst_encoding wird diese Kodierung verwendet.

s = "Ruby\x99".force_encoding('Windows-1252')
s.encoding            # => #<Encoding:Windows-1252>
t = s.encode('UTF-8') # => "Ruby™"
t.encoding            # => #<Encoding:UTF-8>

Mit den Argumenten dst_encoding und src_encoding wird self mit src_encoding interpretiert und der neue String mit dst_encoding kodiert.

s = "Ruby\x99"
t = s.encode('UTF-8', 'Windows-1252') # => "Ruby™"
t.encoding                            # => #<Encoding:UTF-8>

Optionale Schlüsselwortargumente enc_opts geben Kodierungsoptionen an; siehe Encoding Options.

Bitte beachten Sie, dass die Konvertierung von einer Kodierung enc in dieselbe Kodierung enc (unabhängig davon, ob enc explizit oder implizit angegeben ist) eine No-Operation ist, d.h. der String wird einfach ohne Änderungen kopiert und es werden keine Ausnahmen ausgelöst, es sei denn, die Option invalid: :replace wird angegeben, auch wenn ungültige Bytes vorhanden sind.

Verwandt: siehe Konvertierung zu neuem String.

Wie encode, aber wendet Kodierungsänderungen auf self an; gibt self zurück.

Verwandt: siehe Modifizieren.

Gibt ein Encoding-Objekt zurück, das die Kodierung von self repräsentiert; siehe Encodings.

Verwandt: siehe Abfragen.

Gibt zurück, ob self mit einem der gegebenen strings endet.

'foo'.end_with?('oo')         # => true
'foo'.end_with?('bar', 'oo')  # => true
'foo'.end_with?('bar', 'baz') # => false
'foo'.end_with?('')           # => true
'тест'.end_with?('т')         # => true
'こんにちは'.end_with?('は')   # => true

Verwandt: siehe Abfragen.

Gibt zurück, ob self und object die gleiche Länge und denselben Inhalt haben.

s = 'foo'
s.eql?('foo')  # => true
s.eql?('food') # => false
s.eql?('FOO')  # => false

Gibt false zurück, wenn die Kodierungen der beiden Strings nicht kompatibel sind.

s0 = "äöü"                           # => "äöü"
s1 = s0.encode(Encoding::ISO_8859_1) # => "\xE4\xF6\xFC"
s0.encoding                          # => #<Encoding:UTF-8>
s1.encoding                          # => #<Encoding:ISO-8859-1>
s0.eql?(s1)                          # => false

Siehe Encodings.

Verwandt: siehe Abfragen.

Ändert die Kodierung von self auf die gegebene encoding, die ein String-Kodierungsname oder ein Encoding-Objekt sein kann; ändert die zugrunde liegenden Bytes nicht; gibt self zurück.

s = 'łał'
s.bytes                   # => [197, 130, 97, 197, 130]
s.encoding                # => #<Encoding:UTF-8>
s.force_encoding('ascii') # => "\xC5\x82a\xC5\x82"
s.encoding                # => #<Encoding:US-ASCII>
s.valid_encoding?         # => true
s.bytes                   # => [197, 130, 97, 197, 130]

Führt die Änderung auch dann durch, wenn die gegebene encoding für self ungültig ist (ebenso wie die obige Änderung).

s.valid_encoding?         # => false

Siehe Encodings.

Verwandt: siehe Modifizieren.

Gibt das Byte am 0-basierten index als ganze Zahl zurück.

s = 'foo'
s.getbyte(0)    # => 102
s.getbyte(1)    # => 111
s.getbyte(2)    # => 111

Zählt rückwärts vom Ende, wenn index negativ ist.

s.getbyte(-3) # => 102

Gibt nil zurück, wenn index außerhalb des Bereichs liegt.

s.getbyte(3)  # => nil
s.getbyte(-4) # => nil

Weitere Beispiele

s = 'тест'
s.bytes      # => [209, 130, 208, 181, 209, 129, 209, 130]
s.getbyte(2) # => 208
s = 'こんにちは'
s.bytes      # => [227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129, 175]
s.getbyte(2) # => 147

Verwandt: siehe Konvertierung in Nicht-String.

Gibt ein Array der Graphem-Cluster in self zurück (siehe Unicode Grapheme Cluster Boundaries).

s = "ä-pqr-b̈-xyz-c̈"
s.size                   # => 16
s.bytesize               # => 19
s.grapheme_clusters.size # => 13
s.grapheme_clusters
# => ["ä", "-", "p", "q", "r", "-", "b̈", "-", "x", "y", "z", "-", "c̈"]

Details

s = "ä"
s.grapheme_clusters             # => ["ä"]           # One grapheme cluster.
s.bytes                         # => [97, 204, 136]  # Three bytes.
s.chars                         # => ["a", "̈"]       # Two characters.
s.chars.map {|char| char.ord }  # => [97, 776]       # Their values.

Verwandt: siehe Konvertierung in Nicht-String.

Gibt eine Kopie von self zurück, bei der null oder mehr Teilstrings ersetzt wurden.

Das Argument pattern kann ein String oder ein Regexp sein; das Argument replacement kann ein String oder ein Hash sein. Unterschiedliche Typen für die Argumentwerte machen diese Methode sehr vielseitig.

Unten sind einige einfache Beispiele; für viele weitere Beispiele siehe Substitutionsmethoden.

Mit den Argumenten pattern und String replacement wird jeder übereinstimmende Teilstring durch den gegebenen replacement-String ersetzt.

s = 'abracadabra'
s.gsub('ab', 'AB')   # => "ABracadABra"
s.gsub(/[a-c]/, 'X') # => "XXrXXXdXXrX"

Mit den Argumenten pattern und Hash replacement wird jeder übereinstimmende Teilstring durch einen Wert aus dem gegebenen replacement-Hash ersetzt oder entfernt.

h = {'a' => 'A', 'b' => 'B', 'c' => 'C'}
s.gsub(/[a-c]/, h) # => "ABrACAdABrA"  # 'a', 'b', 'c' replaced.
s.gsub(/[a-d]/, h) # => "ABrACAABrA"   # 'd' removed.

Mit dem Argument pattern und einem Block wird der Block mit jedem übereinstimmenden Teilstring aufgerufen; dieser Teilstring wird durch den Rückgabewert des Blocks ersetzt.

s.gsub(/[a-d]/) {|substring| substring.upcase }
# => "ABrACADABrA"

Mit dem Argument pattern und ohne Block wird ein neuer Enumerator zurückgegeben.

Verwandt: siehe Konvertierung zu neuem String.

Wie String#gsub, außer dass

• Substitutionen in self (nicht in einer Kopie von self) durchgeführt werden.

• self zurückgegeben wird, wenn Zeichen entfernt werden, andernfalls nil.

Verwandt: siehe Modifizieren.

Gibt den ganzzahligen Hash-Wert für self zurück.

Zwei String-Objekte mit identischem Inhalt und kompatiblen Kodierungen haben auch denselben Hash-Wert; siehe Object#hash und Encodings.

s = 'foo'
h = s.hash       # => -569050784
h == 'foo'.hash  # => true
h == 'food'.hash # => false
h == 'FOO'.hash  # => false

s0 = "äöü"
s1 = s0.encode(Encoding::ISO_8859_1)
s0.encoding        # => #<Encoding:UTF-8>
s1.encoding        # => #<Encoding:ISO-8859-1>
s0.hash == s1.hash # => false

Verwandt: siehe Abfragen.

Interpretiert den führenden Teilstring von self als Hexadezimalzahl, möglicherweise mit Vorzeichen; gibt dessen Wert als ganze Zahl zurück.

Der führende Teilstring wird als Hexadezimalzahl interpretiert, wenn er beginnt mit

• Einem oder mehreren Zeichen, die Hexadezimalziffern darstellen (jeweils im Bereich '0'..'9', 'a'..'f' oder 'A'..'F'); der zu interpretierende String endet beim ersten Zeichen, das keine Hexadezimalziffer darstellt.

  'f'.hex        # => 15
  '11'.hex       # => 17
  'FFF'.hex      # => 4095
  'fffg'.hex     # => 4095
  'foo'.hex      # => 15   # 'f' hexadecimal, 'oo' not.
  'bar'.hex      # => 186  # 'ba' hexadecimal, 'r' not.
  'deadbeef'.hex # => 3735928559
  

• '0x' oder '0X', gefolgt von einer oder mehreren Hexadezimalziffern.

  '0xfff'.hex    # => 4095
  '0xfffg'.hex   # => 4095
  

Jede der obigen Formen kann mit einem '-' präfigiert werden, das den interpretierten Wert negiert.

'-fff'.hex      # => -4095
'-0xFFF'.hex    # => -4095

Für jeden Teilstring, der nicht oben beschrieben ist, wird Null zurückgegeben.

'xxx'.hex     # => 0
''.hex        # => 0

Beachten Sie, dass diese Methode im Gegensatz zu oct nur Hexadezimalnotationen und keine Binär-, Oktal- oder Dezimalnotationen interpretiert.

'0b111'.hex   # => 45329
'0o777'.hex   # => 0
'0d999'.hex   # => 55705

Verwandt: Siehe Konvertierung in Nicht-String.

Gibt zurück, ob self other_string enthält.

s = 'bar'
s.include?('ba')  # => true
s.include?('ar')  # => true
s.include?('bar') # => true
s.include?('a')   # => true
s.include?('')    # => true
s.include?('foo') # => false

Verwandt: siehe Abfragen.

Gibt die ganzzahlige Position des ersten Teilstrings zurück, der dem gegebenen Argument pattern entspricht, oder nil, wenn keiner gefunden wurde.

Wenn pattern ein String ist, wird der Index des ersten übereinstimmenden Teilstrings in self zurückgegeben.

'foo'.index('f')         # => 0
'foo'.index('o')         # => 1
'foo'.index('oo')        # => 1
'foo'.index('ooo')       # => nil
'тест'.index('с')        # => 2  # Characters, not bytes.
'こんにちは'.index('ち')  # => 3

Wenn pattern ein Regexp ist, wird der Index der ersten Übereinstimmung in self zurückgegeben.

'foo'.index(/o./) # => 1
'foo'.index(/.o/) # => 0

Wenn offset nicht-negativ ist, beginnt die Suche an Position offset; der zurückgegebene Index ist relativ zum Anfang von self.

'bar'.index('r', 0)        # => 2
'bar'.index('r', 1)        # => 2
'bar'.index('r', 2)        # => 2
'bar'.index('r', 3)        # => nil
'bar'.index(/[r-z]/, 0)    # => 2
'тест'.index('с', 1)       # => 2
'тест'.index('с', 2)       # => 2
'тест'.index('с', 3)       # => nil  # Offset in characters, not bytes.
'こんにちは'.index('ち', 2) # => 3

Mit einem negativen ganzzahligen Argument offset wird die Suchposition durch Rückwärtszählen vom Ende von self ausgewählt.

'foo'.index('o', -1)  # => 2
'foo'.index('o', -2)  # => 1
'foo'.index('o', -3)  # => 1
'foo'.index('o', -4)  # => nil
'foo'.index(/o./, -2) # => 1
'foo'.index(/.o/, -2) # => 1

Verwandt: siehe Abfragen.

Fügt den gegebenen other_string in self ein; gibt self zurück.

Wenn der gegebene index nicht-negativ ist, wird other_string an Offset index eingefügt.

'foo'.insert(0, 'bar')       # => "barfoo"
'foo'.insert(1, 'bar')       # => "fbaroo"
'foo'.insert(3, 'bar')       # => "foobar"
'тест'.insert(2, 'bar')      # => "теbarст"  # Characters, not bytes.
'こんにちは'.insert(2, 'bar') # => "こんbarにちは"

Wenn der index negativ ist, wird vom Ende von self rückwärts gezählt und other_string *nach* dem Offset eingefügt.

'foo'.insert(-2, 'bar') # => "fobaro"

Verwandt: siehe Modifizieren.

Gibt eine druckbare Version von self zurück, eingeschlossen in doppelte Anführungszeichen.

Die meisten druckbaren Zeichen werden einfach als sie selbst wiedergegeben.

'abc'.inspect        # => "\"abc\""
'012'.inspect        # => "\"012\""
''.inspect           # => "\"\""
"\u000012".inspect   # => "\"\\u000012\""
'тест'.inspect       # => "\"тест\""
'こんにちは'.inspect  # => "\"こんにちは\""

Aber die druckbaren Zeichen doppelte Anführungszeichen ('"') und Backslash ('\') werden escaped.

'"'.inspect  # => "\"\\\"\""
'\\'.inspect # => "\"\\\\\""

Nicht druckbare Zeichen sind die ASCII-Zeichen, deren Werte im Bereich 0..31 liegen, zusammen mit dem Zeichen, dessen Wert 127 ist.

Die meisten dieser Zeichen werden so wiedergegeben:

0.chr.inspect # => "\"\\x00\""
1.chr.inspect # => "\"\\x01\""
2.chr.inspect # => "\"\\x02\""
# ...

Einige wenige haben jedoch spezielle Darstellungen.

7.chr.inspect  # => "\"\\a\""  # BEL
8.chr.inspect  # => "\"\\b\""  # BS
9.chr.inspect  # => "\"\\t\""  # TAB
10.chr.inspect # => "\"\\n\""  # LF
11.chr.inspect # => "\"\\v\""  # VT
12.chr.inspect # => "\"\\f\""  # FF
13.chr.inspect # => "\"\\r\""  # CR
27.chr.inspect # => "\"\\e\""  # ESC

Verwandt: siehe Konvertierung in Nicht-String.

Gibt das von self abgeleitete Symbol-Objekt zurück und erstellt es, falls es noch nicht existiert.

'foo'.intern       # => :foo
'тест'.intern      # => :тест
'こんにちは'.intern # => :こんにちは

Verwandt: siehe Konvertierung in Nicht-String.

Gibt die Anzahl der Zeichen (nicht Bytes) in self zurück.

'foo'.length        # => 3
'тест'.length       # => 4
'こんにちは'.length  # => 5

Im Gegensatz zu String#bytesize.

'foo'.bytesize        # => 3
'тест'.bytesize       # => 8
'こんにちは'.bytesize  # => 15

Verwandt: siehe Abfragen.

Gibt Teilstrings ("Zeilen") von self gemäß den gegebenen Argumenten zurück.

s = <<~EOT
This is the first line.
This is line two.

This is line four.
This is line five.
EOT

Mit den Standard-Argumentwerten.

$/ # => "\n"
s.lines
# =>
["This is the first line.\n",
 "This is line two.\n",
 "\n",
 "This is line four.\n",
 "This is line five.\n"]

Mit einem anderen record_separator

record_separator = ' is '
s.lines(record_separator)
# =>
["This is ",
 "the first line.\nThis is ",
 "line two.\n\nThis is ",
 "line four.\nThis is ",
 "line five.\n"]

Mit dem Schlüsselwortargument chomp als true wird der nachfolgende Zeilentrenner von jeder Zeile entfernt.

s.lines(chomp: true)
# =>
["This is the first line.",
 "This is line two.",
 "",
 "This is line four.",
 "This is line five."]

Verwandt: siehe Konvertierung in Nicht-String.

Gibt eine Kopie von self zurück, linksbündig und bei Bedarf rechts mit pad_string aufgefüllt.

'hello'.ljust(10)       # => "hello     "
'  hello'.ljust(10)     # => "  hello   "
'hello'.ljust(10, 'ab') # => "helloababa"
'тест'.ljust(10)        # => "тест      "
'こんにちは'.ljust(10)   # => "こんにちは     "

Wenn width <= self.length, wird eine Kopie von self zurückgegeben.

'hello'.ljust(5)  # => "hello"
'hello'.ljust(1)  # => "hello"  # Does not truncate to width.

Verwandt: siehe Konvertierung zu neuem String.

Gibt eine Kopie von self zurück, bei der führende Leerzeichen entfernt wurden; siehe Leerzeichen in Strings.

whitespace = "\x00\t\n\v\f\r "
s = whitespace + 'abc' + whitespace
# => "\u0000\t\n\v\f\r abc\u0000\t\n\v\f\r "
s.lstrip
# => "abc\u0000\t\n\v\f\r "

Wenn selectors angegeben sind, werden Zeichen aus selectors vom Anfang von self entfernt.

s = "---abc+++"
s.lstrip("-") # => "abc+++"

selectors müssen gültige Zeichenselektoren sein (siehe Character Selectors) und können jede seiner gültigen Formen verwenden, einschließlich Negation, Bereiche und Escapes.

"01234abc56789".lstrip("0-9") # "abc56789"
"01234abc56789".lstrip("0-9", "^4-6") # "4abc56789"

Verwandt: siehe Konvertierung zu neuem String.

Wie String#lstrip, außer dass

• das Strippen in self (nicht in einer Kopie von self) durchgeführt wird.

• Gibt self zurück, wenn Zeichen gestrippt wurden, andernfalls nil.

Verwandt: siehe Modifizieren.

Erstellt ein MatchData-Objekt basierend auf self und den gegebenen Argumenten; aktualisiert Regexp Global Variables.

• Berechnet regexp, indem pattern konvertiert wird (falls nicht bereits ein Regexp).

  regexp = Regexp.new(pattern)
  

• Berechnet matchdata, das entweder ein MatchData-Objekt oder nil sein wird (siehe Regexp#match).

  matchdata = regexp.match(self[offset..])
  

Ohne Block wird das berechnete matchdata oder nil zurückgegeben.

'foo'.match('f')    # => #<MatchData "f">
'foo'.match('o')    # => #<MatchData "o">
'foo'.match('x')    # => nil
'foo'.match('f', 1) # => nil
'foo'.match('o', 1) # => #<MatchData "o">

Mit einem Block und nicht-nil berechnetem matchdata wird der Block mit matchdata aufgerufen; gibt den Rückgabewert des Blocks zurück.

'foo'.match(/o/) {|matchdata| matchdata } # => #<MatchData "o">

Mit einem Block und nil matchdata wird der Block nicht aufgerufen.

'foo'.match(/x/) {|matchdata| fail 'Cannot happen' } # => nil

Verwandt: siehe Abfragen.

Gibt zurück, ob eine Übereinstimmung für self und die gegebenen Argumente gefunden wird; aktualisiert keine Regexp Global Variables.

Berechnet regexp, indem pattern konvertiert wird (falls nicht bereits ein Regexp).

regexp = Regexp.new(pattern)

Gibt true zurück, wenn self[offset..].match(regexp) ein MatchData-Objekt zurückgibt, andernfalls false

'foo'.match?(/o/) # => true
'foo'.match?('o') # => true
'foo'.match?(/x/) # => false
'foo'.match?('f', 1) # => false
'foo'.match?('o', 1) # => true

Verwandt: siehe Abfragen.

Interpretiert die führende Teilzeichenkette von self als Oktal-, Binär-, Dezimal- oder Hexadezimalzahl, möglicherweise vorzeichenbehaftet; gibt deren Wert als Ganzzahl zurück.

Kurz gesagt

# Interpreted as octal.
'777'.oct   # => 511
'777x'.oct  # => 511
'0777'.oct  # => 511
'0o777'.oct # => 511
'-777'.oct  # => -511
# Not interpreted as octal.
'0b111'.oct # => 7     # Interpreted as binary.
'0d999'.oct # => 999   # Interpreted as decimal.
'0xfff'.oct # => 4095  # Interpreted as hexadecimal.

Die führende Teilzeichenkette wird als Oktalzahl interpretiert, wenn sie beginnt mit

• Ein oder mehrere Zeichen, die Oktalziffern darstellen (jede im Bereich '0'..'7'); die zu interpretierende Zeichenkette endet beim ersten Zeichen, das keine Oktalldifferenz darstellt

  '7'.oct      @ => 7
  '11'.oct     # => 9
  '777'.oct    # => 511
  '0777'.oct   # => 511
  '7778'.oct   # => 511
  '777x'.oct   # => 511

• '0o', gefolgt von einer oder mehreren Oktalziffern

  '0o777'.oct  # => 511
  '0o7778'.oct # => 511
  

Die führende Teilzeichenkette wird *nicht* als Oktalzahl interpretiert, wenn sie beginnt mit

• '0b', gefolgt von einem oder mehreren Zeichen, die Binärziffern darstellen (jede im Bereich '0'..'1'); die zu interpretierende Zeichenkette endet beim ersten Zeichen, das keine Binärziffer darstellt. Die Zeichenkette wird als Binärziffern (Basis 2) interpretiert

  '0b111'.oct  # => 7
  '0b1112'.oct # => 7
  

• '0d', gefolgt von einer oder mehreren Zeichen, die Dezimalziffern darstellen (jede im Bereich '0'..'9'); die zu interpretierende Zeichenkette endet beim ersten Zeichen, das keine Dezimalziffer darstellt. Die Zeichenkette wird als Dezimalziffern (Basis 10) interpretiert

  '0d999'.oct  # => 999
  '0d999x'.oct # => 999
  

• '0x', gefolgt von einer oder mehreren Zeichen, die Hexadezimalziffern darstellen (jede im Bereich '0'..'9', 'a'..'f' oder 'A'..'F'); die zu interpretierende Zeichenkette endet beim ersten Zeichen, das keine Hexadezimalziffer darstellt. Die Zeichenkette wird als Hexadezimalziffern (Basis 16) interpretiert

  '0xfff'.oct  # => 4095
  '0xfffg'.oct # => 4095
  

Jede der obigen Formen kann mit einem '-' präfigiert werden, das den interpretierten Wert negiert.

'-777'.oct   # => -511
'-0777'.oct  # => -511
'-0b111'.oct # => -7
'-0xfff'.oct # => -4095

Für jeden Teilstring, der nicht oben beschrieben ist, wird Null zurückgegeben.

'foo'.oct      # => 0
''.oct         # => 0

Verwandt: siehe Konvertierung in Nicht-String.

Gibt die ganzzahlige Ordnung des ersten Zeichens von self zurück

'h'.ord         # => 104
'hello'.ord     # => 104
'тест'.ord      # => 1090
'こんにちは'.ord  # => 12371

Verwandt: siehe Konvertierung in Nicht-String.

Gibt ein Array mit 3 Teilzeichenketten von self zurück.

Wenn pattern übereinstimmt, wird das Array zurückgegeben

[pre_match, first_match, post_match]

wobei

• first_match die erste gefundene übereinstimmende Teilzeichenkette ist.

• pre_match und post_match die vorhergehende und nachfolgende Teilzeichenkette sind.

Wenn pattern nicht übereinstimmt, wird das Array zurückgegeben

[self.dup, "", ""]

Beachten Sie, dass in den folgenden Beispielen eine zurückgegebene Zeichenkette 'hello' eine Kopie von self ist, nicht self.

Wenn pattern ein Regexp ist, wird das Äquivalent von self.match(pattern) ausgeführt (wobei auch Matched-Data-Variablen gesetzt werden)

'hello'.partition(/h/)  # => ["", "h", "ello"]
'hello'.partition(/l/)  # => ["he", "l", "lo"]
'hello'.partition(/l+/) # => ["he", "ll", "o"]
'hello'.partition(/o/)  # => ["hell", "o", ""]
'hello'.partition(/^/)  # => ["", "", "hello"]
'hello'.partition(//)   # => ["", "", "hello"]
'hello'.partition(/$/)  # => ["hello", "", ""]
'hello'.partition(/x/)  # => ["hello", "", ""]

Wenn pattern kein Regexp ist, wird es in eine Zeichenkette umgewandelt (falls es nicht bereits eine ist) und dann das Äquivalent von self.index(pattern) ausgeführt (und es werden *keine* Matched-Data-Globalvariablen gesetzt)

'hello'.partition('h')     # => ["", "h", "ello"]
'hello'.partition('l')     # => ["he", "l", "lo"]
'hello'.partition('ll')    # => ["he", "ll", "o"]
'hello'.partition('o')     # => ["hell", "o", ""]
'hello'.partition('')      # => ["", "", "hello"]
'hello'.partition('x')     # => ["hello", "", ""]
'тест'.partition('т')      # => ["", "т", "ест"]
'こんにちは'.partition('に') # => ["こん", "に", "ちは"]

Verwandt: siehe Konvertierung in Nicht-String.

Fügt der Verkettung der gegebenen other_strings vor self an; gibt self zurück

'baz'.prepend('foo', 'bar') # => "foobarbaz"

Verwandt: siehe Modifizieren.

Ersetzt den Inhalt von self durch den Inhalt von other_string; gibt self zurück

s = 'foo'        # => "foo"
s.replace('bar') # => "bar"

Verwandt: siehe Modifizieren.

Gibt eine neue Zeichenkette mit den Zeichen von self in umgekehrter Reihenfolge zurück.

'drawer'.reverse       # => "reward"
'reviled'.reverse      # => "deliver"
'stressed'.reverse     # => "desserts"
'semordnilaps'.reverse # => "spalindromes"

Verwandt: siehe Konvertierung zu neuem String.

Gibt self mit umgedrehten Zeichen zurück

'drawer'.reverse!       # => "reward"
'reviled'.reverse!      # => "deliver"
'stressed'.reverse!     # => "desserts"
'semordnilaps'.reverse! # => "spalindromes"

Verwandt: siehe Modifizieren.

Gibt die ganzzahlige Position der *letzten* Teilzeichenkette zurück, die mit dem gegebenen Argument pattern übereinstimmt, oder nil, wenn keine gefunden wird.

Wenn pattern eine Zeichenkette ist, wird der Index der letzten übereinstimmenden Teilzeichenkette in self zurückgegeben

'foo'.rindex('f')       # => 0
'foo'.rindex('o')       # => 2
'foo'.rindex('oo'       # => 1
'foo'.rindex('ooo')     # => nil
'тест'.rindex('т')      # => 3
'こんにちは'.rindex('ち') # => 3

Wenn pattern ein Regexp ist, wird der Index des letzten Treffers in self zurückgegeben

'foo'.rindex(/f/)   # => 0
'foo'.rindex(/o/)   # => 2
'foo'.rindex(/oo/)  # => 1
'foo'.rindex(/ooo/) # => nil

Wenn offset nicht negativ ist, gibt es die maximale Startposition in der Zeichenkette an, an der die Suche beendet werden soll

'foo'.rindex('o', 0) # => nil
'foo'.rindex('o', 1) # => 1
'foo'.rindex('o', 2) # => 2
'foo'.rindex('o', 3) # => 2

Mit einem negativen ganzzahligen Argument offset wird die Suchposition durch Rückwärtszählen vom Ende von self ausgewählt.

'foo'.rindex('o', -1) # => 2
'foo'.rindex('o', -2) # => 1
'foo'.rindex('o', -3) # => nil
'foo'.rindex('o', -4) # => nil

Der letzte Treffer bedeutet, dass an der zuletzt möglichen Position begonnen wird, nicht der letzte der längsten Treffer

'foo'.rindex(/o+/) # => 2
$~                 # => #<MatchData "o">

Um den letzten längsten Treffer zu erhalten, kombinieren Sie mit negativer Lookbehind-Assertion

'foo'.rindex(/(?<!o)o+/) # => 1
$~                       # => #<MatchData "oo">

Oder String#index mit negativer Lookforward-Assertion.

'foo'.index(/o+(?!.*o)/) # => 1
$~                       # => #<MatchData "oo">

Verwandt: siehe Abfragen.

Gibt eine rechtsbündige Kopie von self zurück.

Wenn das Ganzzahlargument width größer ist als die Größe (in Zeichen) von self, wird eine neue Zeichenkette der Länge width zurückgegeben, die eine Kopie von self ist, rechtsbündig und links mit pad_string aufgefüllt

'hello'.rjust(10)       # => "     hello"
'hello  '.rjust(10)     # => "   hello  "
'hello'.rjust(10, 'ab') # => "ababahello"
'тест'.rjust(10)        # => "      тест"
'こんにちは'.rjust(10)    # => "     こんにちは"

Wenn width <= self.size, wird eine Kopie von self zurückgegeben

'hello'.rjust(5, 'ab')  # => "hello"
'hello'.rjust(1, 'ab')  # => "hello"

Verwandt: siehe Konvertierung zu neuem String.

Gibt ein Array mit 3 Teilzeichenketten von self zurück.

Sucht in self nach einem Treffer von pattern, wobei der *letzte* Treffer gesucht wird.

Wenn pattern nicht übereinstimmt, wird das Array zurückgegeben

["", "", self.dup]

Wenn pattern übereinstimmt, wird das Array zurückgegeben

[pre_match, last_match, post_match]

wobei

• last_match ist die zuletzt gefundene übereinstimmende Teilzeichenkette.

• pre_match und post_match die vorhergehende und nachfolgende Teilzeichenkette sind.

Das verwendete Muster ist

• pattern selbst, wenn es ein Regexp ist.

• Regexp.quote(pattern), wenn pattern eine Zeichenkette ist.

Beachten Sie, dass in den folgenden Beispielen eine zurückgegebene Zeichenkette 'hello' eine Kopie von self ist, nicht self.

Wenn pattern ein Regexp ist, wird nach der letzten übereinstimmenden Teilzeichenkette gesucht (wobei auch Matched-Data-Globalvariablen gesetzt werden)

'hello'.rpartition(/l/)     # => ["hel", "l", "o"]
'hello'.rpartition(/ll/)    # => ["he", "ll", "o"]
'hello'.rpartition(/h/)     # => ["", "h", "ello"]
'hello'.rpartition(/o/)     # => ["hell", "o", ""]
'hello'.rpartition(//)      # => ["hello", "", ""]
'hello'.rpartition(/x/)     # => ["", "", "hello"]
'тест'.rpartition(/т/)      # => ["тес", "т", ""]
'こんにちは'.rpartition(/に/) # => ["こん", "に", "ちは"]

Wenn pattern kein Regexp ist, wird es in eine Zeichenkette umgewandelt (falls es nicht bereits eine ist) und dann nach der letzten übereinstimmenden Teilzeichenkette gesucht (und es werden *keine* Matched-Data-Globalvariablen gesetzt)

'hello'.rpartition('l')     # => ["hel", "l", "o"]
'hello'.rpartition('ll')    # => ["he", "ll", "o"]
'hello'.rpartition('h')     # => ["", "h", "ello"]
'hello'.rpartition('o')     # => ["hell", "o", ""]
'hello'.rpartition('')      # => ["hello", "", ""]
'тест'.rpartition('т')      # => ["тес", "т", ""]
'こんにちは'.rpartition('に') # => ["こん", "に", "ちは"]

Verwandt: siehe Konvertierung in Nicht-String.

Gibt eine Kopie von self mit entfernten nachgestellten Leerzeichen zurück; siehe Leerzeichen in Zeichenketten

whitespace = "\x00\t\n\v\f\r "
s = whitespace + 'abc' + whitespace
s        # => "\u0000\t\n\v\f\r abc\u0000\t\n\v\f\r "
s.rstrip # => "\u0000\t\n\v\f\r abc"

Wenn selectors angegeben sind, werden Zeichen aus selectors vom Ende von self entfernt

s = "---abc+++"
s.rstrip("+") # => "---abc"

selectors müssen gültige Zeichenselektoren sein (siehe Character Selectors) und können jede seiner gültigen Formen verwenden, einschließlich Negation, Bereiche und Escapes.

"01234abc56789".rstrip("0-9") # "01234abc"
"01234abc56789".rstrip("0-9", "^4-6") # "01234abc56"

Verwandt: siehe Konvertierung zu neuem String.

Ähnlich wie String#rstrip, außer dass

• das Strippen in self (nicht in einer Kopie von self) durchgeführt wird.

• Gibt self zurück, wenn Zeichen gestrippt wurden, andernfalls nil.

Verwandt: siehe Modifizieren.

Passt ein Muster an self an

• Wenn pattern ein Regexp ist, ist das verwendete Muster pattern selbst.

• Wenn pattern eine Zeichenkette ist, ist das verwendete Muster Regexp.quote(pattern).

Generiert eine Sammlung von übereinstimmenden Ergebnissen und aktualisiert Regexp-bezogene globale Variablen

• Wenn das Muster keine Gruppen enthält, ist jedes Ergebnis eine übereinstimmende Teilzeichenkette.

• Wenn das Muster Gruppen enthält, ist jedes Ergebnis ein Array, das eine übereinstimmende Teilzeichenkette für jede Gruppe enthält.

Ohne Block wird ein Array der Ergebnisse zurückgegeben

'cruel world'.scan(/\w+/)      # => ["cruel", "world"]
'cruel world'.scan(/.../)      # => ["cru", "el ", "wor"]
'cruel world'.scan(/(...)/)    # => [["cru"], ["el "], ["wor"]]
'cruel world'.scan(/(..)(..)/) # => [["cr", "ue"], ["l ", "wo"]]
'тест'.scan(/../)              # => ["те", "ст"]
'こんにちは'.scan(/../)         # => ["こん", "にち"]
'abracadabra'.scan('ab')       # => ["ab", "ab"]
'abracadabra'.scan('nosuch')   # => []

Mit gegebenem Block wird der Block mit jedem Ergebnis aufgerufen; gibt self zurück

'cruel world'.scan(/\w+/) {|w| p w }
# => "cruel"
# => "world"
'cruel world'.scan(/(.)(.)/) {|x, y| p [x, y] }
# => ["c", "r"]
# => ["u", "e"]
# => ["l", " "]
# => ["w", "o"]
# => ["r", "l"]

Verwandt: siehe Konvertierung in Nicht-String.

Gibt eine Kopie von self zurück, bei der jede ungültige Byte-Sequenz durch die angegebene replacement_string ersetzt wird.

Ohne Block wird jede ungültige Sequenz durch die angegebene default_replacement_string ersetzt (standardmäßig "�" für eine Unicode-Kodierung, andernfalls '?')

"foo\x81\x81bar"scrub                             # => "foo��bar"
"foo\x81\x81bar".force_encoding('US-ASCII').scrub # => "foo??bar"
"foo\x81\x81bar".scrub('xyzzy')                   # => "fooxyzzyxyzzybar"

Mit gegebenem Block wird der Block mit jeder ungültigen Sequenz aufgerufen und diese Sequenz durch den Rückgabewert des Blocks ersetzt

"foo\x81\x81bar".scrub {|sequence| p sequence; 'XYZZY' } # => "fooXYZZYXYZZYbar"

Ausgabe

"\x81"
"\x81"

Verwandt: siehe Konvertierung zu neuem String.

Ähnlich wie String#scrub, außer dass

• Alle Ersetzungen werden in self vorgenommen.

• Gibt self zurück.

Verwandt: siehe Modifizieren.

Setzt das Byte am nullbasierten Offset index auf den Wert des gegebenen integer; gibt integer zurück

s = 'xyzzy'
s.setbyte(2, 129) # => 129
s                 # => "xy\x81zy"

Verwandt: siehe Modifizieren.

Escaped str, damit es sicher in einer Bourne-Shell-Befehlszeile verwendet werden kann.

Siehe Shellwords.shellescape für Details.

Teilt str in ein Array von Tokens auf, genau wie die UNIX Bourne Shell.

Siehe Shellwords.shellsplit für Details.

Ähnlich wie String#[] (und dessen Alias String#slice), außer dass

• Substitutionen in self (nicht in einer Kopie von self) durchgeführt werden.

• Gibt die entfernte Teilzeichenkette zurück, wenn Änderungen vorgenommen wurden, andernfalls nil.

Einige Beispiele

s = 'hello'
s.slice!('e') # => "e"
s             # => "hllo"
s.slice!('e') # => nil
s             # => "hllo"

Verwandt: siehe Modifizieren.

Erstellt ein Array von Teilzeichenketten, indem self bei jedem Vorkommen des angegebenen Feldtrennzeichens field_sep aufgeteilt wird.

Ohne Argumente wird mit dem Feldtrennzeichen $; aufgeteilt, dessen Standardwert nil ist.

Ohne Block wird das Array von Teilzeichenketten zurückgegeben

'abracadabra'.split('a') # => ["", "br", "c", "d", "br"]

Wenn field_sep nil oder ' ' (ein einzelnes Leerzeichen) ist, wird bei jeder Abfolge von Leerzeichen aufgeteilt

'foo bar baz'.split(nil)          # => ["foo", "bar", "baz"]
'foo bar baz'.split(' ')          # => ["foo", "bar", "baz"]
"foo \n\tbar\t\n  baz".split(' ') # => ["foo", "bar", "baz"]
'foo  bar   baz'.split(' ')       # => ["foo", "bar", "baz"]
''.split(' ')                     # => []

Wenn field_sep eine leere Zeichenkette ist, wird bei jedem Zeichen aufgeteilt

'abracadabra'.split('') # => ["a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a"]
''.split('')            # => []
'тест'.split('')        # => ["т", "е", "с", "т"]
'こんにちは'.split('')   # => ["こ", "ん", "に", "ち", "は"]

Wenn field_sep eine nicht leere Zeichenkette ist und sich von ' ' (ein einzelnes Leerzeichen) unterscheidet, wird diese Zeichenkette als Trennzeichen verwendet

'abracadabra'.split('a')  # => ["", "br", "c", "d", "br"]
'abracadabra'.split('ab') # => ["", "racad", "ra"]
''.split('a')             # => []
'тест'.split('т')         # => ["", "ес"]
'こんにちは'.split('に')    # => ["こん", "ちは"]

Wenn field_sep ein Regexp ist, wird bei jedem Vorkommen einer übereinstimmenden Teilzeichenkette aufgeteilt

'abracadabra'.split(/ab/) # => ["", "racad", "ra"]
'1 + 1 == 2'.split(/\W+/) # => ["1", "1", "2"]
'abracadabra'.split(//)   # => ["a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a"]

Wenn der Regexp Gruppen enthält, werden deren Treffer in das zurückgegebene Array aufgenommen

'1:2:3'.split(/(:)()()/, 2) # => ["1", ":", "", "", "2:3"]

Das Argument limit setzt eine Grenze für die Größe des zurückgegebenen Arrays; es bestimmt auch, ob nachgestellte leere Zeichenketten in das zurückgegebene Array aufgenommen werden.

Wenn limit null ist, gibt es keine Begrenzung der Array-Größe, aber nachgestellte leere Zeichenketten werden weggelassen

'abracadabra'.split('', 0)  # => ["a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a"]
'abracadabra'.split('a', 0) # => ["", "br", "c", "d", "br"]  # Empty string after last 'a' omitted.

Wenn limit eine positive Ganzzahl ist, gibt es eine Begrenzung der Array-Größe (nicht mehr als n - 1 Aufteilungen erfolgen) und nachgestellte leere Zeichenketten werden aufgenommen

'abracadabra'.split('', 3)   # => ["a", "b", "racadabra"]
'abracadabra'.split('a', 3)  # => ["", "br", "cadabra"]
'abracadabra'.split('', 30)  # => ["a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a", ""]
'abracadabra'.split('a', 30) # => ["", "br", "c", "d", "br", ""]
'abracadabra'.split('', 1)   # => ["abracadabra"]
'abracadabra'.split('a', 1)  # => ["abracadabra"]

Wenn limit negativ ist, gibt es keine Begrenzung der Array-Größe, und nachgestellte leere Zeichenketten werden weggelassen

'abracadabra'.split('', -1)  # => ["a", "b", "r", "a", "c", "a", "d", "a", "b", "r", "a", ""]
'abracadabra'.split('a', -1) # => ["", "br", "c", "d", "br", ""]

Wenn ein Block gegeben ist, wird er mit jeder Teilzeichenkette aufgerufen und gibt self zurück

'foo bar baz'.split(' ') {|substring| p substring }

Ausgabe

"foo"
"bar"
"baz"

Beachten Sie, dass das obige Beispiel funktional äquivalent ist zu

'foo bar baz'.split(' ').each {|substring| p substring }

Ausgabe

"foo"
"bar"
"baz"

Aber das Letzte

• Hat schlechtere Leistung, da es ein Zwischenarray erstellt.

• Gibt ein Array zurück (anstelle von self).

Verwandt: siehe Konvertierung in Nicht-String.

Gibt eine Kopie von self zurück, bei der jedes Tupel (Verdoppeln, Verdreifachen usw.) von angegebenen Zeichen auf ein einzelnes Zeichen "zusammengestaucht" wird.

Die zu stauchenden Tupel werden durch die Argumente selectors angegeben, von denen jedes eine Zeichenkette ist; siehe Zeichenselektoren.

Ein einzelnes Argument kann ein einzelnes Zeichen sein

'Noooooo!'.squeeze('o')      # => "No!"
'foo  bar  baz'.squeeze(' ') # => "foo bar baz"
'Mississippi'.squeeze('s')   # => "Misisippi"
'Mississippi'.squeeze('p')   # => "Mississipi"
'Mississippi'.squeeze('x')   # => "Mississippi"  # Unused selector character is ignored.
'бессонница'.squeeze('с')    # => "бесонница"
'бессонница'.squeeze('н')    # => "бессоница"

Ein einzelnes Argument kann eine Zeichenkette von Zeichen sein

'Mississippi'.squeeze('sp')       # => "Misisipi"
'Mississippi'.squeeze('ps')       # => "Misisipi"   # Order doesn't matter.
'Mississippi'.squeeze('nonsense') # => "Misisippi"  # Unused selector characters are ignored.

Ein einzelnes Argument kann ein Bereich von Zeichen sein

'Mississippi'.squeeze('a-p') # => "Mississipi"
'Mississippi'.squeeze('q-z') # => "Misisippi"
'Mississippi'.squeeze('a-z') # => "Misisipi"

Mehrere Argumente sind zulässig; siehe Mehrere Zeichenselektoren.

Verwandt: siehe Konvertierung zu neuem String.