Hoe te werken met Strings in Ruby

Inleiding

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

Strings in Ruby zijn objecten en in tegenstelling tot andere talen zijn strings veranderlijk, wat betekent dat ze ter plaatse kunnen worden gewijzigd in plaats van nieuwe strings te maken.

U zult bijna elk programma dat u schrijft, strings gebruiken. Strings stellen u in staat om tekst weer te geven en te communiceren met uw gebruikers. In feite bestaat de pagina die u nu leest uit strings die op uw scherm worden weergegeven via uw webbrowser. Strings zijn een van de belangrijkste fundamenten van programmeren.

In deze handleiding leert u hoe u met strings in Ruby kunt werken. U zult strings maken, ze op het scherm weergeven, ze opslaan in variabelen, meerdere strings samenvoegen en leren hoe u speciale tekens zoals regelafbrekingen, apostrofs en dubbele aanhalingstekens kunt behandelen.

Strings maken en afdrukken

Strings bestaan in Ruby binnen enkele aanhalingstekens ' of dubbele aanhalingstekens ", dus om een string te maken, sluit u een reeks tekens in een van de twee in:

'This is a string in single quotes.'

"This is a string in double quotes."

Je kunt kiezen tussen enkele aanhalingstekens of dubbele aanhalingstekens. In de meeste gevallen maakt het niet uit welke je kiest, zolang je maar consistent bent. Het gebruik van dubbele aanhalingstekens stelt je echter in staat om string interpolatie uit te voeren, waar je in deze tutorial meer over zult leren.

Om een string in je programma weer te geven, kun je de print-methode gebruiken:

print "Let's print out this string."

De print-methode geeft de string precies weer zoals deze is geschreven.

Probeer het uit. Maak een nieuw Ruby-programma genaamd print.rb met behulp van je teksteditor en gebruik de print-methode om drie strings af te drukken:

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

Sla het bestand op en voer het programma uit:

ruby print.rb

Je zult de volgende uitvoer zien:

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

In plaats van de drie strings die op hun eigen regels zijn afgedrukt, zijn alle drie de strings samen op één regel afgedrukt. De print-methode drukt de string af op het scherm, maar als je elke string op een eigen regel wilt, moet je zelf een regeleindekarakter toevoegen.

Als je alle drie de strings op afzonderlijke regels wilt, gebruik dan in plaats daarvan de puts-methode. Pas je programma aan om puts in plaats van print te gebruiken:

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

Voer het programma nu opnieuw uit, en je zult deze uitvoer zien:

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

De puts-methode drukt de opgegeven string af, maar voegt ook een regeleindekarakter toe aan het einde van de string.

Strings Opslaan in Variabelen

Variabelen zijn een benoemde verwijzing naar een locatie in het geheugen van de computer. Je gebruikt variabelen om gegevens op te slaan en later op te halen.

Om een string in een variabele op te slaan, definieer je de variabelenaam en wijs je de waarde van de string toe:

my_string = 'This is my string'

Vervolgens, om de waarde op te halen, gebruik je de naam van de variabele:

print my_string

Om dit zelf uit te proberen, maak het bestand string_variables.rb in je editor met de volgende opdracht:

nano string_variables.rb

Voeg vervolgens de volgende code toe:

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

puts my_name
puts my_age

Deze programma definieert twee variabelen: my_name en my_age. Aan elke variabele wordt een string toegewezen. We gebruiken dan de puts-methode om elke string op een eigen regel af te drukken.

Sla het bestand op met CTRL + X en y, voer dan het programma uit:

ruby string_variables.rb

Je ziet de volgende output:

Output
Sammy the Shark
none of your business

Door strings aan variabelen toe te wijzen, kun je voorkomen dat je elke keer dezelfde string moet typen wanneer je deze wilt gebruiken, waardoor het gemakkelijker wordt om met strings te werken en ze te manipuleren in je programma’s.

Laten we nu kijken hoe we strings kunnen samenvoegen om nieuwe strings te maken.

String Concatenatie

Concatenatie betekent het samenvoegen van twee of meer strings om een nieuwe string te creëren. Om te concatenaten, gebruiken we de concatenatie-operator, voorgesteld door het symbool +. Het symbool + is ook de opteloperator wanneer het wordt gebruikt bij rekenkundige bewerkingen.

Hier is hoe je de strings sammy en shark zou concatenaten:

