Hoe te werken met arrays in Ruby

Introductie

Een array is een gegevensstructuur die een lijst van waarden vertegenwoordigt, genaamd elementen. Arrays stellen je in staat meerdere waarden op te slaan in één variabele. In Ruby kunnen arrays elk gegevenstype bevatten, inclusief getallen, strings en andere Ruby-objecten. Dit kan je code inkorten en organiseren, waardoor het leesbaarder en onderhoudbaarder wordt. Alle arrays zijn objecten met hun eigen methoden die je kunt aanroepen, wat een gestandaardiseerde manier biedt om met gegevenssets te werken.

In deze tutorial maak je arrays, benader je de waarden die ze bevatten, voeg je elementen toe, wijzig je ze en verwijder je ze uit een array, en loop je door de elementen in een array om complexere problemen op te lossen.

Het maken van een array

Je begint met het bekijken van hoe je gedetailleerder arrays kunt maken. Hier is bijvoorbeeld een lijst van verschillende haaiensoorten. Zonder een array zou je ze misschien opslaan in afzonderlijke variabelen:

shark1 = "Hammerhead"
shark2 = "Great White"
shark3 = "Tiger"

Deze aanpak is omslachtig en kan snel moeilijk te onderhouden worden, omdat het niet erg flexibel is. Het toevoegen van nog een haai betekent dat je een extra variabele zou moeten toevoegen en bijhouden.

Als je een array gebruikt, kun je deze gegevens vereenvoudigen. Om een array te maken in een Ruby-programma, gebruik je vierkante haken: ([]) en scheid je de waarden die je wilt opslaan met komma’s.

sharks = ["Hammerhead", "Great White", "Tiger"]

In plaats van drie afzonderlijke variabelen te maken, heb je nu één variabele die alle drie haaien bevat. In dit voorbeeld gebruikte je vierkante haken — [] — om een array te maken, en scheidde je elk item met een komma. Als je een extra haai moest toevoegen, zou je gewoon een andere haai aan de array toevoegen in plaats van een nieuwe variabele te maken en te beheren.

Je kunt een hele array afdrukken met de print-verklaring, die de inhoud van de array weergeeft:

print sharks

Output
["Hammerhead", "Great White", "Tiger"]

Als je een array wilt maken waarbij elk item een enkel woord is, kun je de syntaxis %w{} gebruiken, die een woordarray creëert:

days = %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday}

Dit is equivalent aan het maken van de array met vierkante haken:

days =  ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

Merk echter op dat de methode %w{} je toestaat om de aanhalingstekens en de komma’s over te slaan.

Arrays worden vaak gebruikt om lijsten van vergelijkbare gegevenstypen te groeperen, maar in Ruby kunnen arrays elk waarde of een mix van waarden bevatten. Dit omvat ook andere arrays. Hier is een voorbeeld van een array die een string, een nil-waarde, een geheel getal en een array van strings bevat:

record = [
    "Sammy",
    null,
    7,
    [
        "another",
        "array",
    ]
]

Nu ga je kijken hoe je gegevens kunt benaderen die zijn opgeslagen in arrays.

Toegang tot items in arrays

Om toegang te krijgen tot een specifiek item, of element van een array, refereer je aan zijn index, of zijn positie in de array. In Ruby beginnen indices bij nul. Om het eerste element uit je sharks array op te halen, voeg je de index van het element toe aan de variabele met behulp van vierkante haken:

sharks = ["Hammerhead", "Great White", "Tiger"]

De sharks array heeft drie elementen. Hier is een uiteenzetting van hoe elk element in de sharks array geïndexeerd is.

Het eerste element in de array is Hammerhead, dat geïndexeerd is op 0. Het laatste element is Tiger, dat geïndexeerd is op 2. Het tellen begint bij 0 in indices, wat ingaat tegen de natuurlijke intuïtie om bij 1 te beginnen met tellen, dus je zult dit in gedachten willen houden totdat het natuurlijk aanvoelt.

Je kunt erachter komen hoeveel elementen er in een array zitten met de length-methode:

sharks.length

Output
3

Hoewel de indices van sharks beginnen bij 0 en doorgaan tot 2, retourneert de length-eigenschap het aantal elementen in de array, wat 3 is. Het gaat helemaal niet over de indices.

Als je het indexnummer van een specifiek element in een array wilt vinden, zoals Tiger, gebruik dan de index()-methode:

print sharks.index("Tiger")

Output
2

