Wie man mit Zeichenketten in Ruby arbeitet

Einführung

A string is a sequence of one or more characters that may consist of letters, numbers, or symbols.

Strings in Ruby sind Objekte und im Gegensatz zu anderen Sprachen sind Strings veränderbar, was bedeutet, dass sie an Ort und Stelle geändert werden können, anstatt neue Strings zu erstellen.

Sie werden Strings in fast jedem von Ihnen geschriebenen Programm verwenden. Strings ermöglichen es Ihnen, Text auf dem Bildschirm anzuzeigen und mit Ihren Benutzern zu kommunizieren. Tatsächlich besteht die Seite, die Sie gerade lesen, aus Strings, die auf Ihrem Bildschirm durch Ihren Webbrowser angezeigt werden. Strings sind eine der wichtigsten Grundlagen des Programmierens.

In diesem Tutorial lernen Sie, wie Sie mit Strings in Ruby arbeiten. Sie erstellen Strings, zeigen sie auf dem Bildschirm an, speichern sie in Variablen, fügen mehrere Strings zusammen und lernen, wie Sie Sonderzeichen wie Zeilenumbrüche, Apostrophe und doppelte Anführungszeichen behandeln können.

Erstellen und Drucken von Strings

Strings existieren entweder innerhalb von einfachen Anführungszeichen ' oder doppelten Anführungszeichen " in Ruby. Um einen String zu erstellen, umschließen Sie eine Zeichenfolge von Zeichen mit einem der beiden:

'This is a string in single quotes.'

"This is a string in double quotes."

Sie können entweder einfache Anführungszeichen oder doppelte Anführungszeichen verwenden. In den meisten Fällen ist es egal, welche Sie wählen, solange Sie konsequent sind. Die Verwendung von doppelten Anführungszeichen ermöglicht jedoch die Durchführung der Zeicheninterpolation, die Sie in diesem Tutorial kennenlernen werden.

Um einen String in Ihrem Programm anzuzeigen, können Sie die Methode print verwenden:

print "Let's print out this string."

Die Methode print gibt den String genau so aus, wie er geschrieben wurde.

Probieren Sie es aus. Erstellen Sie ein neues Ruby-Programm mit dem Namen print.rb in Ihrem Texteditor und verwenden Sie die Methode print, um drei Strings auszugeben:

print 'This is the first string.'
print 'This is the second string.'
print 'This is the third string.'

Speichern Sie die Datei und führen Sie das Programm aus:

ruby print.rb

Sie sehen die folgende Ausgabe:

Output
This is the first string.This is the second string.This is the third string.

Anstelle der drei Strings, die jeweils auf einer eigenen Zeile gedruckt wurden, wurden alle drei Strings zusammen auf einer einzigen Zeile gedruckt. Die Methode print gibt den String auf dem Bildschirm aus, aber wenn Sie jeden String in einer eigenen Zeile haben möchten, müssten Sie selbst ein Zeilenumbruchszeichen hinzufügen.

Wenn Sie alle drei Strings auf separaten Zeilen haben möchten, verwenden Sie stattdessen die Methode puts. Ändern Sie Ihr Programm so, dass anstelle von print puts verwendet wird:

puts 'This is the first string.'
puts 'This is the second string.'
puts 'This is the third string.'

Führen Sie das Programm jetzt erneut aus und Sie sehen diese Ausgabe:

Output
This is the first string.
This is the second string.
This is the third string.

Die Methode puts gibt den von Ihnen angegebenen String aus, fügt aber auch automatisch ein Zeilenumbruchszeichen am Ende des Strings hinzu.

Speichern von Zeichenfolgen in Variablen

Variablen sind eine benannte Referenz auf einen Speicherplatz im Computer. Sie verwenden Variablen, um Daten zu speichern und später abzurufen.

Um eine Zeichenfolge in einer Variable zu speichern, definieren Sie den Variablennamen und weisen Sie ihm den Wert der Zeichenfolge zu:

my_string = 'This is my string'

Um den Wert abzurufen, verwenden Sie den Variablennamen:

print my_string

Um dies selbst auszuprobieren, erstellen Sie die Datei string_variables.rb in Ihrem Editor mit folgendem Befehl:

nano string_variables.rb

Fügen Sie dann den folgenden Code hinzu:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts my_name
puts my_age

Dieses Programm definiert zwei Variablen: my_name und my_age. Jede Variable wird einer Zeichenfolge zugewiesen. Dann verwenden wir die Methode puts, um jede Zeichenfolge in einer eigenen Zeile auszugeben.

Speichern Sie die Datei mit STRG + X und y, und führen Sie dann das Programm aus:

ruby string_variables.rb

Sie sehen die folgende Ausgabe:

Output
Sammy the Shark
none of your business

Indem Sie Zeichenfolgen Variablen zuweisen, können Sie vermeiden, dass Sie dieselbe Zeichenfolge jedes Mal erneut eingeben müssen, wenn Sie sie verwenden möchten. Dies erleichtert das Arbeiten mit Zeichenfolgen in Ihren Programmen.

Lassen Sie uns nun anschauen, wie man Zeichenfolgen zusammenfügt, um neue Zeichenfolgen zu erstellen.

Zeichenfolgenverkettung

Verkettung bedeutet das Verbinden von zwei oder mehr Zeichenketten, um eine neue Zeichenkette zu erstellen. Um zu verketteln, verwenden wir den Verkettungsoperator, dargestellt durch ein +-Symbol. Das +-Symbol ist auch der Additionoperator bei arithmetischen Operationen.

So würde man die Zeichenketten sammy und shark verketteln:

"sammy" + "shark"

Dies würde die folgende Ausgabe erzeugen:

Output
sammyshark

Verkettung verbindet die Zeichenketten hintereinander und gibt einen ganz neuen Zeichenkettenwert aus. Wenn Sie einen Abstand zwischen den Wörtern sammy und shark haben möchten, müssen Sie diesen Abstand in einer der Zeichenketten einschließen, so wie hier:

"sammy " + "shark"

Sie würden solchen Code in einem Programm nicht wirklich so schreiben, aber Sie müssen Zeichenketten und Variablen oft miteinander mischen, und hier kommt die Verkettung ins Spiel.

Hier ist ein Beispiel:

color = "Blue"
print "My favorite color is " + color

Dies würde zu der Ausgabe Meine Lieblingsfarbe ist blau führen. Beachten Sie, dass wir nach dem Wort ist in der Zeichenkette einen Abstand gelassen haben, damit zwischen der Zeichenkette und dem Variablenwert in der Ausgabe ein Abstand vorhanden ist.

Sie können auf diese Weise mehrere Zeichenketten miteinander verketteln. Erstellen Sie die Datei verkettung.rb und fügen Sie diesen Code hinzu:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts "My name is " + my_name + " and my age is " + my_age + "."

Dieses Programm definiert zwei Variablen: mein_name und mein_alter, jede mit ihrer eigenen zugewiesenen Zeichenkette, genauso wie Sie es zuvor getan haben. Aber diesmal geben wir nicht einfach die Werte aus, sondern drucken eine Zeichenkette aus, die die Verkettung verwendet, um diese Werte mit etwas mehr Kontext auszugeben.

Wenn Sie dieses Programm ausführen, sehen Sie die folgende Ausgabe:

Output
My name is Sammy the Shark and my age is none of your business.

In diesem kleinen Programm haben Sie die Verkettung verwendet, um Variablen in diesen String einzufügen.

Wenn Sie zwei oder mehr Zeichenfolgen durch Verkettung kombinieren, erstellen Sie eine neue Zeichenfolge, die Sie im gesamten Programm verwenden können. Daher möchten Sie möglicherweise die erstellte Zeichenfolge einer neuen Variablen zuweisen, die Sie später verwenden können:

my_name = "Sammy the Shark"
my_age = "none of your business"

# der verketteten Zeichenfolge eine Variable zuweisen
output = "My name is " + my_name + " and my age is " + my_age + "."

# Ausgabe drucken
puts output

