Einführung
Ein string ist eine Folge von einem oder mehreren Zeichen, die aus Buchstaben, Zahlen oder Symbolen bestehen können.
Strings in Ruby sind Objekte, und im Gegensatz zu anderen Sprachen sind Zeichenfolgen mutable, dh, sie können geändert werden anstatt neue Zeichenfolgen zu erstellen.
Sie werden in fast jedem Programm, das Sie schreiben, Zeichenfolgen verwenden. Mit Strings können Sie Ihre Benutzer mithilfe von Text anzeigen und mit ihnen kommunizieren. Tatsächlich besteht die Seite, die Sie gerade lesen, aus Zeichenfolgen, die über Ihren Webbrowser auf Ihrem Bildschirm angezeigt werden. Streicher sind eine der wichtigsten Grundlagen der Programmierung.
In diesem Tutorial erfahren Sie, wie Sie mit Strings in Ruby arbeiten. Sie erstellen Zeichenfolgen, zeigen sie auf dem Bildschirm an, speichern sie in Variablen, fügen mehrere Zeichenfolgen zusammen und lernen, wie Sie mit Sonderzeichen wie Zeilenumbrüchen, Apostrophen und doppelten Anführungszeichen umgehen.
Strings erstellen und drucken
Zeichenfolgen stehen in Ruby entweder in einfachen Anführungszeichen ("" + ") oder in doppelten Anführungszeichen (" + ""). Um eine Zeichenfolge zu erstellen, müssen Sie eine Zeichenfolge in die eine oder andere einschließen:
'This is a string in single quotes.'
"This is a string in double quotes."Sie können zwischen einfachen und doppelten Anführungszeichen wählen. In den meisten Fällen spielt es keine Rolle, welchen Sie wählen, solange Sie konsistent sind. Mit doppelten Anführungszeichen können Sie jedoch eine String-Interpolation ausführen, die Sie in diesem Lernprogramm 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 + zeigt den String genau so an, wie er geschrieben wurde.
Versuch es. https://www.digitalocean.com/community/tutorials/how-to-write-your-first-ruby-pragramsCreate a new Ruby program] namens "+ print.rb " mit Ihrem Texteditor und verwenden Sie " print +" `um drei Zeichenketten zu drucken:
print.rb
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.rbSie sehen die folgende Ausgabe:
OutputThis is the first string.This is the second string.This is the third string.Anstelle der drei Zeichenfolgen, die in eigenen Zeilen gedruckt wurden, wurden alle drei Zeichenfolgen zusammen in einer einzelnen Zeile gedruckt. Mit der Methode "+ print +" wird die Zeichenfolge auf dem Bildschirm gedruckt. Wenn Sie jedoch möchten, dass jede Zeichenfolge in einer eigenen Zeile steht, müssen Sie selbst ein Zeilenumbruchzeichen hinzufügen.
Wenn Sie alle drei Zeichenfolgen in separaten Zeilen verwenden möchten, verwenden Sie stattdessen die Methode "+ puts ". Ändern Sie Ihr Programm so, dass anstelle von " print" "+ puts" verwendet werden:
print.rb
'This is the first string.'
'This is the second string.'
'This is the third string.'Führen Sie das Programm jetzt erneut aus und Sie werden die folgende Ausgabe sehen:
OutputThis is the first string.
This is the second string.
This is the third string.Die Methode + puts + druckt die von Ihnen angegebene Zeichenfolge aus, fügt jedoch am Ende der Zeichenfolge ein Zeilenumbruchzeichen hinzu.
Zeichenfolgen in Variablen speichern
Variablen sind ein benannter Verweis auf eine Stelle im Speicher des Computers. Sie verwenden Variablen, um Daten zu speichern und später abzurufen.
Um eine Zeichenfolge in einer Variablen zu speichern, definieren Sie den Variablennamen und weisen Sie den Wert der Zeichenfolge zu:
my_string = 'This is my string'Verwenden Sie anschließend den Namen der Variablen, um den Wert abzurufen:
print my_stringUm dies selbst zu testen, erstellen Sie die Datei "+ string_variables.rb +" in Ihrem Editor und fügen Sie den folgenden Code hinzu:
string_variables.rb
my_name = "Sammy the Shark"
my_age = "none of your business"
puts my_name
puts my_ageDieses Programm definiert zwei Variablen: + mein_name + und mein_alter. Jeder Variablen ist eine Zeichenkette zugeordnet. Wir verwenden dann die Methode "+ puts +", um jeden String in einer eigenen Zeile auszudrucken.
Speichern Sie die Datei und führen Sie das Programm aus:
ruby string_variables.rbSie sehen die folgende Ausgabe:
OutputSammy the Shark
none of your businessDurch Zuweisen von Zeichenfolgen zu Variablen können Sie vermeiden, dass Sie immer wieder dieselbe Zeichenfolge eingeben, wenn Sie sie verwenden möchten, wodurch die Arbeit mit und die Bearbeitung von Zeichenfolgen in Ihren Programmen vereinfacht werden.
Schauen wir uns an, wie Sie Zeichenfolgen zusammenfügen, um neue Zeichenfolgen zu erstellen.
String-Verkettung
Concatenation bedeutet, dass zwei oder mehr Zeichenfolgen miteinander verbunden werden, um eine neue Zeichenfolge zu erstellen. Zur Verkettung verwenden wir den Verkettungsoperator, der durch ein "" - Symbol dargestellt wird. Das `` Symbol ist auch der Additionsoperator, wenn es mit arithmetischen Operationen verwendet wird.
So verketten Sie die Zeichenfolgen "+ sammy " und " shark +":
"sammy" + "shark"Dies würde die folgende Ausgabe erzeugen:
OutputsammysharkDie Verkettung verbindet die Zeichenfolgen von Ende zu Ende, kombiniert sie und gibt einen brandneuen Zeichenfolgenwert aus. Wenn Sie ein Leerzeichen zwischen den Wörtern "+ sammy " und " shark +" einfügen möchten, müssen Sie dieses Leerzeichen in eine der folgenden Zeichenfolgen einfügen:
"sammy " + "shark"Jetzt schreiben Sie in einem Programm nicht wirklich Code wie diesen, aber Sie müssen Zeichenfolgen und Variablen ziemlich oft miteinander mischen, und hier kommt die Verkettung ins Spiel.
Hier ist ein Beispiel:
color = "Blue"
print "My favorite color is " + colorDies würde zu der Ausgabe "+ Meine Lieblingsfarbe ist blau " führen. Beachten Sie, dass wir in der Zeichenfolge ein Leerzeichen hinter dem Wort " ist +" gelassen haben, damit die Ausgabe ein Leerzeichen zwischen der Zeichenfolge und dem Wert der Variablen in der Ausgabe enthält.
Sie können auf diese Weise mehrere Zeichenfolgen miteinander verknüpfen. Erstellen Sie die Datei + concatenation.rb + und fügen Sie diesen Code hinzu:
concatenation.rb
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_string +", jede mit einem eigenen zugewiesenen String, genau wie Sie es zuvor getan haben. Anstatt die Werte zu drucken, wird diesmal eine Zeichenfolge gedruckt, die Verkettung verwendet, um diese Werte mit mehr Kontext zu drucken.
Wenn Sie dieses Programm ausführen, wird die folgende Ausgabe angezeigt:
OutputMy 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 diese Zeichenfolge einzufügen.
Wenn Sie zwei oder mehr Zeichenfolgen durch Verketten kombinieren, erstellen Sie eine neue Zeichenfolge, die Sie im gesamten Programm verwenden können. Daher möchten Sie die erstellte Zeichenfolge möglicherweise einer neuen Variablen zuweisen, die Sie später verwenden können:
concatenation.rb
my_name = "Sammy the Shark"
my_age = "none of your business"
# assign concatenated string to variable
output = "My name is " + my_name + " and my age is " + my_age + "."
# Print the output.
puts outputIn einem kleinen Programm wie diesem ist die Verwendung einer zusätzlichen "+ output +" - Variablen wahrscheinlich nicht erforderlich. In größeren Programmen möchten Sie möglicherweise eine Zeichenfolge mithilfe einer Verkettung erstellen, die Sie an mehreren Stellen verwenden. Es ist auch eine gute Angewohnheit, 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 die Verwaltung zu vereinfachen.
Verwenden Sie den Operator "+" nicht zwischen zwei verschiedenen Datentypen. Sie können beispielsweise keine Zeichenfolgen und Ganzzahlen miteinander verketten.
Um zu sehen, was passiert, erstellen Sie ein neues Programm mit dem Namen "+ strings_and_integers.rb +" und folgendem Inhalt:
strings_and_integers.rb
my_name = "Sammy the Shark"
my_number = 27
print my_name + my_numberDiesmal haben wir "+ mein_name ", der den String " Sammy the Shark " enthält, und " meine_nummer ", der die Ganzzahl " 27 " enthält. Wir wissen, dass " 27 +" kein String ist, da er von Anführungszeichen umgeben ist. Es gibt auch kein Dezimalzeichen. Wir wissen also, dass es sich um eine Ganzzahl handelt.
Wenn Sie das Programm ausführen:
ruby strings_and_ints.rbDiese Fehlermeldung wird angezeigt:
Outputstrings_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 mit dem vorhandenen String verketten kann.
Wir können unser Programm ändern und die Zahl "+ 27 " in Anführungszeichen ("" 27 "+") setzen, sodass sie als Zeichenfolge anstelle einer Ganzzahl deklariert wird. Oder wir können die Zahl in eine Zeichenfolge konvertieren, wenn wir die Zeichenfolge erstellen, wie folgt:
strings_and_integers.rb
my_name = "Sammy the Shark"
my_number = 27
print my_name + my_numberDie Methode + .to_s + konvertiert die Ganzzahl in einen String. Dies ist ein besserer Ansatz, da wir dadurch unsere Zahl als Ganzzahl in unserem Programm behalten können. Wir brauchen es nur, um eine Zeichenkette zu sein, wenn wir es ausdrucken, aber wir möchten vielleicht, dass es eine ganze Zahl ist, wenn wir es in anderen Teilen unserer Programmlogik verwenden müssen.
Führen Sie das Programm erneut aus, und auf dem Bildschirm wird "+ Sammy the Shark27 +" angezeigt.
Das Konvertieren von Zahlen in Zeichenfolgen zur Verkettung tritt häufig auf, wenn Sie mit Postleitzahlen, Währungen, Telefonnummern und anderen numerischen Daten arbeiten, die neben Text auf dem Bildschirm angezeigt werden sollen.
Verkettung ist mächtig, kann aber schwierig sein. Wenn Sie versehentlich einen der + - Operatoren weglassen, kann ein Syntaxfehler auftreten. Und wenn Sie Zeichenfolgen mit Variablen verbinden müssen, die Zahlen enthalten, müssen Sie die Variablen in Zeichenfolgen konvertieren. Ruby bietet eine weitere Möglichkeit, Variablenwerte in eine Zeichenfolge mit der Bezeichnung string interpolation einzufügen, mit der diese beiden Probleme behoben werden.
Verwenden der Zeichenfolgeninterpolation
Bei der Verkettung von Zeichenfolgen und Variablen kann die Ausgabe schwer zu lesen und zu debuggen sein. Die String-Interpolation löst dieses Problem, indem Sie Ausdrücke in einen in doppelte Anführungszeichen eingeschlossenen String einbetten können.
Anstatt dies zu schreiben:
"My name is " + my_name + "!"Du kannst das:
"My name is #{my_name}!"Anstatt den String zu beenden und den Operator "+" zu verwenden, schließen Sie die Variable mit der Syntax "+ # {} +" ein. Diese Syntax weist Ruby an, den Ausdruck auszuwerten und in die Zeichenfolge einzufügen.
Versuch es. Erstellen Sie ein neues Programm mit dem Namen "+ interpolation.rb +" und fügen Sie diesen Code hinzu:
interpolation.rb
my_name = "Sammy the Shark"
my_age = "none of your business"
output = "My name is #{my_name} and my age is #{my_age}."
puts outputDies ist dasselbe Programm, das Sie bereits geschrieben haben, diesmal verwenden wir jedoch die String-Interpolation, um die Ausgabe zu erstellen.
Die Zeichenfolgeninterpolation 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, aber ändern Sie die letzte Zeile so, dass sie wie folgt aussieht:
strings_and_integers.rb
my_name = "Sammy the Shark"
my_number = 27
# use interpolation instead of concatenation
print "My name is #{my_name} and my favorite number is #{my_number}."Ruby konvertiert automatisch "+ meine_Nummer +" in einen String und Ihr Programm gibt die folgende Ausgabe aus, wenn Sie es ausführen:
OutputMy name is Sammy the Shark and my favorite number is 27.Die String-Interpolation ist leistungsstark und komfortabel. Dies ist auch die bevorzugte Methode zum Verketten von Zeichenfolgen mit Variablen.
String-Literale und String-Werte
Beachten Sie, dass alle von Ihnen erstellten Zeichenfolgen im Code in Anführungszeichen gesetzt sind, die gedruckte Ausgabe jedoch keine Anführungszeichen enthält.
Es gibt einen Unterschied, wenn man sich auf diese bezieht. Ein string-Literal ist die Zeichenfolge, wie sie im Quellcode geschrieben ist, einschließlich Anführungszeichen. Ein String-Wert ist das, was Sie in der Ausgabe sehen, und enthält keine Zitate.
Dies ist ein String-Literal:
"Sammy the Shark"Der String-Wert 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 in Ihren Zeichenfolgen Sonderzeichen wie Anführungszeichen oder Apostrophe verwenden.
Anführungszeichen und Apostrophe in Strings
Aufgrund der Tatsache, dass Anführungszeichen zur Bezeichnung von Zeichenfolgen verwendet werden, müssen Sie ein wenig zusätzliche Arbeit leisten, wenn Sie Apostrophe und Anführungszeichen in Zeichenfolgen verwenden möchten.
Wenn Sie versuchen, ein Apostroph in der Mitte einer Zeichenfolge in Anführungszeichen zu setzen, gehen Sie wie folgt vor:
'This isn't what I wanted.'Das Apostroph in "+ ist nicht +" beendet die Zeichenfolge, wie Sie an der seltsamen Hervorhebung in diesem Beispiel sehen können. Infolgedessen versucht der Ruby-Interpreter, den Rest der beabsichtigten Zeichenfolge als Code zu analysieren, und es wird eine Fehlermeldung angezeigt.
Dieselbe Situation würde auftreten, wenn Sie doppelte Anführungszeichen in einer Zeichenfolge verwenden, die in doppelte Anführungszeichen eingeschlossen ist:
"Sammy says, "Hello!""In diesem Beispiel wird die Zeichenfolge durch das schließende Anführungszeichen vor "+ Hello " beendet, und durch das Anführungszeichen nach " Hello! +" Wird eine neue Zeichenfolge erstellt, die kein übereinstimmendes Anführungszeichen zum Beenden enthält. Ruby wird dies tun einen Fehler anzeigen.
Um dieses Problem zu vermeiden, haben Sie einige Möglichkeiten. Erstens können Sie die alternative Syntax zum Erstellen von Zeichenfolgen verwenden. Wenn Sie doppelte Anführungszeichen in der Zeichenfolge verwenden müssen, definieren Sie die Zeichenfolge in einfachen Anführungszeichen und umgekehrt. Sie können auch die Anführungszeichen austreten oder eine andere Ruby-Syntax verwenden, um die Zeichenfolgen zu definieren. Schauen wir uns jeden Ansatz an.
Option 1: Verwenden Sie die alternative Zeichenfolgensyntax
Der einfachste Weg, um diese Probleme zu umgehen, besteht darin, die Zeichenfolge in einfache Anführungszeichen zu setzen, wenn die Zeichenfolge ein doppeltes Anführungszeichen enthalten muss, und die Zeichenfolge in doppelte Anführungszeichen zu setzen, wenn die Zeichenfolge einfache Anführungszeichen verwenden muss.
Anstatt diesen String mit einfachen Anführungszeichen zu definieren:
'This isn't what I wanted.'Definiere es mit doppelten Anführungszeichen:
"This isn't what I wanted."Und anstatt doppelte Anführungszeichen zu verwenden, um diese Zeichenfolge zu definieren:
"Sammy says, "Hello!""Verwenden Sie einfache Anführungszeichen:
'Sammy says, "Hello!"'Wenn Sie die alternative Syntax verwenden, können Sie einige schnelle Staus beheben, dies funktioniert jedoch nicht immer. Beispielsweise funktioniert keiner der beiden Ansätze für diese Zeichenfolge:
"Sammy says, "I'm a happy shark!""In diesem Beispiel wirft das schließende doppelte Anführungszeichen vor "+ Ich bin " die Dinge wirklich ab. Dies beendet die erste Zeichenkette und Ruby trifft in " I’m " auf das Apostroph, wodurch eine neue Zeichenkette mit dem Wert " m a happy shark!" "+" Beginnt. Diese neue Zeichenfolge enthält jedoch kein übereinstimmendes einfaches Anführungszeichen, um sie zu beenden. Wenn Sie die Zeichenfolge in einfache Anführungszeichen setzen, tritt ein ähnliches Problem auf:
'Sammy says, "I'm a happy shark!"'Diesmal beendet der Apostroph in "+ Ich bin +" die Zeichenkette.
Die Verwendung der alternativen Syntax kann Ihren Code auch inkonsistent machen. Das ständige Umblättern der Zeichenfolgensyntax kann verwirrend sein. Wir können Zeichen umgehen, um dieses Problem zu umgehen.
Option 2: Escapezeichen in Zeichenfolgen
Das Backslash-Zeichen (+ \ +), in Strings oft als escape-Zeichen bezeichnet, verhindert, dass Ruby das nächste Zeichen im String wörtlich interpretiert.
Hier ist unsere problematische Zeichenfolge, die in doppelte Anführungszeichen und in doppelte Anführungszeichen eingeschlossen ist:
"Sammy says, "I'm a happy shark!""Erstellen Sie ein neues Ruby-Programm mit dem Namen "+ quoting.rb +" und fügen Sie den folgenden Code zur Datei hinzu:
quoting.rb
print "Sammy says, "I'm a happy shark!""Führen Sie das Programm aus:
ruby quoting.rbUnd Sie werden diese Ausgabe sehen:
Outputquoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "Sammy says, "I'm a happy shark!""
^Verwenden Sie den umgekehrten Schrägstrich vor den inneren Anführungszeichen, um den Fehler zu beheben:
quoting.rb
print "Sammy says, \"I'm a happy shark!\""Führen Sie das Programm dann erneut aus und Sie sehen die erwartete Ausgabe:
Sammy says, "I'm a happy shark!"Beachten Sie, dass Sie in diesem Beispiel nicht dem Apostroph entkommen müssen, da es keinen Konflikt gibt. Sie müssen nur Anführungszeichen umgehen, die Ruby verwirren.
Sie können das Entweichen von Anführungszeichen ganz vermeiden, indem Sie Zeichenfolgen mit einer anderen Syntax definieren.
Option 3: Verwenden alternativer Syntax für Zeichenfolgen
Bisher haben Sie Anführungszeichen verwendet, um die Grenzen Ihrer Zeichenfolgen zu definieren. Sie können Zeichenfolgen in Ruby auch mit anderen Zeichen erstellen. Sie können den Delimiter oder das Zeichen definieren, das Sie zum Einschließen der Zeichenfolge verwenden möchten, indem Sie es nach einem Prozentzeichen wie folgt angeben:
%$Sammy says, "I'm a happy shark!"$Diese Syntax wird den eingebetteten Zeichenfolgen automatisch entzogen. Die tatsächliche Zeichenfolge sieht folgendermaßen aus:
"Sammy says, \"I'm a happy shark!\""Das Ändern des Trennzeichens bedeutet jedoch, dass Sie das Trennzeichen verlassen müssen, wenn Sie es verwenden möchten. In diesem Fall. Wenn Sie in Ihrer Zeichenfolge ein Dollarzeichen verwenden müssen, müssen Sie das wörtliche Dollarzeichen in der Zeichenfolge umgehen.
Um dies zu vermeiden, können Sie auch Klammerpaare, eckige Klammern oder runde Klammern als Begrenzer verwenden. Geschweifte Klammern sind am häufigsten:
%{Sammy says, "I'm a happy shark!"}Diese Formulare unterstützen bei Bedarf die Interpolation von Zeichenfolgen.
droplets = 5
print %{Sammy says, "I just created #{droplets} droplets!"}Außerdem sehen Sie "% Q {} +" und "% q {} ", die zum Definieren von Zeichenfolgen in Ruby-Programmen verwendet werden. Die Syntax "% Q {} +" funktioniert genau wie Zeichenfolgen in doppelten Anführungszeichen. Das bedeutet, dass Sie keine doppelten Anführungszeichen einfügen müssen und die Zeichenfolgeninterpolation verwenden können:
droplets = 5
print %Q{Sammy says, "I just created #{droplets} droplets!"}Die Syntax +% q {} + funktioniert genauso wie Zeichenfolgen in einfachen Anführungszeichen:
%q{Sammy says, "I'm a happy shark!"}In einigen Programmen wird möglicherweise die Syntax "% q +" und "% Q +" angezeigt, die in Klammern oder eckigen Klammern anstelle von geschweiften Klammern verwendet wird.
Wie Sie sehen, gibt es in Ruby viele Möglichkeiten, Zeichenfolgen zu erstellen. Egal für welche Methode Sie sich entscheiden, seien Sie in Ihrem Code konsistent. Sie werden feststellen, dass die Methoden "% Q {} +" und "% {} +" am häufigsten verwendet werden.
Nachdem Sie nun wissen, wie Sie mit Sonderzeichen umgehen, wollen wir uns ansehen, wie Sie mit langen Zeichenfolgen und Zeilenumbrüchen umgehen.
Lange Streicher und Zeilenumbrüche
Es kann vorkommen, dass Sie ein Zeilenumbruchzeichen oder einen Zeilenumbruch in Ihre Zeichenfolge einfügen möchten. Sie können die Escape-Zeichen + \ n + oder + \ r + verwenden, um eine neue Zeile in den Code einzufügen:
output = "This is\na string\nwith newlines"
puts outputDieses Programm würde diese Ausgabe erzeugen:
OutputThis is
a string
with newlinesDies funktioniert technisch, um unsere Ausgabe in mehreren Zeilen zu erhalten. Das Schreiben einer sehr langen Zeichenfolge in einer einzelnen Zeile wird jedoch schnell sehr schwer zu lesen und zu verarbeiten sein. Es gibt einige Lösungen.
Zunächst können Sie den Verkettungsoperator verwenden, um die Zeichenfolge in mehrere Zeilen aufzuteilen:
output = "This is a\n" +
"longer string\n" +
"with newlines."
puts outputDies verkettet nur drei Zeichenfolgen miteinander, ähnlich dem, was Sie bereits getan haben.
Sie können auch einfach die Zeilenumbrüche direkt in die Zeichenfolge einfügen:
output = "This is a
longer string
with newlines"
puts outputSie können auch eine der alternativen Zeichenfolgensyntaxen verwenden, um mehrzeilige Zeichenfolgen zu erstellen:
output = %{This is a
longer string
with newlines}
puts outputBeachten Sie in beiden Beispielen, dass wir keine Zeilenumbrüche (+ \ n +) benötigen. Bei diesem Ansatz bleiben Leerzeichen, einschließlich Einrückungen und Zeilenumbrüchen, erhalten.
Infolgedessen enthält die Ausgabe die Zeilenumbrüche sowie alle führenden Einrückungen wie folgt:
OutputThis is a
longer string
with newlinesUm dies zu verhindern, entfernen Sie das zusätzliche Leerzeichen aus Ihrem Code:
output = %{This is a
longer string
with newlines
}Sie können auch mehrzeilige Zeichenfolgen mit einem _https: //en.wikipedia.org/wiki/Here_document [heredoc] _ oder "here document" erstellen, einem Begriff, der für mehrzeilige Zeichenfolgenliterale in Programmen verwendet wird. So schreiben Sie diesen Code:
output = <<-END
This is a
longer string
with newlines
ENDDie Markierungen "+ << - END" und "+ END" kennzeichnen den Anfang und das Ende des Heredocs.
Heredocs in Ruby behalten auch Leerzeichen bei. Wenn Sie also den Code im Heredoc einrücken, bleibt auch der führende Einzug erhalten. Also dieser Code:
output = <<-END
This is a
longer string
with newlines
ENDwürde mit zwei Einrückungen drucken.
Ruby 2.3 und höher enthält die Syntax "squiggly heredoc", die dieses führende Leerzeichen automatisch entfernt. Ersetzen Sie den Bindestrich in der Heredoc-Definition durch eine Tilde, sodass aus "+ << - " " << ~ +" wird.
output = <<~END
This is a
longer string
with newlines
and the code is indented
but the output is not.
ENDDies erzeugt die folgende Ausgabe:
OutputThis is a
longer string
with newlines
and the code is indented
but the output is not.Auf diese Weise können Sie heredocs verwenden und Ihren Code gut eingerückt lassen.
Heredocs in Ruby unterstützt auch die String-Interpolation.
Wie Sie sehen, gibt es in Ruby viele Möglichkeiten, mit Zeilenumbrüchen und mehrzeiligen Zeichenfolgen umzugehen. Sie werden all diese Methoden kennenlernen, wenn Sie mit vorhandenem Ruby-Code arbeiten, da jedes Projekt seinen eigenen Stil hat. Wählen Sie in Ihrem eigenen Code den für Sie passenden Stil und seien Sie konsistent.
String-Replikation
Es kann vorkommen, dass Sie Ruby verwenden müssen, um eine Zeichenfolge mehrmals zu wiederholen. Sie können dies mit dem Operator "+ * " tun. Wie der Operator "+" hat der Operator " * " eine andere Verwendung, wenn er mit Zahlen verwendet wird, wobei er der Operator für die Multiplikation ist. Bei Verwendung mit einer Zeichenfolge und einer Ganzzahl ist " * +" der Zeichenfolgenreplikationsoperator, der eine einzelne Zeichenfolge wiederholt, wie oft Sie die von Ihnen angegebene Ganzzahl verwenden möchten.
Um "+ Sammy +" neun Mal auszudrucken, verwenden Sie den folgenden Code:
print "Sammy" * 9Dieser Code erzeugt die folgende Ausgabe:
OutputSammySammySammySammySammySammySammySammySammySie können dies verwenden, um einige schöne ASCII-Grafiken zu erstellen. Erstellen Sie eine Datei mit dem Namen "+ banner.rb +" und fügen Sie den folgenden Code hinzu:
puts "=" * 15
puts "| Hello World |"
puts "=" * 15Kö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, sich wiederholende Aufgaben für Sie auszuführen.
Fazit
In diesem Tutorial haben Sie gelernt, wie Sie mit dem Datentyp String in der Programmiersprache Ruby arbeiten. Sie haben neue Zeichenfolgen erstellt, sie mit anderen Zeichenfolgen verkettet und Zeilenumbrüche, Anführungszeichen und Apostrophe verarbeitet. Dann haben Sie die Zeichenfolgeninterpolation verwendet, um das Mischen von Zeichenfolgen und variablen Werten zu vereinfachen, und Sie haben gelernt, wie Zeichenfolgen wiederholt werden.