"sammy" + "shark"

Dit zou de volgende uitvoer produceren:

Output
sammyshark

Concatenatie voegt de strings achter elkaar, combineert ze en geeft een geheel nieuwe stringwaarde weer. Als je een spatie wilt hebben tussen de woorden sammy en shark, moet je die spatie opnemen in een van de strings, zoals dit:

"sammy " + "shark"

Nu, je zou niet echt code schrijven als deze in een programma, maar je zult vaak strings en variabelen moeten combineren, en daar komt concatenatie van pas.

Hier is een voorbeeld:

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

Dit zou resulteren in de uitvoer Mijn favoriete kleur is blauw. Let op dat we een spatie hebben achtergelaten na het woord is in de string, zodat de uitvoer een spatie heeft tussen de string en de waarde van de variabele in de uitvoer.

Je kunt op deze manier meerdere strings concatenaten. Maak het bestand concatenation.rb aan en voeg deze code toe:

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

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

Dit programma definieert twee variabelen: my_name en my_age, elk met zijn eigen toegewezen string, net zoals je eerder hebt gedaan. Maar deze keer printen we in plaats van de waarden, een string die concatenatie gebruikt om die waarden met wat meer context af te drukken.

Wanneer je dit programma uitvoert, zie je de volgende uitvoer:

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

In dit kleine programma heb je concatenatie gebruikt om variabelen in deze string in te voegen.

Wanneer je twee of meer strings combineert via concatenatie, maak je een nieuwe string die je gedurende je programma kunt gebruiken. Je wilt mogelijk de gemaakte string toewijzen aan een nieuwe variabele die je later kunt gebruiken:

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

# wijs de geconcateneerde string toe aan een variabele
output = "My name is " + my_name + " and my age is " + my_age + "."

# Druk de output af.
puts output

In een klein programma als dit is het waarschijnlijk onnodig om een extra output variabele te gebruiken. Maar in grotere programma’s wil je mogelijk een string maken met concatenatie die je op meerdere plaatsen zult gebruiken. Het is ook een goede gewoonte om gegevensverwerking zoals concatenatie en rekenkunde te scheiden van de uitvoer, omdat je programma’s uiteindelijk groter zullen worden en je de logica en uitvoer in aparte bestanden of componenten wilt scheiden om ze gemakkelijker te beheren.

Zorg ervoor dat je de +-operator niet gebruikt tussen twee verschillende gegevenstypen. Je kunt bijvoorbeeld geen strings en integers samenvoegen.

Om te zien wat er gebeurt, maak een nieuw programma genaamd strings_and_integers.rb met de volgende inhoud:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

Deze keer hebben we my_name die de string Sammy the Shark bevat en my_number die het geheel getal 27 bevat. We weten dat 27 geen string is omdat het niet tussen aanhalingstekens staat. Het heeft ook geen decimaalteken, dus we weten dat het een geheel getal is.

Als je het programma uitvoert:

ruby strings_and_ints.rb

Je zult dit foutbericht zien:

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

De fout geen impliciete conversie van Integer naar String betekent dat Ruby alleen een string kan concatenaten met de bestaande string.

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

We kunnen ons programma aanpassen en het getal 27 tussen aanhalingstekens plaatsen ("27") zodat het wordt aangegeven als een string in plaats van een integer. Of we kunnen het getal converteren naar een string bij het maken van de string, zoals dit:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number.to_s

De .to_s-methode zet het geheel getal om naar een string. Dit is een betere benadering, omdat het ons in staat stelt ons getal als een integer in ons programma te behouden. We hebben het alleen nodig als een string wanneer we het afdrukken, maar we willen misschien dat het een integer is als we het moeten gebruiken in andere delen van onze programmalogica.

Voer het programma opnieuw uit en je ziet Sammy de Shark27 afgedrukt op het scherm.

Het converteren van getallen naar strings voor concatenatie is iets wat je vaak zult tegenkomen bij het omgaan met postcodes, valuta, telefoonnummers en andere numerieke gegevens die je op het scherm wilt weergeven naast tekst.

Concatenatie is krachtig, maar kan lastig zijn. Als je per ongeluk een van de + operators vergeet, kun je een syntaxfout krijgen. En als je strings moet samenvoegen met variabelen die nummers bevatten, moet je de variabelen omzetten naar strings. Ruby biedt een andere manier om variabele waarden in een string te injecteren, genaamd string interpolatie dat beide problemen aanpakt.

