Verständnis von Datentypen in Ruby

Einführung

Wenn Sie Programme schreiben, verwenden Sie Datentypen, um Daten zu klassifizieren. Datentypen geben dem Computer an, wie er die Daten in Ihrem Programm verarbeiten soll. Sie bestimmen auch, was Sie mit den Daten tun können, einschließlich der Operationen, die Sie ausführen können.

Eine Möglichkeit, über Datentypen nachzudenken, besteht darin, die verschiedenen Arten von Daten zu betrachten, die wir in der realen Welt verwenden. Zum Beispiel verwenden wir ganze Zahlen (0, 1, 2, …), Ganzzahlen (…, -1, 0, 1, …), und irrationale Zahlen (π).

Normalerweise können wir in der Mathematik Zahlen aus verschiedenen Typen kombinieren und eine Art Antwort erhalten. Zum Beispiel möchten wir vielleicht 5 zu π hinzufügen:

5 + π

Wir können entweder die Gleichung als Antwort beibehalten, um die irrationale Zahl zu berücksichtigen, oder wir können π auf eine Zahl mit einer geringen Anzahl von Dezimalstellen runden und dann die Zahlen zusammen addieren:

5 + π = 5 + 3.14 = 8.14

Aber wenn wir versuchen, Zahlen mit einem anderen Datentyp zu bewerten, wie z. B. Wörter, fangen die Dinge an, weniger Sinn zu ergeben. Wie würden wir die folgende Gleichung lösen?

sky + 8

Dies ist etwas, das wir nicht sofort wissen, wie wir es lösen können. Der Computer kann es auch nicht, weil die Daten zwei verschiedenen Typen angehören. „Himmel“ ist ein Wort und 8 ist eine ganze Zahl. Wenn wir Programme schreiben, müssen wir darauf achten, wie wir Werte zuweisen und wie wir sie durch Operationen wie Addition, Subtraktion, Multiplikation und andere manipulieren.

In diesem Tutorial lernen Sie die wichtigsten Datentypen kennen, die in Ruby nativ vorhanden sind: Ganzzahlen, Gleitkommazahlen, Zeichenfolgen, Symbole, Arrays und Hashes. Dies ist keine umfassende Untersuchung der Datentypen, aber es wird Ihnen helfen, sich mit den verfügbaren Optionen in Ihren Programmen vertraut zu machen.

Als nächstes werden Sie die dynamische Typisierung erkunden. Ruby-Programme bestimmen Datentypen basierend darauf, was die Variablen enthalten, daher wird Ihnen das Verständnis, wie die dynamische Typisierung funktioniert, helfen, knifflige Situationen in Ihren eigenen Programmen zu vermeiden. Und da Variablen jeden Wert enthalten können, werden Sie lernen, den Datentyp einer Variablen zu identifizieren.

Beginnen wir damit, wie man mit ganzen Zahlen in Ruby arbeitet.

Ganzzahlen

Wie in der Mathematik sind Ganzzahlen in der Computerprogrammierung ganze Zahlen, die positiv, negativ oder 0 sein können (…, -1, 0, 1, …). Eine Ganzzahl wird auch häufig als int bezeichnet.

Sie können eine Ganzzahl wie folgt ausgeben:

print -25

Output
-25

Sie können die Ganzzahl auch in einer Variable speichern und dann den Wert ausgeben, indem Sie auf die Variable verweisen:

my_int = -25
print my_int

Output
-25

Sie können auch Mathematik mit Ganzzahlen betreiben. Zum Beispiel können Sie die Summe von zwei Zahlen berechnen und das Ergebnis ausgeben:

sum = 116 - 68
print sum

Output
48

Wenn wir größere Zahlen aufschreiben, neigen wir dazu, Kommas zu verwenden, um sie leichter lesbar zu machen. Zum Beispiel würden wir 1.000.000 für „eine Million“ schreiben. In Ihrem Code können Sie keine Kommas verwenden, aber Ruby erlaubt es Ihnen, den Unterstrich (_) zu verwenden, um große Zahlen lesbarer zu machen.

Probieren Sie es aus:

large_number = 1_234_567
print large_number

Sie werden die ganze Zahl ohne Unterstriche gedruckt sehen:

Output
1234567

Die Unterstriche ermöglichen es Ihnen, lesbareren Code zu schreiben, wenn Sie große Zahlen in Ihren Programmen darstellen müssen.