In einem kleinen Programm wie diesem ist es wahrscheinlich unnötig, eine zusätzliche Ausgabe-Variable zu verwenden. Aber in größeren Programmen möchten Sie möglicherweise eine Zeichenfolge durch Verkettung erstellen, die Sie an mehreren Stellen verwenden werden. Es ist auch eine gute Angewohnheit, die Datenverarbeitung wie Verkettung und Arithmetik von der Ausgabe zu trennen, da Ihre Programme mit der Zeit größer werden und Sie die Logik und Ausgabe in separate Dateien oder Komponenten aufteilen möchten, um sie einfacher zu verwalten.

Achten Sie darauf, den +-Operator nicht zwischen zwei verschiedenen Datentypen zu verwenden. Sie können beispielsweise keine Zeichenfolgen und Ganzzahlen miteinander verketten.

Um zu sehen, was passiert, erstellen Sie ein neues Programm namens strings_and_integers.rb mit dem folgenden Inhalt:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

Dieses Mal haben wir my_name, das die Zeichenfolge Sammy the Shark enthält, und my_number, das die Ganzzahl 27 enthält. Wir wissen, dass 27 keine Zeichenfolge ist, weil es nicht in Anführungszeichen steht. Es hat auch keinen Dezimalpunkt, also wissen wir, dass es sich um eine Ganzzahl handelt.

Wenn Sie das Programm ausführen:

ruby strings_and_ints.rb

Sie werden diese Fehlermeldung sehen:

Output
strings_and_ints.rb:4:in `+': no implicit conversion of Integer into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

Der Fehler keine implizite Konvertierung von Integer in String bedeutet, dass Ruby nur einen String an den vorhandenen String anhängen kann.

strings_and_ints.rb:4:in `+': no implicit conversion of Fixnum into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

Wir könnten unser Programm ändern und die Zahl 27 in Anführungszeichen ("27") setzen, damit sie als String und nicht als Ganzzahl deklariert wird. Oder wir können die Zahl in einen String umwandeln, wenn wir den String erstellen, so wie hier:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number.to_s

Die Methode .to_s wandelt die Ganzzahl in einen String um. Dies ist ein besserer Ansatz, da es uns ermöglicht, unsere Zahl als Ganzzahl in unserem Programm zu behalten. Wir benötigen sie nur als String, wenn wir sie ausgeben, aber wir möchten, dass sie als Ganzzahl vorliegt, wenn wir sie in anderen Teilen unserer Programmlogik verwenden müssen.

Führen Sie das Programm erneut aus, und Sie sehen Sammy the Shark27 auf dem Bildschirm gedruckt.

Zahlen in Strings umzuwandeln, um sie aneinanderzureihen, ist etwas, das Sie häufig begegnen werden, wenn Sie mit Postleitzahlen, Währungen, Telefonnummern und anderen numerischen Daten arbeiten, die Sie zusammen mit Text auf dem Bildschirm anzeigen möchten.

Konkatenation ist leistungsstark, aber sie kann knifflig sein. Wenn Sie versehentlich einen der +-Operatoren auslassen, kann es zu einem Syntaxfehler kommen. Und wenn Sie Zeichenfolgen mit Variablen, die Zahlen enthalten, verbinden müssen, müssen Sie die Variablen in Zeichenfolgen konvertieren. Ruby bietet einen anderen Weg, um Variablenwerte in eine Zeichenfolge einzufügen, genannt **String Interpolation**, der beide Probleme löst.

Verwendung der String-Interpolation

Beim Verketten von Zeichenfolgen und Variablen kann die Ausgabe schwer zu lesen und zu debuggen sein. String-Interpolation löst dies, indem es Ihnen ermöglicht, Ausdrücke in einer Zeichenfolge einzubetten, die in doppelte Anführungszeichen eingeschlossen ist.

Statt dies zu schreiben:

"My name is " + my_name + "!"

Sie können dies tun:

"My name is #{my_name}!"