Gebruik van string interpolatie

Wanneer je strings en variabelen aan elkaar koppelt, kan de uitvoer moeilijk te lezen en te debuggen zijn. String interpolatie lost dit op door je toe te staan expressies in een string in te sluiten tussen dubbele aanhalingstekens.

In plaats van dit te schrijven:

"My name is " + my_name + "!"

Kun je dit doen:

"My name is #{my_name}!"

In plaats van de string te beëindigen en de + operator te gebruiken, sluit je de variabele in met de #{} syntax. Deze syntax vertelt Ruby om de expressie te evalueren en in de string in te voegen.

Probeer het uit. Maak een nieuw programma genaamd interpolation.rb en voeg deze code toe:

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

Dit is hetzelfde programma dat je al hebt geschreven, maar deze keer gebruiken we string interpolatie om de uitvoer te genereren.

String interpolatie heeft nog een ander voordeel: het kan numerieke waarden automatisch omzetten naar strings. Herinner je je het programma strings_and_integers.rb nog? Open dat bestand opnieuw in je editor maar verander de laatste regel zodat het er als volgt uitziet:

my_name = "Sammy the Shark"
my_number = 27

# gebruik interpolatie in plaats van concatenatie
print "My name is #{my_name} and my favorite number is #{my_number}."

Ruby zal automatisch my_number naar een string converteren, en je programma zal de volgende output afdrukken wanneer je het uitvoert:

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

String-interpolatie is krachtig en handig. Het is ook de voorkeursmethode voor het samenvoegen van strings met variabelen.

String-literals en String-waarden

Let op dat alle strings die je hebt gemaakt, tussen aanhalingstekens staan in de code, maar de daadwerkelijke afgedrukte output bevat de aanhalingstekens niet.

Er is een onderscheid bij verwijzing naar elk van deze. Een string-literal is de string zoals deze in de broncode is geschreven, inclusief aanhalingstekens. Een string-waarde is wat je ziet in de output en bevat geen aanhalingstekens.

Dit is een string-literal:

"Sammy the Shark"

De string-waarde zou Sammy the Shark zijn.

In de meeste gevallen hoef je je geen zorgen te maken over dit verschil, tenzij je speciale tekens zoals aanhalingstekens of apostrofs in je strings wilt gebruiken.

Quotes en apostrofs ontsnappen in strings

Vanwege het feit dat aanhalingstekens worden gebruikt om strings aan te duiden, moet je wat extra werk doen als je apostrofs en aanhalingstekens in strings wilt gebruiken.

Als je probeert een apostrof te gebruiken middenin een enkelvoudig tussen enkele aanhalingstekens geplaatste string, zoals dit:

'This isn't what I wanted.'

De apostrof in isn't beëindigt de string, zoals je kunt zien aan de vreemde markering in dit voorbeeld. Als gevolg hiervan zal de Ruby-interpreter proberen de rest van de bedoelde string als code te interpreteren en zul je een foutmelding krijgen.

Je zou in dezelfde situatie belanden als je dubbele aanhalingstekens zou gebruiken in een string die tussen dubbele aanhalingstekens staat:

"Sammy says, "Hello!""

In dit voorbeeld beëindigt het sluiten van de dubbele aanhalingstekens voor Hello de string, en de dubbele aanhalingstekens na Hello! creëren een nieuwe string die geen overeenkomende dubbele aanhalingstekens heeft om het te beëindigen, dus Ruby zal een foutmelding weergeven.

Om dit probleem te vermijden, heb je een paar opties. Ten eerste kun je de alternatieve syntaxis voor het maken van strings gebruiken; als je dubbele aanhalingstekens in de string moet gebruiken, gebruik dan enkele aanhalingstekens om de string te definiëren, en vice versa. Je zou ook de aanhalingstekens kunnen ontsnappen, of je zou een andere Ruby-syntaxis kunnen gebruiken om de strings te definiëren. Laten we naar elke benadering kijken.

Optie 1: Gebruik de Alternatieve String Syntaxis

De gemakkelijkste manier om deze problemen te omzeilen, is door uw string tussen enkele aanhalingstekens te plaatsen wanneer uw string een dubbel aanhalingsteken moet bevatten, en uw string tussen dubbele aanhalingstekens te plaatsen wanneer uw string enkele aanhalingstekens moet gebruiken.