Wenn Sie mehr über die Ruby-Sprache lernen, werden Sie viele weitere Möglichkeiten haben, mit ganzen Zahlen zu arbeiten. Schauen wir uns an, wie man mit echten Zahlen

Fließkommazahlen

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.

Sie können Floats in Ruby genauso drucken wie ganze Zahlen:

print 17.3

Output
17.3

Sie können auch eine Variable deklarieren und einen Float zuweisen:

my_float = 17.3
print my_float

Output
17.3

Und genau wie bei ganzen Zahlen können Sie auch mit Floats in Ruby rechnen:

sum = 564.0 + 365.24
print sum

Output
929.24

Wenn Sie in Ruby einen Float zu einer ganzen Zahl hinzufügen, erhalten Sie einen Float:

sum = 564 + 365.24
print sum

Output
929.24

Ruby betrachtet jede Zahl, die ohne Dezimalstellen geschrieben ist, als ganze Zahl (wie in 138) und jede Zahl, die mit Dezimalstellen geschrieben ist, als Float (wie in 138,0).

Als nächstes schauen wir uns Boolesche Werte in Ruby an.

Boolesche Datentypen

Boolesche Werte werden verwendet, um die Wahrheitswerte darzustellen, die mit dem logischen Zweig der Mathematik verbunden sind und Algorithmen in der Informatik informieren. In Ruby stellen wir diesen Datentyp mit einem von zwei Werten dar, entweder true oder false.

Viele Operationen in der Mathematik liefern Antworten, die entweder wahr oder falsch ausgewertet werden:

• größer als
• 500 > 100 true
• 1 > 5 false
• kleiner als
• 200 < 400 true
• 4 < 2 false
• gleich
• 5 = 5 true
• 500 = 400 false

Wie bei Zahlen können Sie einen true– oder false-Wert in einer Variablen speichern:

result = 5 > 8

Dann können Sie den booleschen Wert mit einem Aufruf der print()-Funktion ausgeben:

print result

Da 5 nicht größer als 8 ist, erhalten Sie das folgende Ergebnis:

Output
false

Je mehr Programme Sie in Ruby schreiben, desto vertrauter werden Sie mit der Funktionsweise von Booleschen Werten und wie sich verschiedene Funktionen und Operationen, die zu entweder true oder false ausgewertet werden, auf den Programmverlauf auswirken können.

Als nächstes wollen wir uns damit beschäftigen, wie man mit Text in unseren Programmen arbeitet.

Zeichenfolgen

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."

Das kleine Programm „Hallo, Welt!“ zeigt, wie eine Zeichenfolge in der Computerprogrammierung verwendet werden kann, da die Zeichen, die den Satz Hallo, Welt! bilden, eine Zeichenfolge sind.

print "Hello, World!"

Wie bei anderen Datentypen können Zeichenfolgen in Variablen gespeichert werden:

output = "Hello, World!"

Und die Zeichenfolge kann durch Aufrufen der Variablen ausgegeben werden:

print output

Output
Hello, World!

Ähnlich wie Zahlen gibt es viele Operationen, die wir mit Zeichenfolgen in unseren Programmen ausführen können, um sie zu manipulieren und die gewünschten Ergebnisse zu erzielen. Zeichenfolgen sind wichtig, um Informationen an den Benutzer zu kommunizieren, und für den Benutzer, um Informationen an das Programm zurückzugeben.

Manchmal müssen Sie mit Listen von Daten arbeiten. Hier kommen Arrays ins Spiel.

Arrays

Ein Array kann mehrere Werte innerhalb einer einzigen Variablen speichern. Das bedeutet, dass Sie eine Liste von Werten in einem Array enthalten und durch sie iterieren können. Jedes Element oder jeder Wert, der sich in einem Array befindet, wird als Element bezeichnet.

Arrays werden definiert, indem Werte zwischen eckigen Klammern [ ] angegeben werden, die durch Kommas getrennt sind.

Ein Array von Ganzzahlen sieht so aus:

[-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 ist eine Liste von Zeichenfolgen:

['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Wie bei anderen Datentypen können Sie einem Array eine Variable zuweisen:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Wenn wir die Variable ausgeben, sieht die Ausgabe genau wie das Array aus, das wir erstellt haben:

print sea_creatures

['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Sie greifen auf einzelne Elemente in einem Array zu, indem Sie eine Indexnummer verwenden, die bei 0 beginnt.

puts sea_creatures[0] # Hai
puts sea_creatures[2] # Tintenfisch

Um den letzten Wert auszugeben, können Sie den Index -1 verwenden. Ruby bietet auch die Methoden .first und .last zum Abrufen des ersten bzw. letzten Eintrags:

puts sea_creatures.first # Hai
puts sea_creatures.last # Fangschreckenkrebs

Arrays in Ruby können viele verschiedene Datentypen enthalten. Sie können Zeichenfolgen, Symbole und sogar andere Arrays in einem Array speichern:

record = [
:en,
"Sammy",
42,
[
"coral",
"reef"
]
]

Arrays in Ruby sind veränderlich, was bedeutet, dass Sie Werte hinzufügen, Werte entfernen und sogar Einträge im Array ändern können.

Manchmal benötigen wir in einem Programm eine Möglichkeit, Dinge zu kennzeichnen. Dafür sind Symbole da.

Symbole

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 verwendet man üblicherweise ein Symbol, um etwas Wichtiges zu identifizieren, während man für Text, den man bearbeiten oder manipulieren muss, einen String verwendet. Jeder String in einem Ruby-Programm ist ein eigenes Objekt mit einem einzigartigen Speicherort, auch wenn die Strings identisch sind.

Aber wenn du dasselbe Symbol mehrmals referenzierst, beziehst du dich überall in deinem Programm auf dasselbe Objekt, was bedeutet, dass du dieselbe Speicherstelle referenzierst.

Dieses Konzept wird in Aktion gezeigt, wenn wir uns Hashes anschauen, die es dir ermöglichen, Schlüssel mit Werten zu verknüpfen.

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"}

Du kannst Hashes genauso wie andere Datentypen Variablen zuweisen:

user = {"first_name" => "Sammy", "last_name" => "Shark"}

Um Werte aus dem user-Hash abzurufen, verwendest du den Schlüssel für den Wert:

print user["first_name"] # "Sammy"
print user["last_name"] # "Shark"

Du kannst Symbole anstelle von Strings als Schlüssel in deinem Hash verwenden:

user = {:first_name => "Sammy", :last_name => "Shark"}

Die Verwendung von Symbolen als Hash-Schlüssel wird immer dann bevorzugt, wenn möglich. Jede Instanz eines Symbols verweist auf dasselbe Objekt, während jede Instanz eines Strings auf ein einzigartiges Objekt verweist. Die Verwendung von Symbolen als Schlüssel führt zu etwas besserer Leistung und geringerem Speicherverbrauch.

Wenn du Symbole als Schlüssel verwendest, benutzt du Symbole, um die Werte abzurufen:

print user[:first_name] # "Sammy"
print user[:last_name] # "Shark"

Du kannst auch eine etwas andere Syntax verwenden, um den Hash zu definieren:

user = {first_name: "Sammy", last_name: "Shark"}

Diese Syntax ähnelt der Syntax, die in JavaScript und anderen Sprachen verwendet wird. Diese Syntax definiert die Schlüssel als Symbole, sodass du auf die Einträge zugreifen würdest, indem du :first_name und :last_name anstelle der Zeichenketten "first_name" und "last_name" verwendest.

Du hast dir verschiedene Datentypen angesehen, also lasst uns anschauen, wie Ruby mit diesen Typen arbeitet.

Dynamische Typisierung

In Ruby deklarierst du den Datentyp nicht explizit, bevor du ihm einen Wert zuweist; durch die Zuweisung des Werts wird der Datentyp bestimmt. Ruby verwendet dynamische Typisierung, was bedeutet, dass die Typüberprüfung zur Laufzeit und nicht zur Kompilierzeit erfolgt, wie es bei Sprachen der Fall ist, die statische Typisierung verwenden. Ruby bestimmt den Datentyp aus den im Variablen gespeicherten Daten. Dies ähnelt den Datentypen in Python und den Datentypen in JavaScript.

Die Variable t in folgendem Beispiel kann auf jeden verfügbaren Datentyp gesetzt werden:

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

Mit dynamisch typisierten Sprachen kannst du eine vorhandene Variable wiederverwenden, um verschiedene Datentypen zu halten.

Dies ist nützlich, wenn Daten von einem Typ in einen anderen konvertiert werden müssen. Zum Beispiel könntest du diesen Code haben, der den Benutzer nach einem numerischen Wert fragt:

print "Please enter the length of the room: "
length = gets.chop

Die Daten, die Sie von der Tastatur erhalten, sind immer ein String. Um mathematische Operationen durchzuführen, müssen Sie daher die Daten der Variablen length in eine Zahl umwandeln. In statisch typisierten Sprachen, in denen Sie den Datentyp der Variable deklarieren müssen, bevor Sie ihr einen Wert zuweisen können, benötigen Sie eine neue Variable, um die umgewandelten Daten zu speichern. Aber in Ruby, da es dynamisch typisiert ist, können Sie die Variable length wiederverwenden, wenn Sie möchten.

# Konvertieren Sie den Betrag in eine Gleitkommazahl.
length = length.to_f

Die Methode to_f wandelt den String in eine Gleitkommazahl um. Ruby bietet auch die Methode to_i an, um Strings in Ganzzahlen umzuwandeln, und die meisten Objekte können mit der Methode to_s in Strings umgewandelt werden:

42.to_s # "42"
(42.5).to_s # "42.5"
["Sammy", "Shark"].to_s # "[\"Sammy\", \"Shark\"]"

Ruby ist dynamisch typisiert, erlaubt es Ihnen jedoch nicht, Operationen mit unterschiedlichen Datentypen durchzuführen, ohne sie in den gleichen Typ umzuwandeln. Dieser Code führt beispielsweise zu einem Fehler:

print 5 + "5"

Output
TypeError: String can't be coerced into Integer

Auch dieser Code führt zu einem Fehler:

print "5" + 5

Output
TypeError: no implicit conversion of Integer into String

Wenn Sie die Zahlen addieren möchten, um 10 zu erhalten, wandeln Sie den String in eine Ganzzahl um. Wenn Sie sie zusammenfügen möchten, um "55" zu erhalten, wandeln Sie die Ganzzahl in einen String um.

Dynamische Typisierung bietet Flexibilität, aber ein Nachteil ist, dass Sie nicht immer sicher sein können, mit welcher Art von Daten Sie arbeiten, da die Variable jeden verfügbaren Typ enthalten kann. Ruby bietet Möglichkeiten, den Datentyp der Daten zu identifizieren.

Datentypen identifizieren

In Ruby ist fast alles ein Objekt. Ganze Zahlen, Gleitkommazahlen, Arrays, Symbole und Hashes sind allesamt Ruby-Objekte und sie alle haben eine Methode namens class, die angibt, welchen Typ sie haben. Selbst die booleschen Werte true und false sowie der Wert nil sind Objekte. Probieren Sie es selbst aus:

42.class # Ganze Zahl
(42.2).class # Gleitkommazahl
["Sammy", "Shark"].class # Array
true.class # TrueClass
nil.class # NilClass

Zusätzlich können Sie die Methode kind_of? verwenden, um einen bestimmten Datentyp zu überprüfen, so wie hier:

42.kind_of?(Integer) # true

Dies ist besonders nützlich, wenn Sie eine Variable haben und deren Typ bestimmen möchten:

# irgendwo im Code...
sharks = ["Hammerhead", "Tiger", "Great White"]
...
# an anderer Stelle...

sharks.kind_of?(Hash) # false
sharks.kind_of?(Array) # true

Sie können dies auch verwenden, um zu überprüfen, ob Daten von einer externen Quelle korrekt sind:

if data.kind_of? String
data = data.to_f
end

Ruby bietet auch die Methode is_a?, die dasselbe wie kind_of? tut, aber für einige Entwickler möglicherweise etwas einfacher zu lesen ist:

if data.is_a? String
data = data.to_f
end

Die Verwendung von class, kind_of? und is_a? kann Ihnen helfen, sicherzustellen, dass Sie mit der richtigen Art von Daten arbeiten. Wenn Sie mehr über Ruby erfahren, werden Sie weitere Möglichkeiten entdecken, Daten zu verarbeiten, die nicht das explizite Überprüfen des Typs der Daten beinhalten.

Fazit

Sie werden viele verschiedene Datentypen in Ihren Ruby-Programmen verwenden. Sie haben nun ein besseres Verständnis der wichtigsten Datentypen, die in Ruby-Programmen verfügbar sind.

Werfen Sie einen Blick auf diese Tutorials, um Ihre Erkundung der Datentypen von Ruby fortzusetzen:

• Wie man mit Zeichenketten in Ruby arbeitet
• Wie man mit Arrays in Ruby arbeitet
• Wie man Datentypen in Ruby konvertiert