Bisher hat der Lehrplan nicht viel über Typen gesagt, aber offensichtlich gibt es sie in Julia:
julia> vals = (42, 4.3, π, "hello", 'Q')
(42, 4.3, π, "hello", 'Q')
julia> typeof(vals)
Tuple{Int64, Float64, Irrational{:π}, String, Char}
Wir haben die Typen nie festgelegt, aber Julia hat sie trotzdem zugewiesen.
- Julia hat
types, die für sein Design zentral sind.
- Julia kann den Typ meist „erraten“, indem es
Type Inference verwendet.
Der JIT-Compiler schaut sich den (gesamten) Code an, sieht, wie eine Variable verwendet wird, und leitet einen passenden Standardtyp ab, der zu dieser Verwendung passt.
Typzuweisung
Sich auf die Typinferenz zu verlassen, ist für einfache Übungen in Ordnung, aber bei größeren Programmen brauchst du wahrscheinlich eine genauere Kontrolle.
Auf den meisten modernen Prozessoren hat eine Ganzzahl standardmäßig den Typ Int64.
Im Numbers-Konzept haben wir gesehen, dass ein Wert in einen bestimmten Typ umgewandelt werden kann, der nicht der Standardtyp ist.
julia> x = Int16(42)
42
julia> typeof(x)
Int16
Allerdings kann die Variable x weiterhin einem anderen Typ zugewiesen werden:
julia> x = "changed"
"changed"
julia> typeof(x)
String
Das ist type instability, was Folgendes bedeutet:
- In kleinen Skripten sehr praktisch.
- In größeren Programmen schlecht für Leistung und Zuverlässigkeit.
Stattdessen können wir den Typ von x mit dem Operator :: festlegen:
julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> y = "changed"
ERROR: MethodError: Cannot `convert` an object of type String to an object of type Int16
The function `convert` exists, but no method is defined for this combination of argument types.
Jetzt ist y vom Typ Int16, und das wird immer so bleiben.
So weiß der Compiler, wie viele Bytes er dafür reservieren muss, und kann den restlichen Code darauf optimieren, sich auf einen stabilen Typ zu verlassen.
Damit ähnelt die Variable mehr oder weniger denen in einer statisch typisierten Sprache wie C.
Die Typhierarchie
Int64, Int16, String, Char: Woher "kommen" diese Typen?
In vielen objektorientierten (OO) Sprachen ist jeder Typ eine Klasse, die Vererbung ordnet sie in einer Klassenhierarchie an, und Klassenmethoden definieren das Verhalten.
Java und Ruby sind offensichtliche Beispiele für dieses Muster, aber selbst Python funktioniert intern ähnlich.
Julia hat keine Klassen.
Der dokumentierte Grund dafür ist, dass OO-Features den JIT-Compiler stören und die Laufzeitleistung beeinträchtigen.
Und trotzdem, schau dir diesen Code an:
julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> supertype(Int16)
Signed
julia> supertypes(Int16)
(Int16, Signed, Integer, Real, Number, Any)
Ein paar Details dazu:
-
Int16 ist ein Typ, und wir können Variablen dieses Typs erstellen.
-
Int16 ist ein Untertyp von Signed, und die Funktion supertype() zeigt uns das.
- Es gibt eine Hierarchie von Typen, die über
Integer, Real und Number bis hin zu Any an der Spitze reicht, und subtypes() listet diesen Zweig der Hierarchie für uns auf.
Alle Zweige enden in Any, das einzigartig darin ist, sein eigener Obertyp zu sein.
julia> supertypes(String)
(String, AbstractString, Any)
julia> supertype(Any)
Any
Julia hat also keine class-Hierarchie, aber es hat eine type-Hierarchie.
Irgendwann werden wir versuchen, zu ergründen, wie das funktioniert, aber zuerst gibt es noch viel mehr zu entdecken.
Typen testen
Wir können mit typeof() wie üblich auf Gleichheit prüfen.
julia> typeof(11)
Int64
julia> typeof(11) == Int64
true
julia> typeof(11) == Number
false
Die Typgleichheit muss exakt sein, denn diese Art des Vergleichs kennt die Typhierarchie nicht.
Flexibler ist isa: Es sagt uns, ob ein Wert denselben Typ wie ein Vergleichswert hat oder einen Untertyp davon.
Es kann sowohl in Funktionsform als auch in Infixform verwendet werden.
julia> 12 isa Int64
true
julia> 12 isa Number
true
julia> isa(12, Number)
true
julia> 12 isa String
false
Beachte, dass isa links einen value erwartet, nicht einen type.
Wenn du zwei Typen auf diese Weise vergleichst, bekommst du unerwartete Ergebnisse.
Der richtige Operator ist <:, den wir in zukünftigen Konzepten noch viel häufiger sehen werden.
julia> Int64 isa Number ## Don't do this!
false
julia> Int64 <: Number
true
Abstrakte und konkrete Typen
Wir haben gesehen, dass die Typhierarchie eine Baumstruktur bildet (im Sinne der Informatik, mit der Wurzel oben).
Jedes Element im Baum ist ein node, und diese lassen sich in Kategorien einteilen:
- Knoten mit Untertypen heißen
abstract.
- Blattknoten ohne Untertypen heißen
concrete.
julia> subtypes(Integer) # an abstract type
3-element Vector{Any}:
Bool
Signed
Unsigned
julia> subtypes(Int64) # a concrete type
Type[]
Das ist ein wichtiger Unterschied, denn nur konkrete Typen können als Variablen instantiated werden.
julia> a::Int16 = 42
42
julia> typeof(a)
Int16
julia> b::Integer = 42
42
julia> typeof(b)
Int64
Beachte, dass der Versuch, einen abstrakten Typ zu verwenden, (in diesem Fall) keine Fehlermeldung erzeugt, aber der Compiler erstellt einen passenden konkreten Typ: Int64 statt Integer.
Lernübung