In plaats van deze string te definiëren met enkele aanhalingstekens:

'This isn't what I wanted.'

Definieer het met dubbele aanhalingstekens:

"This isn't what I wanted."

En in plaats van dubbele aanhalingstekens te gebruiken om deze string te definiëren:

"Sammy says, "Hello!""

Gebruik enkele aanhalingstekens:

'Sammy says, "Hello!"'

Het gebruik van de alternatieve syntaxis kan u uit een aantal snelle benarde situaties halen, maar het zal niet altijd werken. Bijvoorbeeld, geen van beide benaderingen zal werken voor deze string:

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

In dit voorbeeld gooit het sluiten van het dubbele aanhalingsteken voor I'm echt roet in het eten. Dit beëindigt de eerste string en vervolgens stuit Ruby op het apostrof in I'm, wat een nieuwe string start met de waarde m a happy shark!"". Maar deze nieuwe string heeft geen overeenkomend enkel aanhalingsteken om deze te beëindigen. En het gebruik van enkele aanhalingstekens om de string te omringen introduceert een soortgelijk probleem:

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

Deze keer beëindigt het apostrof in I'm de string.

Het gebruik van de alternatieve syntaxis kan ook uw code inconsistent maken. Voortdurend heen en weer schakelen tussen string syntaxis kan verwarrend zijn. We kunnen tekens escapen om dit probleem te omzeilen.

Optie 2: Tekens escapen in strings

Het schuine streepje (\), vaak aangeduid als het ontsnappingsteken in strings, voorkomt dat Ruby het volgende teken in de string letterlijk interpreteert.

Hier is onze problematische string, gecodeerd tussen dubbele aanhalingstekens, met dubbele aanhalingstekens erin:

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

Maak een nieuw Ruby-programma met de naam quoting.rb en voeg deze code toe aan het bestand:

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

Voer het programma uit:

ruby quoting.rb

En je zult deze uitvoer zien:

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

Om de fout op te lossen, gebruik het schuine streepje voor de binnenste dubbele aanhalingstekens:

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

Voer vervolgens het programma opnieuw uit en je ziet de verwachte uitvoer:

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

Merk op dat je in dit voorbeeld het apostrof niet hoeft te ontvluchten, omdat er geen conflict is. Je hoeft alleen aanhalingstekens te ontvluchten die Ruby in de war zouden kunnen brengen.

Je kunt het ontvluchten van aanhalingstekens volledig vermijden door een andere syntaxis te gebruiken om strings te definiëren.

Optie 3: Alternatieve syntaxis voor strings gebruiken

Tot nu toe heb je aanhalingstekens gebruikt om de grenzen van je strings te definiëren. Je kunt strings in Ruby ook maken met andere tekens. Je kunt de delimiter, of het teken dat je wilt gebruiken om je string in te sluiten, definiëren door het na een procentteken te specificeren, zoals dit:

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

Deze syntaxis zal de ingebedde strings automatisch voor je ontvluchten. De daadwerkelijke string ziet er zo uit:

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

Echter, het veranderen van de delimiter betekent dat je de delimiter moet escapen als je hem nodig hebt. In dit geval, als je een dollarteken in je string zou moeten gebruiken, zou je het letterlijke dollarteken in de string moeten escapen.

Om dit te vermijden, kun je ook paren van accolades, vierkante haken of haakjes als delimiters gebruiken. Accolades zijn het meest gebruikelijk:

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

Al deze vormen ondersteunen stringinterpolatie als je het nodig hebt.

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

Je zult ook %Q{} en %q{} zien gebruikt om strings te definiëren in Ruby-programma’s. De syntaxis %Q{} werkt precies zoals dubbel-aanhalingstekens, wat betekent dat je dubbele aanhalingstekens niet hoeft te escapen, en je zult stringinterpolatie kunnen gebruiken:

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

De syntaxis %q{} werkt precies zoals enkele aanhalingstekens:

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

Je zou de syntaxis %q en %Q kunnen zien gebruikt met haakjes of vierkante haken in sommige programma’s in plaats van accolades.

Zoals je kunt zien, zijn er veel manieren om strings te maken in Ruby. Welke methode je ook kiest, wees consistent in je code. Je zult merken dat de methoden %Q{} en %{} het meest gebruikelijk zijn.