Anstatt die Zeichenfolge zu beenden und den +-Operator zu verwenden, umschließen Sie die Variable mit der Syntax #{}. Diese Syntax sagt Ruby, den Ausdruck zu evaluieren und ihn in die Zeichenfolge einzufügen.

Probieren Sie es aus. Erstellen Sie ein neues Programm namens interpolation.rb und fügen Sie diesen Code hinzu:

my_name = "Sammy the Shark"
my_age = "none of your business"

output = "My name is #{my_name} and my age is #{my_age}."

puts output

Dies ist dasselbe Programm, das Sie bereits geschrieben haben, aber dieses Mal verwenden wir String-Interpolation, um die Ausgabe zu erstellen.

String-Interpolation hat einen weiteren Vorteil: Sie kann numerische Werte automatisch in Zeichenfolgen konvertieren. Erinnern Sie sich an Ihr Programm strings_and_integers.rb? Öffnen Sie diese Datei erneut in Ihrem Editor, ändern Sie jedoch die letzte Zeile, sodass sie wie folgt aussieht:

my_name = "Sammy the Shark"
my_number = 27

# Verwenden Sie Interpolation anstelle von Konkatenation
print "My name is #{my_name} and my favorite number is #{my_number}."

Ruby konvertiert automatisch my_number in eine Zeichenfolge, und Ihr Programm gibt die folgende Ausgabe aus, wenn Sie es ausführen:

Output
My name is Sammy the Shark and my favorite number is 27.

String-Interpolation ist leistungsstark und bequem. Es ist auch die bevorzugte Methode zum Verketten von Zeichenfolgen mit Variablen.

Zeichenfolgenliterale und Zeichenfolgenwerte

Bemerken Sie, dass alle Zeichenfolgen, die Sie erstellt haben, im Code in Anführungszeichen eingeschlossen sind, aber die tatsächliche gedruckte Ausgabe enthält keine Anführungszeichen.

Es gibt einen Unterschied, wenn Sie jeden davon ansprechen. Ein Zeichenfolgenliteral ist die Zeichenfolge, wie sie im Quellcode geschrieben steht, einschließlich Anführungszeichen. Ein Zeichenfolgenwert ist das, was Sie in der Ausgabe sehen, und enthält keine Anführungszeichen.

Dies ist ein Zeichenfolgenliteral:

"Sammy the Shark"

Der Zeichenfolgenwert wäre Sammy the Shark.

In den meisten Fällen müssen Sie sich um diesen Unterschied keine Gedanken machen, es sei denn, Sie möchten Sonderzeichen wie Anführungszeichen oder Apostrophe in Ihren Zeichenfolgen verwenden.

Escapen von Anführungszeichen und Apostrophen in Zeichenfolgen

Aufgrund der Tatsache, dass Anführungszeichen verwendet werden, um Zeichenketten anzugeben, müssen Sie etwas zusätzliche Arbeit leisten, wenn Sie Apostrophe und Anführungszeichen in Zeichenketten haben möchten.

Wenn Sie versuchen, einen Apostroph inmitten einer einfachen Zeichenkette zu verwenden, wie in diesem Beispiel:

'This isn't what I wanted.'

Der Apostroph in isn't beendet die Zeichenkette, wie Sie an der seltsamen Hervorhebung in diesem Beispiel sehen können. Als Ergebnis wird der Ruby-Interpreter versuchen, den Rest der beabsichtigten Zeichenkette als Code zu parsen, und Sie erhalten einen Fehler.

Sie würden auf dieselbe Situation stoßen, wenn Sie doppelte Anführungszeichen in einer Zeichenkette verwenden würden, die von doppelten Anführungszeichen umschlossen ist:

"Sammy says, "Hello!""

In diesem Beispiel beendet das schließende doppelte Anführungszeichen vor Hello die Zeichenkette, und das doppelte Anführungszeichen nach Hello! erzeugt eine neue Zeichenkette, die kein übereinstimmendes doppeltes Anführungszeichen hat, um sie zu beenden. Daher wird Ruby einen Fehler anzeigen.