Dit geeft de index terug van het eerste element dat die tekst bevat. Als een indexnummer niet wordt gevonden, zoals voor een waarde die niet bestaat, zal de console nil retourneren.

print sharks.index("Whale")

Output
nil

Om het laatste element van een array in Ruby te krijgen, gebruik je de index -1:

print sharks[-1]

Output
"Tiger"

Ruby biedt ook de methoden first en last om het eerste en laatste element te krijgen zonder indices te gebruiken:

puts sharks.first
puts sharks.last

Output
"Hammerhead"
"Tiger"

Als je probeert toegang te krijgen tot een index die niet bestaat, zal dit nil retourneren:

sharks[10]

Output
nil

Arrays kunnen andere arrays bevatten, die geneste arrays worden genoemd. Dit is één manier om tweedimensionale gegevenssets in een programma te modelleren. Hier is een voorbeeld van een geneste array:

nested_array = [
    [
        "salmon",
        "halibut",
    ],
    [
        "coral",
        "reef",
    ]
]

Om elementen in een geneste array te benaderen, voeg je nog een indexnummer toe dat overeenkomt met de binnenste array. Bijvoorbeeld, om de waarde coral uit deze geneste array te halen, zou je de volgende instructie gebruiken:

print nested_array[1][0];

Output
coral

In dit voorbeeld heb je de array op positie 1 van de variabele nested_array benaderd, wat de array ["coral", "reef"] retourneerde. Vervolgens heb je de elementen op positie 0 van die array benaderd, wat "coral" was.

Nu zullen we kijken hoe we elementen aan een array kunnen toevoegen.

Elementen toevoegen aan Arrays

Je hebt drie elementen in je sharks array, die geïndexeerd zijn van 0 tot 2:

sharks = ["Hammerhead", "Great White", "Tiger"]

Er zijn een paar manieren om een nieuw element toe te voegen. Je zou een waarde kunnen toekennen aan de volgende index, die in dit geval 3 zou zijn:

sharks[3] = "Whale";

print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale"]

Deze methode is echter foutgevoelig. Als je een element toevoegt en per ongeluk een index overslaat, zal dit een nil element in de array creëren.

sharks[5] = "Sand";

print sharks;

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Sand"]

Als je probeert toegang te krijgen tot het extra array-element, zal het zijn waarde retourneren, wat nil zal zijn:

sharks[4]

Output
nil

Het vinden van de volgende beschikbare index in een array is foutgevoelig en kost extra tijd. Voorkom fouten door de push-methode te gebruiken, die een element toevoegt aan het einde van een array:

sharks.push("Thresher")
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher"]

Je kunt ook de syntax << gebruiken in plaats van de push-methode om een element aan het einde van een array toe te voegen:

sharks << "Bullhead"

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Om een element aan het begin van een array toe te voegen, gebruik je de unshift()-methode:

sharks.unshift("Angel")
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

Nu je weet hoe je elementen kunt toevoegen, ga je kijken naar het verwijderen ervan.

Elementen verwijderen uit Arrays

Om een specifiek element uit een array te verwijderen, gebruik je de methoden delete of delete_at. In de array sharks heb je eerder een nil array-element gemaakt. Nu ga je er vanaf.

Eerst vind je de positie in de array. Je kunt daarvoor de index-methode gebruiken:

print sharks.index(nil)

Output
4

Vervolgens gebruik je delete_at om het element op index 4 te verwijderen en de array af te drukken:

sharks.delete_at(4)
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", "Thresher", "Bullhead"]

De methode delete verwijdert elementen uit een array die overeenkomen met de waarde die je doorgeeft. Gebruik het om Walvis uit de array te verwijderen:

sharks.delete("Whale")
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher", "Bullhead"]

De delete methode zal alle voorkomens van de door jou doorgegeven waarde verwijderen, dus als je array duplicaat elementen bevat, zullen ze allemaal worden verwijderd.

De pop methode verwijdert het laatste element in een array:

sharks.pop
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher"]

Bultrug is verwijderd als het laatste element van de array. Om het eerste element van de array te verwijderen, gebruik je de shift methode:

sharks.shift
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Thresher"]

Deze keer werd Engel verwijderd van het begin van de array.

Door pop en shift te gebruiken, kun je elementen verwijderen van zowel het begin als het einde van arrays. Het gebruik van pop heeft de voorkeur waar mogelijk, omdat de overige items in de array hun oorspronkelijke indexnummers behouden.

De methoden delete_at, pop en shift veranderen allemaal de oorspronkelijke array en retourneren het element dat je hebt verwijderd::

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
deleted_at_element = sharks.delete_at(1)
popped_element = sharks.pop

puts "Deleted_at element: #{deleted_at_element}"
puts "Popped element: #{popped_element}"

puts "Remaining array: #{sharks}"

Output
Deleted_at element: Great White
Popped element: Whale
Remaining array: ["Hammerhead", "Tiger"]

Je weet nu verschillende manieren om elementen uit een array te verwijderen. Nu zul je kijken naar hoe je het element dat je al hebt kunt wijzigen.

Bestaande elementen wijzigen in Arrays

Om een element in de array bij te werken, wijs je een nieuwe waarde toe aan de index van het element door de toekenningsoperator te gebruiken, net zoals je zou doen met een gewone variabele.

Gegeven een nieuwe array van haaien, met "Hammerhead" op index 0, zal je "Hammerhead" vervangen door "Angel":

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks[0] = "Angel"
print sharks;

Output
["Angel", "Great White", "Tiger", "Whale"]

Om er zeker van te zijn dat je het juiste element bijwerkt, kan je de index-methode gebruiken om eerst het element te lokaliseren, net zoals je deed om het element te vinden dat je wilde verwijderen.

Nu zal je kijken naar hoe je kunt werken met alle elementen in de array.

Itereren Over Arrays

Ruby biedt veel manieren om te itereren over een array, en elke methode die je gebruikt is afhankelijk van het soort werk dat je wilt uitvoeren. Vervolgens zal je verkennen hoe je kunt itereren over een array en elk van zijn elementen kunt weergeven.

Ruby biedt de for..in-syntax:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
for shark in sharks do
  puts shark
end

Voor elk element in de sharks-array wijst Ruby dat element toe aan de lokale variabele shark. Vervolgens kan je de waarde van het element afdrukken met puts.

Je zult for..in echter niet vaak zien. Ruby-arrays zijn objecten en ze bieden de each-methode voor het werken met elementen. De each-methode werkt op een vergelijkbare manier als for..in, maar heeft een andere syntaxis:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each do |shark|
  puts shark
end

De each methode gebruikt een syntaxis die je vaak zult zien in Ruby-programmering. Het neemt een Ruby block als argument. Een block is wat code die later zal worden uitgevoerd in de context van de methode. In dit geval is de code puts shark. Het shark trefwoord, ingesloten in de pijp tekens (|), is de lokale variabele die het element in de array vertegenwoordigt waartoe het blok toegang zal hebben. Ruby wijst het element toe aan deze variabele en voert de code in het blok uit. De each methode herhaalt dit proces voor elk element in de array:

Output
Hammerhead
Great White
Tiger
Whale

Wanneer het blok slechts uit één regel bestaat, zie je vaak dat Ruby-ontwikkelaars de do en end trefwoorden vervangen door accolades en de hele instructie samendrukken tot één regel:

...
sharks.each {|shark| puts shark }

Dit produceert dezelfde resultaten maar gebruikt minder regels code.

De each_with_index methode werkt op een vergelijkbare manier, maar geeft je ook toegang tot de index van het array-element. Dit programma gebruikt each_with_index om de index en de waarde voor elk element af te drukken:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each_with_index do |shark, index|
  puts "The index is #{index}"
  puts "The value is #{shark}"
end

Voor elk element in de array wijst Ruby het element toe aan de variabele shark, en wijst de huidige index toe aan de variabele index. Je kunt dan beide variabelen in het blok refereren.

Output
The index is 0
The value is Hammerhead
The index is 1
The value is Great White
The index is 2
The value is Tiger
The index is 3
The value is Whale

Je zult vaak over de elementen in een array itereren in je eigen programma’s, bijvoorbeeld wanneer je de items uit een database op een website moet weergeven, of wanneer je regels uit een bestand leest en de inhoud ervan verwerkt.

Conclusie

Arrays zijn een uiterst veelzijdig en fundamenteel onderdeel van programmeren in Ruby. In deze tutorial heb je arrays gemaakt en individuele elementen benaderd. Je hebt ook elementen toegevoegd, verwijderd en gewijzigd in een array. Ten slotte heb je twee manieren verkend om over een array te itereren en de inhoud ervan weer te geven, wat wordt gebruikt als een veelvoorkomende methode om gegevens weer te geven.

Leer meer over andere gegevenstypen in Ruby door de tutorial Understanding Data Types in Ruby te lezen.