Nu je weet hoe je speciale tekens moet behandelen, laten we eens kijken hoe je lange strings en newline-tekens behandelt.

Lange Strings en Newlines

Er zijn momenten waarop je een nieuwe regel karakter wilt invoegen, of een carriage return in je string. Je kunt de escape-karakters \n of \r gebruiken om een nieuwe regel in de code in te voegen:

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

Dit programma zou deze uitvoer produceren:

Output
This is
a string
with newlines

Dit werkt technisch gezien om onze uitvoer op meerdere regels te krijgen. Echter, het schrijven van een zeer lange string op één regel zal al snel erg moeilijk leesbaar en mee te werken worden. Er zijn een paar oplossingen.

Ten eerste, je kunt de concatenatie-operator gebruiken om de string op te splitsen over meerdere regels:

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

Dit voegt gewoon drie strings samen, vergelijkbaar met wat je al hebt gedaan.

Je kunt ook gewoon de regelafbrekingen direct in de string plaatsen:

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

Je kunt ook een van de alternatieve string-syntaxen gebruiken om meerregelige strings te maken:

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

In beide voorbeelden hoef je geen newline (\n) karakters te gebruiken. Deze aanpak behoudt de witruimte, inclusief inspringing en nieuwe regels.

Als gevolg hiervan zal de uitvoer de regelafbrekingen bevatten, evenals alle toonaangevende inspringing, zoals dit:

Output
This is a
longer string
with newlines

Om dat te voorkomen, verwijder je de extra witruimte uit je code:

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

Je kunt ook meerregelige strings maken met behulp van een heredoc, of “hier document”, een term die wordt gebruikt voor meerregelige string literals in programma’s. Zo schrijf je die code:

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

De <<-END en END markers duiden het begin en einde van de heredoc aan.

Heredocs in Ruby behouden ook spatietekens, wat betekent dat als je de code inspringt in de heredoc, de toonaangevende inspringing ook behouden blijft. Dus deze code:

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

zou worden afgedrukt met twee spaties inspringen.

Ruby 2.3 en hoger bieden de “squiggly heredoc” syntaxis die automatisch deze toonaangevende spaties verwijdert. Vervang het minteken in de heredoc-definitie door een tilde, dus <<- wordt <<~, zoals dit:

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

Dit levert de volgende uitvoer op:

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

Dit stelt je in staat om heredocs te gebruiken en je code mooi ingesprongen te houden.

Heredocs in Ruby ondersteunen ook stringinterpolatie.

Zoals je kunt zien, zijn er veel manieren om om te gaan met nieuwe regels en meerdere regels strings in Ruby. Je zult al deze methoden tegenkomen terwijl je werkt met bestaande Ruby-code, omdat elk project de neiging heeft zijn eigen stijl te hebben. Kies in je eigen code de stijl die bij je past en wees consequent.

String Replicatie

Er kunnen momenten zijn waarop je Ruby moet gebruiken om een ​​reeks tekens meerdere keren te herhalen. Je kunt dit doen met de *-operator. Net als de +-operator heeft de *-operator een andere functie bij gebruik met getallen, waar het de operator is voor vermenigvuldiging. Wanneer het wordt gebruikt met één string en één integer, is * de string-replicatie-operator, waarmee je een enkele string zo vaak kunt herhalen als je wilt met de opgegeven integer.

Om Sammy negen keer af te drukken, gebruik je de volgende code:

print "Sammy" * 9

Deze code produceert de volgende output:

Output
SammySammySammySammySammySammySammySammySammy

Je kunt dit gebruiken om wat mooie ASCII-art te maken. Maak een bestand genaamd banner.rb en voeg de volgende code toe:

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

Kun je je voorstellen wat het programma zal produceren voordat je het uitvoert?

Het produceert deze output:

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

Dit is slechts een klein voorbeeld van hoe je de computer repetitieve taken voor je kunt laten uitvoeren.

Conclusie

In deze tutorial heb je geleerd hoe je kunt werken met het stringgegevenstype in de Ruby-programmeertaal. Je hebt nieuwe strings gemaakt, ze geconcateneerd met andere strings, en omgegaan met nieuwe regels, aanhalingstekens en apostrofs. Vervolgens heb je stringinterpolatie gebruikt om het mixen van strings en variabele waarden gemakkelijker te maken, en je hebt geleerd hoe je strings kunt herhalen.