Um dieses Problem zu vermeiden, haben Sie einige Optionen. Erstens können Sie die alternative Syntax zum Erstellen von Zeichenketten verwenden; Wenn Sie doppelte Anführungszeichen in der Zeichenkette verwenden müssen, verwenden Sie einfache Anführungszeichen, um die Zeichenkette zu definieren, und umgekehrt. Sie könnten auch die Anführungszeichen maskieren, oder Sie könnten eine andere Ruby-Syntax verwenden, um die Zeichenketten zu definieren. Schauen wir uns jeden Ansatz an.

Option 1: Verwendung der alternativen Zeichenketten-Syntax

Der einfachste Weg, diese Probleme zu umgehen, besteht darin, Ihren String in einfache Anführungszeichen zu setzen, wenn Ihr String doppelte Anführungszeichen enthalten muss, und Ihren String in doppelte Anführungszeichen zu setzen, wenn Ihr String einfache Anführungszeichen verwenden muss.

Anstatt diesen String mit einfachen Anführungszeichen zu definieren:

'This isn't what I wanted.'

Definieren Sie ihn mit doppelten Anführungszeichen:

"This isn't what I wanted."

Und anstatt doppelte Anführungszeichen zu verwenden, um diesen String zu definieren:

"Sammy says, "Hello!""

Verwenden Sie einfache Anführungszeichen:

'Sammy says, "Hello!"'

Die Verwendung der alternativen Syntax kann Sie aus einigen schnellen Schwierigkeiten herausbringen, aber es wird nicht immer funktionieren. Zum Beispiel wird keiner der Ansätze für diesen String funktionieren:

"Sammy says, "I'm a happy shark!""

In diesem Beispiel wirft das schließende doppelte Anführungszeichen vor I'm wirklich alles durcheinander. Dies beendet den ersten String, und dann stößt Ruby auf das Apostroph in I'm, das einen neuen String mit dem Wert m a happy shark!"" startet. Aber dieser neue String hat kein passendes einfaches Anführungszeichen, um ihn zu beenden. Und die Verwendung von einfachen Anführungszeichen, um den String einzuschließen, führt zu einem ähnlichen Problem:

'Sammy says, "I'm a happy shark!"'

Diesmal beendet das Apostroph in I'm den String.

Die Verwendung der alternativen Syntax kann Ihren Code auch inkonsistent machen. Ständiges Wechseln zwischen String-Syntax kann verwirrend sein. Wir können Zeichen escapen, um dieses Problem zu umgehen.

Option 2: Zeichen in Strings escapen

Das Backslash-Zeichen (\), oft als Escape-Zeichen in Zeichenketten bezeichnet, verhindert, dass Ruby das nächste Zeichen in der Zeichenkette wörtlich interpretiert.

Hier ist unsere problematische Zeichenkette, die in doppelten Anführungszeichen codiert ist und doppelte Anführungszeichen enthält:

"Sammy says, "I'm a happy shark!""

Erstellen Sie ein neues Ruby-Programm namens quoting.rb und fügen Sie diesen Code zur Datei hinzu:

print "Sammy says, "I'm a happy shark!""

Führen Sie das Programm aus:

ruby quoting.rb

Und Sie werden diese Ausgabe sehen:

Output
quoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "Sammy says, "I'm a happy shark!""
^

Um den Fehler zu beheben, verwenden Sie den Backslash vor den inneren doppelten Anführungszeichen:

print "Sammy says, \"I'm a happy shark!\""

Führen Sie das Programm erneut aus und Sie werden die erwartete Ausgabe sehen:

Sammy says, "I'm a happy shark!"

Beachten Sie, dass Sie das Apostroph in diesem Beispiel nicht escapen müssen, da es keine Konflikte gibt. Sie müssen nur Anführungszeichen escapen, die Ruby verwirren würden.

Sie können das Escapen von Anführungszeichen vollständig vermeiden, indem Sie eine andere Syntax zum Definieren von Zeichenketten verwenden.

Option 3: Alternative Syntax für Zeichenketten verwenden

Bisher haben Sie Anführungszeichen verwendet, um die Grenzen Ihrer Zeichenketten festzulegen. Sie können in Ruby Zeichenketten auch mit anderen Zeichen definieren. Sie können das Trennzeichen oder das Zeichen, mit dem Sie Ihre Zeichenkette einschließen möchten, angeben, indem Sie es nach einem Prozentzeichen angeben, wie folgt:

%$Sammy says, "I'm a happy shark!"$

Diese Syntax escapet die eingebetteten Zeichenketten automatisch für Sie. Die tatsächliche Zeichenkette sieht so aus:

"Sammy says, \"I'm a happy shark!\""

Allerdings bedeutet die Änderung des Trennzeichens, dass Sie das Trennzeichen escapen müssen, wenn Sie es verwenden müssen. In diesem Fall müssten Sie das Dollarzeichen im String escapen.

Um dies zu vermeiden, können Sie auch Paare von geschweiften Klammern, eckigen Klammern oder runden Klammern als Trennzeichen verwenden. Geschweifte Klammern sind am häufigsten:

%{Sammy says, "I'm a happy shark!"}

Diese Formen unterstützen alle die String-Interpolation, wenn Sie sie benötigen.

droplets = 5
print %{Sammy says, "I just created #{droplets} droplets!"}

Sie werden auch %Q{} und %q{} verwenden, um Strings in Ruby-Programmen zu definieren. Die Syntax %Q{} funktioniert genauso wie doppelte Anführungszeichen, das bedeutet, dass Sie doppelte Anführungszeichen nicht escapen müssen und String-Interpolation verwenden können:

droplets = 5
print %Q{Sammy says, "I just created #{droplets} droplets!"}

Die Syntax %q{} funktioniert genauso wie einfache Anführungszeichen:

%q{Sammy says, "I'm a happy shark!"}

In einigen Programmen sehen Sie möglicherweise die Syntax %q und %Q mit Klammern oder eckigen Klammern anstelle von geschweiften Klammern.

Wie Sie sehen, gibt es viele Möglichkeiten, Strings in Ruby zu erstellen. Welche Methode Sie auch wählen, bleiben Sie in Ihrem Code konsistent. Sie werden feststellen, dass die Methoden %Q{} und %{} am häufigsten verwendet werden.

Jetzt, da Sie wissen, wie Sie mit Sonderzeichen umgehen, schauen wir uns an, wie man lange Strings und Zeilenumbrüche behandelt.

Lange Strings und Zeilenumbrüche

Es gibt Zeiten, in denen Sie ein Newline-Zeichen oder einen Wagenrücklauf in Ihren String einfügen möchten. Sie können die Escape-Zeichen \n oder \r verwenden, um einen Zeilenumbruch im Code einzufügen:

output = "This is\na string\nwith newlines"
puts output

Dieses Programm würde diese Ausgabe erzeugen:

Output
This is
a string
with newlines

Dies funktioniert technisch, um unsere Ausgabe auf mehreren Zeilen zu erhalten. Das Schreiben eines sehr langen Strings in einer einzigen Zeile wird jedoch schnell schwer lesbar und schwer zu bearbeiten. Es gibt ein paar Lösungen.

Zuerst können Sie den Verkettungsoperator verwenden, um den String auf mehrere Zeilen aufzuteilen:

output = "This is a\n" +
"longer string\n" +
"with newlines."
puts output

Dies verbindet einfach drei Strings miteinander, ähnlich wie Sie es bereits getan haben.

Sie können auch einfach die Zeilenumbrüche direkt in den String einfügen:

output = "This is a
longer string
with newlines"
puts output

Sie können auch eine der alternativen String-Syntaxen verwenden, um mehrzeilige Strings zu erstellen:

output = %{This is a
longer string
with newlines}
puts output

In beiden Beispielen fällt auf, dass wir die Newline (\n) Zeichen nicht benötigen. Diese Methode bewahrt Leerzeichen, einschließlich Einrückung und Zeilenumbrüche.

Als Ergebnis enthält die Ausgabe die Zeilenumbrüche sowie alle führenden Einrückungen, so wie dies aussieht:

Output
This is a
longer string
with newlines

Um das zu verhindern, entfernen Sie die zusätzlichen Leerzeichen aus Ihrem Code:

output = %{This is a
longer string
with newlines
}

Sie können auch mehrzeilige Strings mithilfe eines heredoc erstellen, oder „hier-Dokument“, ein Begriff, der für mehrzeilige String-Literale in Programmen verwendet wird. So würden Sie diesen Code schreiben:

output = <<-END
This is a
longer string
with newlines
END

Die Marker <<-END und END kennzeichnen den Anfang und das Ende des heredoc.

Heredocs in Ruby bewahren auch Leerzeichen auf, was bedeutet, dass wenn du den Code in der Heredoc einrückst, die führende Einrückung ebenfalls beibehalten wird. Also würde dieser Code:

output = <<-END
This is a
longer string
with newlines
END

mit zwei Leerzeichen Einrückung ausgegeben werden.

Ruby 2.3 und höher bieten die Syntax für „squiggly heredoc“, die automatisch diese führenden Leerzeichen entfernt. Ersetze den Bindestrich in der Heredoc-Definition durch eine Tilde, sodass <<- zu <<~ wird, wie folgt:

output = <<~END
This is a
longer string
with newlines
and the code is indented
but the output is not.
END

Dies erzeugt die folgende Ausgabe:

Output
This is a
longer string
with newlines
and the code is indented
but the output is not.

Dies ermöglicht es dir, Heredocs zu verwenden und deinen Code schön eingerückt zu halten.

Heredocs in Ruby unterstützen auch die Zeichenketteninterpolation.

Wie du sehen kannst, gibt es viele Möglichkeiten, Zeilenumbrüche und mehrzeilige Zeichenketten in Ruby zu handhaben. Du wirst auf all diese Methoden stoßen, während du mit vorhandenem Ruby-Code arbeitest, da jedes Projekt oft seinen eigenen Stil hat. In deinem eigenen Code wähle den Stil, der zu dir passt, und sei konsequent.

Zeichenkettenreplikation

Es kann Zeiten geben, in denen du Ruby verwenden musst, um eine Zeichenkette mehrmals zu wiederholen. Das kannst du mit dem *-Operator tun. Wie der +-Operator hat der *-Operator eine andere Verwendung, wenn er mit Zahlen verwendet wird, wo er der Operator für Multiplikation ist. Wenn er mit einer Zeichenkette und einer Ganzzahl verwendet wird, ist * der Operator für die Zeichenkettenreplikation, der eine einzelne Zeichenkette so oft wiederholt, wie du es mit der bereitgestellten Ganzzahl möchtest.

Um Sammy neunmal auszudrucken, verwenden Sie den folgenden Code:

print "Sammy" * 9

Dieser Code erzeugt folgende Ausgabe:

Output
SammySammySammySammySammySammySammySammySammy

Sie können dies verwenden, um einige schöne ASCII-Kunstwerke zu erstellen. Erstellen Sie eine Datei namens banner.rb und fügen Sie den folgenden Code hinzu:

puts "=" * 15
puts "| Hello World |"
puts "=" * 15

Können Sie sich vorstellen, was das Programm produzieren wird, bevor Sie es ausführen?

Es erzeugt diese Ausgabe:

Output
===============
| Hello World |
===============

Dies ist nur ein kleines Beispiel dafür, wie Sie den Computer dazu bringen können, repetitive Aufgaben für Sie auszuführen.

Schlussfolgerung

In diesem Tutorial haben Sie gelernt, wie Sie mit dem Zeichenfolgendatentyp in der Ruby-Programmiersprache arbeiten. Sie haben neue Zeichenfolgen erstellt, sie mit anderen Zeichenfolgen verkettet und Zeilenumbrüche, Anführungszeichen und Apostrophe behandelt. Dann haben Sie Zeichenfolgeninterpolation verwendet, um das Mischen von Zeichenfolgen und Variablenwerten zu vereinfachen, und Sie haben gelernt, wie Sie Zeichenfolgen wiederholen.