Einführung
Ruby strings verfügt über zahlreiche integrierte Methoden, mit denen sich Text problemlos ändern und bearbeiten lässt. Dies ist eine häufige Aufgabe in vielen Programmen.
In diesem Lernprogramm verwenden Sie Zeichenfolgenmethoden, um die Länge einer Zeichenfolge zu bestimmen, Zeichenfolgen zu indizieren und zu teilen, um Teilzeichenfolgen zu extrahieren, Leerzeichen und andere Zeichen hinzuzufügen und zu entfernen, die Groß- und Kleinschreibung von Zeichen in Zeichenfolgen zu ändern und Text zu suchen und zu ersetzen. Wenn Sie fertig sind, können Sie diese Methoden in Ihre eigenen Programme integrieren.
Stringlänge bestimmen
Die Zeichenkettenmethode "+ Länge" gibt die Anzahl der Zeichen in einer Zeichenkette zurück. Diese Methode ist nützlich, wenn Sie minimale oder maximale Kennwortlängen erzwingen oder größere Zeichenfolgen abschneiden müssen, um bestimmte Grenzwerte für die Verwendung als Abkürzungen einzuhalten.
Hier ist ein Beispiel, das die Länge eines Satzes ausgibt:
open_source = "Sammy contributes to open source."
print open_source.lengthOutput33Beachten Sie, dass jedes Zeichen, einschließlich Buchstaben, Zahlen, Leerzeichen und Symbolen, gezählt wird, da es Teil der Zeichenfolge ist.
Um zu überprüfen, ob eine Zeichenfolge leer ist, können Sie überprüfen, ob ihre Länge "+ 0 " ist, oder Sie können die Methode " leer? +" Verwenden:
name = ""
name.empty? # true
name = "Sammy"
name.empty? # false
name = " "
name.empty? # falseSchauen wir uns an, wie wir Strings indizieren und auf den Inhalt eines Strings zugreifen.
Zugreifen auf Zeichen innerhalb eines Strings
Verwenden Sie zum Drucken oder Bearbeiten einiger Zeichen in einer Zeichenfolge die Methode "+ Slice +", um den gewünschten Teil zu erhalten.
Wie arrays, bei dem jedes Element einer Indexnummer entspricht, entspricht auch jedes Zeichen einer Zeichenfolge einem Indexnummer, beginnend mit der Indexnummer 0.
Für die Zeichenfolge "+ Sammy +" sieht die Indexaufschlüsselung folgendermaßen aus:
| 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|
S |
a |
m |
m |
y |
Mit der Methode + slice + können Sie ein einzelnes Zeichen oder einen Zeichenbereich erfassen. Wenn Sie eine einzelne Ganzzahl übergeben, wird das Zeichen an diesem Index zurückgegeben. Durch Übergabe von zwei durch Komma getrennten Ganzzahlen wird + slice + angewiesen, alle Zeichen vom ersten Index bis einschließlich zum letzten Index zurückzugeben. Die Methode + slice + akzeptiert auch einen Bereich wie + 1..4 +, um die zu extrahierenden Zeichen anzugeben:
"Sammy".slice(0) # "s"
"Sammy".slice(1,2) # "am"
"Sammy".slice(1..4) # "ammy"Die Syntax "+ [] " ist ein Alias für " slice +", sodass Sie Zeichenfolgen wie Arrays behandeln können:
"Sammy"[0] # "s"
"Sammy"[1,2] # "am"
"Sammy"[1..4] # "ammy"Sie können auch vom Ende der Zeichenfolge mit einem negativen Index auf ein einzelnes Zeichen zugreifen. Mit + -1 + können Sie auf das letzte Zeichen der Zeichenfolge zugreifen, mit + -2 + auf das vorletzte Zeichen usw.
Schließlich können Sie die Zeichenfolge mit der Methode + chars + in ein Array von Zeichen konvertieren:
"sammy".chars # ["S", "a", "m", "m", "y"]Dies kann nützlich sein, um die Zeichen in der Zeichenfolge zu bearbeiten oder zu transformieren.
Schauen wir uns als Nächstes an, wie Sie die Groß- und Kleinschreibung der Zeichen in einer Zeichenfolge ändern.
Konvertieren in Groß- und Kleinschreibung
Die Methoden + upcase + und + downcase + geben eine Zeichenfolge mit allen Buchstaben einer Originalzeichenfolge zurück, die in Groß- oder Kleinbuchstaben umgewandelt wurden. Alle Zeichen in der Zeichenfolge, die keine Buchstaben sind, werden nicht geändert.
Konvertieren wir den String "+ Sammy Shark +" in Großbuchstaben:
name = "Sammy Shark"
print name.upcaseOuputSAMMY SHARKLassen Sie uns nun die Zeichenfolge in Kleinbuchstaben umwandeln:
print name.downcaseOuputsammy sharkDie Funktionen "+ upcase " und " downcase +" erleichtern das Auswerten und Vergleichen von Zeichenfolgen, indem die Groß- und Kleinschreibung durchgehend konsistent gemacht wird. Wenn Sie beispielsweise nach einem Benutzernamen fragen und der Benutzer den Benutzernamen mit einem Großbuchstaben eingibt, können Sie die Benutzereingabe in Kleinbuchstaben eingeben und mit einem bekannten Kleinbuchstabenwert vergleichen.
Ruby-Strings haben auch eine Methode + capitalize +, die einen neuen String mit dem ersten Großbuchstaben zurückgibt:
"sammy".capitalize # "Sammy"Dies ist eine bequeme Methode, aber seien Sie vorsichtig, wie Sie sie verwenden. Es wird nur der erste Buchstabe in Großbuchstaben geschrieben, sodass es möglicherweise nicht immer zu dem von Ihnen benötigten Anwendungsfall passt.
Ruby bietet auch eine "+ swapcase +" - Methode, die einen String mit vertauschtem Gehäuse zurückgibt:
text = "Sammy"
print text.swapcasesAMMYDie Methoden + downcase +, + upcase +, + captalize + und + swapcase + geben alle eine neue Zeichenfolge zurück und lassen die vorhandene Zeichenfolge unverändert. Dies ist wichtig, damit Sie nicht vergessen, den Text sofort auszudrucken. Schauen Sie sich folgendes Beispiel an:
text = "sammy"
text.capitalize
print "Hello, #{text}!"OutputHello, sammy!Obwohl wir für die Variable "+ text " " capitalize " aufgerufen haben, haben wir den von " capitalize +" zurückgegebenen Wert nie erfasst. Wir müssten das Programm folgendermaßen umschreiben:
text = "sammy"
text = text.capitalize
print "Hello, #{text}!"OutputHello, Sammy!Sie können stattdessen "+ downcase! ", " Upcase! ", " Capitalize! " Und " swapcase! +" Verwenden, um die ursprüngliche Zeichenfolge zu ändern:
text = "sammy"
text = text.capitalize
print "Hello, #{text}!"Sei aber vorsichtig. Das Mutieren der Originalsaite hat Nachteile. Ruby bietet beide Methoden, sodass Sie diejenige auswählen können, die Ihren Anforderungen entspricht.
Lassen Sie uns nun Leerzeichen zu Strings hinzufügen und daraus entfernen.
Polstern und Strippen von Saiten
Wenn Sie ein Programm schreiben, das Text formatieren muss, werden Sie häufig feststellen, dass Sie vor, nach oder um eine Zeichenfolge ein Leerzeichen einfügen möchten, damit diese mit anderen Daten übereinstimmt. In anderen Fällen möchten Sie möglicherweise unnötige Zeichen vom Anfang oder Ende Ihrer Zeichenfolgen entfernen, z. B. zusätzliche Leerzeichen oder Sonderzeichen.
Verwenden Sie die Methode "+ center +", um eine Zeichenfolge mit Leerzeichen zu umgeben:
"Sammy",center(21) # " Sammy "Sie können eine Zeichenfolge als zweites Argument angeben, wenn Sie ein anderes Zeichen verwenden möchten:
" [Sammy] ".center(21, "<>") # "<><><> [Sammy] <><><>"Die Methoden "+ ljust " und " rjust " fügen links oder rechts von einer Zeichenfolge Leerzeichen oder Zeichen hinzu und funktionieren genau wie die Methode " center +":
"Sammy".ljust(20) # "Sammy "
"Sammy".rjust(20) # " Sammy"
"Sammy".rjust(20, "!") # "!!!!!!!!!!!!!!!Sammy"Verwenden Sie die Methode + rstrip +, um führende Leerzeichen aus einer Zeichenfolge zu entfernen. Verwenden Sie "+ lstrip ", um nachgestellte Leerzeichen zu entfernen. Verwenden Sie " strip +", um führende und nachfolgende Leerzeichen zu entfernen:
" Sammy".rstrip # "Sammy"
"Sammy ".lstrip # "Sammy"
" Sammy ".strip # "Sammy"Sie können die Methoden "+ center! ", " Ljust +"! "," + Rjust! + "," + Lstrip! + "," + Rstrip! + "Und" + strip! + "Verwenden, um das Original zu ändern Zeichenfolge.
Manchmal müssen Sie Zeichen vom Ende einer Zeichenfolge entfernen. Rubys + chop + Methode macht genau das; Es entfernt das letzte Zeichen aus einer Zeichenfolge:
"Sammy".chop # "Samm"Dies ist besonders nützlich, um das Newline-Zeichen (+ \ n +) aus Strings zu entfernen:
"This string has a newline\n".chopDie Methode + chop + lässt die ursprüngliche Zeichenfolge intakt und gibt eine neue Zeichenfolge zurück. Die Methode "+ chop! +" Ändert die vorhandene Zeichenfolge.
Die + chomp + Methode kann mehrere Zeichen vom Ende eines Strings entfernen:
"Sammy".chomp("my") # "Sam"Wenn Sie keinen zu entfernenden String angeben, entfernt "+ chomp +" die neue Zeile:
"This string has a newline\n".chomp # "This string has a newlineWenn die Zeichenfolge jedoch kein Zeilenumbruchzeichen enthält, gibt "+ chomp +" nur die ursprüngliche Zeichenfolge zurück:
"Sammy".chomp # "Sammy"Dies macht die Verwendung von "+ chomp " beim Entfernen von Zeilenumbrüchen ein wenig sicherer als die Methode " chop +", bei der immer das letzte Zeichen entfernt wird.
Ruby hat eine "+ chomp! " - Methode, die die ursprüngliche Zeichenfolge mutiert und die geänderte Zeichenfolge zurückgibt, wenn sie ersetzt wurde. Im Gegensatz zu " chomp " gibt die " chomp! " - Methode " nil +" zurück, wenn die Zeichenfolge nicht geändert wurde:
string = "Hello\n"
string.chomp! # "Hello"
string = "Hello"
string.chomp! # nilSchauen wir uns als Nächstes an, wie Sie in Zeichenfolgen nach Text suchen.
Zeichen und Text finden
Manchmal müssen Sie feststellen, ob eine Zeichenfolge eine andere Zeichenfolge enthält.
Die Methode + include? + Prüft, ob eine Zeichenkette eine andere Zeichenkette enthält. Es gibt "+ true" zurück, wenn der String existiert und "+ false", wenn nicht:
"Sammy".include?("a") # true
"Sammy".include?("b") # falseDie Methode + index + gibt den Index eines Zeichens zurück. Es kann auch den Index des ersten Zeichens einer Teilzeichenfolge identifizieren. Und es gibt "+ nil +" zurück, wenn das Zeichen oder der Teilstring nicht existiert:
"Sammy".index("a") # 1
"Sammy".index("mm") # 2
"Sammy".index("Fish") # nilDie Methode "+ index" findet jedoch nur das erste Vorkommen. Hier ist ein Beispiel mit einer längeren Zeichenfolge:
text = "Sammy has a balloon"
text.index("a") # 1Die Zeichenfolge "+ Sammy hat einen Ballon" hat vier Vorkommen des Buchstabens "a". Aber + index + hat nur das erste Vorkommen gefunden. Sie müssen etwas Spezifischeres schreiben, um eines der anderen Vorkommen zu lokalisieren.
Sie können die Zeichenfolge beispielsweise in ein Array von Zeichen konvertieren und mithilfe von array methods die Zeichenfolge durchlaufen Ergebnisse und wählen Sie die Indizes für den Charakter. Hier ist eine Methode, um dies zu tun:
text = "Sammy has a balloon"
indices = text.chars
.each_with_index
.select{|char, index| char == "a" }
.map{|pair| pair.last}
print indices[1, 7, 10, 13]+ each_with_index + gibt ein zweidimensionales Array zurück, das einen Eintrag für jedes Zeichen und seinen Index enthält. + select + schneidet es auf die Einträge ab, bei denen das Zeichen "+ a " ist, und " map +" konvertiert das zweidimensionale Array in ein eindimensionales Array der Indizes.
Zusätzlich zur Suche nach Zeichen in einer Zeichenfolge können Sie mit der Methode "+ start_with? +" Überprüfen, ob eine Zeichenfolge mit einem Zeichen oder einer Teilzeichenfolge beginnt:
text = "Sammy has a balloon"
text.start_with?("s") # true
text.start_with?("Sammy has" # trueDie Methode + start_with? + Akzeptiert mehrere Zeichenfolgen und gibt true zurück, wenn eine davon übereinstimmt:
text = "Sammy has a balloon"
text.start_with?("Sammy the Shark", "Sammy") # trueIn diesem Beispiel wird "Sammy the Shark" nicht gefunden, "Sammy" jedoch. Der Rückgabewert lautet also "+ true +".
Sie können die Methode + end_with? + Verwenden, um festzustellen, ob eine Zeichenfolge mit der angegebenen Teilzeichenfolge endet. Es funktioniert genauso wie + start_with? +:
text = "Sammy has a balloon"
text.end_with?("balloon") # true
text.end_with?("boomerang") # false
text.end_with?("boomerang", "balloon") # trueWir haben nach Möglichkeiten gesucht, Text zu finden. Schauen wir uns also an, wie dieser Text durch einen anderen Text ersetzt wird.
Ersetzen von Text in Zeichenfolgen
Mit der Funktion zum Suchen und Ersetzen in Textverarbeitungsprogrammen können Sie nach einer Zeichenfolge suchen und diese durch eine andere Zeichenfolge ersetzen. Sie können dies in Ruby mit den Methoden "+ sub" und "+ gsub" tun.
Die Methode "+ sub +" ersetzt einen Teil eines Strings durch einen anderen.
Sammy hat den Ballon nicht mehr; es flog weg. Lassen Sie uns den Teilstring "" has "" to "" had "" ändern.
balloon = "Sammy has a balloon"
print balloon.sub("has","had")Unsere Ausgabe sieht folgendermaßen aus:
OuputSammy had a balloon.Die Methode "+ sub" ersetzt nur das erste Vorkommen der Übereinstimmung durch den neuen Text. Verwenden wir einen modifizierten String, der zweimal das Wort "+ has +" enthält:
balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.sub("has","had")OutputSammy a balloon. The balloon has a ribbonNur das erste Vorkommen wurde geändert.
Um sie alle zu ändern, verwenden Sie die Methode + gsub +, die die globale Ersetzung durchführt:
balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.gsub("has","had")OutputSammy a balloon. The balloon a ribbonDie Methoden "+ sub " und " gsub +" geben immer neue Zeichenfolgen zurück, sodass die Originale unverändert bleiben. Lassen Sie uns dies demonstrieren, indem wir in unserer Zeichenfolge "Sprechblase" in "Bumerang" ändern:
text = "Sammy has a balloon"
text.gsub("ballooon", "boomerang")
print textOutputSammy has a balloonDie Ausgabe zeigt nicht das gesuchte Ergebnis an, da wir, während wir die Substitution angegeben haben, das Ergebnis von "+ gsub +" keiner neuen Variablen zugewiesen haben. Um das gewünschte Ergebnis zu erzielen, können wir das Programm folgendermaßen umschreiben:
text = "Sammy has a balloon"
text = text.sub("ballooon", "boomerang")
print textAlternativ können Sie auch "+ sub! +" Verwenden, um die ursprüngliche Zeichenfolge zu ändern. Versuchen wir es mit ein paar Saitenersetzungen. Wir werden den "roten Ballon" in "blauen Bumerang" ändern:
text = "Sammy has a red balloon"
text.sub!("red", "blue")
text.sub!("balloon", "boomerang")
print textOutputSammy has a blue boomerangSie können auch die Methode + gsub! + Verwenden, um eine globale Substitution durchzuführen.
Die Methoden "+ sub " und " gsub " akzeptieren https://www.digitalocean.com/community/tutorials/an-introduction-to-regular-expressions[regular expressions] für das Suchmuster. Lassen Sie uns alle Vokale in der Zeichenkette durch das Symbol " @ +" ersetzen:
"Sammy has a red balloon".gsub /[aeiou]/, "@""S@mmy h@s @ r@d b@ll@@n"Der Ersatzwert muss keine Zeichenfolge sein. Mit einem Hash können Sie festlegen, wie einzelne Zeichen oder Teile ersetzt werden sollen. Ersetzen wir alle Vorkommen des Buchstabens "+ a" durch "+ @ " und alle " o +" -Zeichen durch Nullen:
"Sammy has a red balloon".gsub /[aeiou]/, {"a" => "@", "o" => "0"}
# "S@mmy h@s @ rd b@ll00n"Sie können dies verwenden, um komplexere Ersetzungen mit weniger Code durchzuführen.
Fazit
In diesem Lernprogramm haben Sie mit einigen der integrierten Methoden für den Datentyp "Zeichenfolge" gearbeitet und Zeichenfolgen bearbeitet. Sie haben auch erfahren, dass es für viele Methoden zum Arbeiten mit Zeichenfolgen zwei Varianten gibt: eine, bei der die Zeichenfolge unverändert bleibt, und eine, bei der die ursprüngliche Zeichenfolge geändert wird. Welches Sie verwenden, hängt von Ihren Bedürfnissen ab. Ruby gibt Ihnen die Flexibilität zu wählen, wie Sie mit Ihren Daten arbeiten möchten. Das Schreiben von Code, der keine Änderungen an vorhandenen Daten vornimmt, kann später jedoch einfacher sein.
Schauen Sie sich unbedingt diese zugehörigen Tutorials an, um weitere Informationen zum Umgang mit Daten in Ruby zu erhalten: