Inleiding
Bij het schrijven van programma’s gebruik je datatypen om gegevens te classificeren. Datatypen vertellen de computer hoe hij de gegevens in je programma moet behandelen. Ze bepalen ook wat je met de gegevens kunt doen, inclusief welke bewerkingen je kunt uitvoeren.
Een manier om over datatypen na te denken is door de verschillende soorten gegevens te overwegen die we in de echte wereld gebruiken. Bijvoorbeeld, we gebruiken gehele getallen (0, 1, 2, …), integers (… -1, 0, 1, …), en irrationele getallen (π).
Gewoonlijk kunnen we in de wiskunde getallen van verschillende typen combineren en een soort antwoord krijgen. Bijvoorbeeld, we willen misschien 5 bij π optellen:
5 + π
We kunnen ofwel de vergelijking als het antwoord behouden om het irrationele getal mee te nemen, of we kunnen π afronden naar een getal met een beperkt aantal decimalen, en vervolgens de getallen bij elkaar optellen:
5 + π = 5 + 3.14 = 8.14
Maar als we proberen getallen met een ander gegevenstype te evalueren, zoals woorden, beginnen dingen minder zinvol te worden. Hoe zouden we de volgende vergelijking oplossen?
sky + 8
Dit is iets waar we niet meteen weten hoe we het moeten oplossen. De computer kan het ook niet omdat de gegevens van twee verschillende typen zijn. “Sky” is een woord, en 8 is een geheel getal. Bij het schrijven van programma’s moeten we voorzichtig zijn met hoe we waarden toewijzen en hoe we ze manipuleren door bewerkingen zoals optellen, aftrekken, vermenigvuldigen en andere.
In deze tutorial leer je over de belangrijkste gegevenstypen die standaard zijn in Ruby: integers, floats, strings, symbols, arrays en hashes. Dit is geen uitputtend onderzoek van gegevenstypen, maar het zal je helpen vertrouwd te raken met de opties die je hebt in je programma’s.
Je zult vervolgens de dynamische typering verkennen. Ruby-programma’s bepalen gegevenstypen op basis van wat de variabelen bevatten, dus begrijpen hoe dynamische typering werkt, zal je helpen lastige situaties te vermijden in je eigen programma’s. En omdat variabelen elke waarde kunnen bevatten, leer je het gegevenstype van een variabele te identificeren.
Laten we beginnen met kijken naar hoe je werkt met gehele getallen in Ruby.
Integers
Net als in de wiskunde zijn integers in computerprogrammering gehele getallen die positief, negatief of 0 kunnen zijn (…, -1, 0, 1, …). Een integer staat ook vaak bekend als een int.
Je kunt een integer afdrukken als volgt:
print -25
Output-25
Je kunt ook de integer opslaan in een variabele en vervolgens de waarde afdrukken door naar de variabele te verwijzen:
my_int = -25
print my_int
Output-25
Je kunt ook wiskunde doen met integers. Bijvoorbeeld, je kunt de som van twee getallen berekenen en het resultaat afdrukken:
sum = 116 - 68
print sum
Output48
Wanneer we grotere getallen uitschrijven, gebruiken we vaak komma’s om ze gemakkelijker leesbaar te maken. Bijvoorbeeld, we zouden 1.000.000 schrijven voor “één miljoen”. Je kunt geen komma’s gebruiken in je code, maar Ruby staat toe dat je het underscore-teken (_) gebruikt om grote getallen leesbaarder te maken.
Probeer het uit:
large_number = 1_234_567
print large_number
Je zult zien dat het gehele getal wordt afgedrukt zonder de underscores:
Output1234567
De underscores stellen je in staat om leesbaardere code te schrijven als je grote getallen moet voorstellen in je programma’s.
Naarmate je meer leert over de Ruby-taal, zul je veel meer kansen hebben om met gehele getallen te werken. Laten we eens kijken hoe je kunt werken met echte getallen.
Drijvende-kommagetallen
A floating-point number or a float represents a real number. Real numbers can be either a rational or an irrational number; numbers that contain a fractional part, such as 9.0 or -116.42. In other words, a float in a Ruby program is a number that contains a decimal point.
Je kunt zwevende-kommagetallen in Ruby afdrukken zoals je gehele getallen afdrukt:
print 17.3
Output17.3
Je kunt ook een variabele declareren en een zwevend-kommagetal toewijzen:
my_float = 17.3
print my_float
Output17.3
En, net zoals met gehele getallen, kun je ook wiskunde doen met zwevende-kommagetallen in Ruby:
sum = 564.0 + 365.24
print sum
Output929.24
Als je een zwevend-kommagetal optelt bij een geheel getal in Ruby, krijg je een zwevend-kommagetal:
sum = 564 + 365.24
print sum
Output929.24
Ruby beschouwt elk getal geschreven zonder decimalen als een geheel getal (zoals in 138) en elk getal geschreven met decimalen als een zwevend-kommagetal (zoals in 138,0).
Als volgende, laten we kijken naar booleans in Ruby.
Boolean Data Types
Booleans worden gebruikt om de waarheidswaarden te vertegenwoordigen die geassocieerd zijn met de logische tak van de wiskunde, die algoritmes informeert in de informatica. In Ruby stellen we dit gegevenstype voor met een van twee waarden, namelijk true of false.
Veel bewerkingen in de wiskunde geven ons antwoorden die evalueren naar waar of onwaar:
- groter dan
- 500 > 100
true - 1 > 5
false - kleiner dan
- 200 < 400
true - 4 < 2
false - gelijk aan
- 5 = 5
true - 500 = 400
false
Net zoals met getallen, kun je een true of false waarde opslaan in een variabele:
result = 5 > 8
Vervolgens kun je de Booleaanse waarde afdrukken met een oproep naar de print() functie:
print result
Aangezien 5 niet groter is dan 8, zie je het volgende resultaat:
Outputfalse
Naarmate je meer programma’s schrijft in Ruby, zul je vertrouwder raken met hoe Booleans werken en hoe verschillende functies en bewerkingen die evalueren naar true of false de loop van het programma kunnen veranderen.
Laten we nu verkennen hoe we met tekst kunnen werken in onze programma’s.
Strings
A string is a sequence of one or more characters, such as letters, numbers, and symbols. Strings primarily exist within either single quotes (') or double quotes (") in Ruby, so to create a string, enclose a sequence of characters in quotes, like this:
"This is a string in double quotes."
Het kleine programma ” Hallo, wereld! ” toont hoe een string kan worden gebruikt in computerprogrammering, omdat de tekens die de zin Hallo, wereld! vormen een string zijn.
print "Hello, World!"
Net als bij andere gegevenstypen kun je strings opslaan in variabelen:
output = "Hello, World!"
En print de string uit door de variabele aan te roepen:
print output
OutputHello, World!
Net als bij nummers zijn er veel bewerkingen die we kunnen uitvoeren op strings binnen onze programma’s om ze te manipuleren om de resultaten te bereiken die we zoeken. Strings zijn belangrijk voor het communiceren van informatie naar de gebruiker, en voor de gebruiker om informatie terug te communiceren naar het programma.
Soms moet je werken met lijsten met gegevens. Daar komen arrays van pas.
Arrays
Een array kan meerdere waarden bevatten binnen een enkele variabele. Dit betekent dat je een lijst van waarden kunt bevatten binnen een array en er doorheen kunt itereren. Elk item of elke waarde die zich in een array bevindt, wordt een element genoemd.
Arrays worden gedefinieerd door waarden tussen vierkante haken [ ] op te geven, gescheiden door komma’s.
Een array van gehele getallen ziet er zo uit:
[-3, -2, -1, 0, 1, 2, 3]
A array of floats looks like this:
[3.14, 9.23, 111.11, 312.12, 1.05]
Hier is een lijst van strings:
['shark', 'cuttlefish', 'squid', 'mantis shrimp']
Net als bij andere gegevenstypen, kun je een array toewijzen aan een variabele:
sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']
Als we de variabele afdrukken, ziet de uitvoer er precies hetzelfde uit als de array die we hebben gemaakt:
print sea_creatures
['shark', 'cuttlefish', 'squid', 'mantis shrimp']
Je kunt individuele elementen in een array benaderen door een indexnummer te gebruiken, te beginnen bij 0.
puts sea_creatures[0] # haai
puts sea_creatures[2] # inktvis
Om de laatste waarde af te drukken, kun je de index -1 gebruiken. Ruby biedt ook de methoden .first en .last om respectievelijk de eerste en laatste invoer te pakken:
puts sea_creatures.first # haai
puts sea_creatures.last # bidsprinkhaan
Arrays in Ruby kunnen veel verschillende soorten gegevens bevatten. Je kunt strings, symbolen en zelfs andere arrays opslaan in een array:
record = [
:en,
"Sammy",
42,
[
"coral",
"reef"
]
]
Arrays in Ruby zijn wijzigbaar, wat betekent dat je waarden kunt toevoegen, verwijderen en zelfs aanpassen in de array.
Soms hebben we een manier nodig om dingen in een programma te labelen. Daar zijn symbolen voor bedoeld.
Symbolen
A symbol is a special data type that acts like a label or an identifier in a Ruby program. Symbols are immutable, which means that they cannot be changed. A symbol looks like a variable declaration without a value. Here’s an example of a symbol:
:time_zone
In Ruby gebruik je doorgaans een symbool om iets belangrijks te identificeren, terwijl je een string zou gebruiken voor tekst waarmee je moet werken of manipuleren. Elke string in een Ruby-programma is een eigen object, met een unieke locatie in het geheugen, zelfs als de strings identiek zijn.
Maar als je meerdere keren naar hetzelfde symbool verwijst, verwijs je overal in je programma naar hetzelfde object, wat betekent dat je naar dezelfde geheugenlocatie verwijst.
Je zult dit concept in actie zien wanneer we naar hashes kijken, die je in staat stellen om sleutels aan waarden te koppelen.
Hashes
A hash is a dictionary-like collection of keys and values. These key-value pairs provide a useful way to store and access data. Hashes are often used to hold data that are related, such as the information about a user. You define a hash like this:
{"first_name" => "Sammy", "last_name" => "Shark"}
Je kunt hashes aan variabelen toewijzen, net zoals andere datatypen:
user = {"first_name" => "Sammy", "last_name" => "Shark"}
Om waarden uit de user-hash op te halen, gebruik je de sleutel voor de waarde:
print user["first_name"] # "Sammy"
print user["last_name"] # "Shark"
Je kunt symbolen gebruiken als sleutels in je hash in plaats van strings:
user = {:first_name => "Sammy", :last_name => "Shark"}
Het gebruik van symbolen als hash-sleutels heeft de voorkeur wanneer mogelijk. Elke instantie van een symbool wijst naar hetzelfde object, terwijl elke instantie van een string verwijst naar een uniek object. Het gebruik van symbolen als sleutels resulteert in iets betere prestaties en minder geheugengebruik.
Wanneer je symbolen als sleutels gebruikt, gebruik je symbolen om de waarden op te halen:
print user[:first_name] # "Sammy"
print user[:last_name] # "Shark"
Je kunt ook een iets andere syntaxis gebruiken bij het definiëren van de hash:
user = {first_name: "Sammy", last_name: "Shark"}
Deze syntaxis lijkt op de syntaxis die wordt gebruikt in JavaScript en andere talen. Deze syntaxis definieert de sleutels als symbolen, zodat je toegang zou krijgen tot de items met :first_name en :last_name in plaats van de strings "first_name" en "last_name".
Je hebt naar verschillende gegevenstypen gekeken, laten we nu kijken hoe Ruby met die typen werkt.
Dynamisch Typeren
In Ruby declareer je het gegevenstype niet expliciet voordat je een waarde toewijst; het toewijzen van de waarde bepaalt het gegevenstype. Ruby gebruikt dynamisch typen, wat betekent dat typecontrole wordt uitgevoerd tijdens runtime in plaats van compileertijd, zoals bij talen die statisch typen gebruiken. Ruby bepaalt het gegevenstype op basis van de gegevens die zijn opgeslagen in de variabele. Dit lijkt op gegevenstypen in Python en op gegevenstypen in JavaScript.
De variabele t in het volgende voorbeeld kan worden ingesteld op elk beschikbaar gegevenstype:
t = 42 # t is an Integer
t = "Sammy" # t is a String
t = :sammy # t is a Symbol
t = true # t is a boolean (true)
t # t is nil
Met dynamisch getypeerde talen kun je een bestaande variabele hergebruiken om verschillende gegevenstypen vast te houden.
Dit is handig bij het converteren van gegevens van het ene type naar het andere. Bijvoorbeeld, je zou deze code kunnen hebben die de gebruiker vraagt om een numerieke waarde:
print "Please enter the length of the room: "
length = gets.chop
De gegevens die je van het toetsenbord krijgt zijn altijd een string, dus om wiskundige bewerkingen uit te voeren, moet je de gegevens van de variabele length omzetten naar een getal. In statisch getypeerde talen, waar je het gegevenstype van de variabele moet declareren voordat je het een waarde kunt toewijzen, heb je een nieuwe variabele nodig om de omgezette gegevens vast te houden. Maar in Ruby, omdat het dynamisch getypeerd is, kun je de variabele length hergebruiken als je wilt.
# Converteer het bedrag naar een Float.
length = length.to_f
De methode to_f zet de string om naar een float. Ruby biedt ook de methode to_i om strings naar gehele getallen om te zetten, en de meeste objecten kunnen worden omgezet naar strings met de methode to_s:
42.to_s # "42"
(42.5).to_s # "42.5"
["Sammy", "Shark"].to_s # "[\"Sammy\", \"Shark\"]"
Ruby is dynamisch getypeerd, maar het staat je niet toe bewerkingen uit te voeren op verschillende typen gegevens zonder ze naar hetzelfde type om te zetten. Bijvoorbeeld, deze code zal resulteren in een fout:
print 5 + "5"
OutputTypeError: String can't be coerced into Integer
Evenals deze code:
print "5" + 5
OutputTypeError: no implicit conversion of Integer into String
Als je de getallen wilt optellen om 10 te krijgen, zet dan de string om naar een geheel getal. Als je ze wilt samenvoegen om "55" te krijgen, zet dan het geheel getal om naar een string.
Dynamische typen biedt flexibiliteit, maar een nadeel is dat je niet altijd zeker weet met wat voor soort gegevens je werkt, omdat de variabele elk beschikbaar type kan bevatten. Ruby biedt manieren om het type gegevens te identificeren.
Herkennen van gegevenstypen
In Ruby is bijna alles een object. Integer, float, array, symbool en hash zijn allemaal Ruby-objecten, en ze hebben allemaal een methode genaamd class die je vertelt welk type ze zijn. Zelfs de booleans true en false, en de waarde nil zijn objecten. Probeer het zelf uit:
42.class # Integer
(42.2).class # Float
["Sammy", "Shark"].class # Array
true.class # TrueClass
nil.class # NilClass
Bovendien kun je de methode kind_of? gebruiken om een bepaald gegevenstype te verifiëren, zoals dit:
42.kind_of?(Integer) # true
Dit is vooral handig wanneer je een variabele hebt en je het type ervan wilt bepalen:
# ergens in de code...
sharks = ["Hammerhead", "Tiger", "Great White"]
...
# ergens anders...
sharks.kind_of?(Hash) # false
sharks.kind_of?(Array) # true
Je kunt dit ook gebruiken om te controleren of gegevens van een externe bron correct zijn:
if data.kind_of? String
data = data.to_f
end
Ruby biedt ook de is_a?-methode aan, die hetzelfde doet als kind_of?, maar voor sommige ontwikkelaars misschien wat gemakkelijker te lezen is:
if data.is_a? String
data = data.to_f
end
Het gebruik van class, kind_of? en is_a? kan je helpen ervoor te zorgen dat je met het juiste soort gegevens werkt. Naarmate je meer leert over Ruby, zul je andere manieren ontdekken om gegevens te verwerken die niet inhouden dat je expliciet het type van de gegevens controleert.
Conclusie
Je zult veel verschillende gegevenstypen gebruiken in je Ruby-programma’s. Je hebt nu een beter begrip van de belangrijkste gegevenstypen die beschikbaar zijn in Ruby-programma’s.
Bekijk deze tutorials om je verkenning van de gegevenstypen in Ruby voort te zetten:
Source:
https://www.digitalocean.com/community/tutorials/understanding-data-types-in-ruby