A tanterv eddig nem sokat mondott a típusokról, de nyilvánvalóan léteznek a Juliában:
julia> vals = (42, 4.3, π, "hello", 'Q')
(42, 4.3, π, "hello", 'Q')
julia> typeof(vals)
Tuple{Int64, Float64, Irrational{:π}, String, Char}
Sosem adtuk meg a típusokat, a Julia mégis hozzárendelte őket.
- A Juliának vannak
types, amelyek központi szerepet játszanak a tervezésében.
- A Julia általában „kitalálja” a típust,
Type Inference segítségével.
A JIT-fordító átnézi az (összes) kódot, megnézi, hogyan használjuk a változót, és kikövetkeztet egy olyan megfelelő alapértelmezett típust, amely összeegyeztethető ezzel a használattal.
Típus-hozzárendelés
A típuskövetkeztetésre hagyatkozni rendben van egyszerű gyakorlófeladatok megoldásánál, de nagyobb programoknál valószínűleg pontosabb irányításra lesz szükséged.
A legtöbb modern processzoron egy egész szám alapértelmezett típusa az Int64.
A Numbers fogalomban láttuk, hogy egy érték átalakítható egy adott, nem alapértelmezett típusra.
julia> x = Int16(42)
42
julia> typeof(x)
Int16
Az x változó azonban továbbra is hozzárendelhető egy másik típushoz:
julia> x = "changed"
"changed"
julia> typeof(x)
String
Ez a type instability, ami:
- Kis szkriptekben nagyon kényelmes.
- Nagyobb programokban árt a teljesítménynek és a megbízhatóságnak.
Ehelyett a :: operátorral megadhatjuk az x típusát:
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.
Mostantól y Int16 típusú, és az is marad.
Így a fordító tudja, hány bájtot kell fenntartania számára, és a kód többi részét is optimalizálhatja arra, hogy egy stabil típusra támaszkodjon.
Ebben a változó többé-kevésbé hasonlít egy statikusan típusos nyelv, például a C változóihoz.
A típus-hierarchia
Int64, Int16, String, Char: honnan „származnak” ezek a típusok?
Sok objektumorientált (OO) nyelvben minden típus egy osztály, az alosztályozás osztályhierarchiába rendezi őket, és az osztálymetódusok határozzák meg a viselkedést.
A Java és a Ruby nyilvánvaló példák erre a mintára, de még a Python is hasonlóan működik belül.
A Juliának nincsenek osztályai.
A dokumentált ok az, hogy az OO-jellemzők zavarják a JIT-fordítót, és rontják a futásidejű teljesítményt.
És mégis, nézd meg ezt a kódot:
julia> y::Int16 = 42
42
julia> typeof(y)
Int16
julia> supertype(Int16)
Signed
julia> supertypes(Int16)
(Int16, Signed, Integer, Real, Number, Any)
Kiegészítésképpen néhány részlet:
- Az
Int16 egy típus, és létrehozhatunk ilyen típusú változókat.
- Az
Int16 a Signed altípusa, és ezt a supertype() függvény mutatja meg nekünk.
- Létezik a típusoknak egy hierarchiája, amely az
Integer, Real és Number szinteken keresztül halad felfelé a legfelső Any-ig, és a subtypes() függvény kilistázza nekünk a hierarchia ezen ágát.
Minden ág az Any-ban végződik, amely egyedülálló abban, hogy a saját szupertípusa.
julia> supertypes(String)
(String, AbstractString, Any)
julia> supertype(Any)
Any
Tehát a Juliának nincs class-hierarchiája, de van type-hierarchiája.
Egyszer majd megpróbáljuk kibogozni, hogyan is működik ez, de előbb még sokkal többet kell felfedeznünk.
Típusvizsgálat
A typeof() függvénnyel a szokásos módon vizsgálhatjuk az egyenlőséget.
julia> typeof(11)
Int64
julia> typeof(11) == Int64
true
julia> typeof(11) == Number
false
A típusegyenlőségnek pontosnak kell lennie, mert ez az összehasonlítási forma mit sem tud a típus-hierarchiáról.
Rugalmasabban az isa megmondja, hogy egy érték ugyanolyan típusú-e, mint az összehasonlító, vagy annak egy altípusa-e.
Használható függvény- vagy infix alakban is.
julia> 12 isa Int64
true
julia> 12 isa Number
true
julia> isa(12, Number)
true
julia> 12 isa String
false
Vedd figyelembe, hogy az isa a bal oldalon value-t vár, nem type-ot.
Ha két típust próbálunk így összehasonlítani, váratlan eredményt kapunk.
A helyes operátor a <:, amellyel a későbbi fogalmakban még sokat fogunk találkozni.
julia> Int64 isa Number ## Don't do this!
false
julia> Int64 <: Number
true
Absztrakt és konkrét típusok
Láttuk, hogy a típus-hierarchia fastruktúrát alkot (a számítástudomány értelmében, a gyökérrel a tetején).
A fa minden eleme egy node, és ezeket kategóriákba sorolhatjuk:
- Az altípusokkal rendelkező csomópontokat
abstract-nak nevezzük.
- A levélcsomópontokat, amelyeknek nincs altípusuk,
concrete-nak nevezzük.
julia> subtypes(Integer) # an abstract type
3-element Vector{Any}:
Bool
Signed
Unsigned
julia> subtypes(Int64) # a concrete type
Type[]
Ez fontos megkülönböztetés, mert változóként csak konkrét típusokat lehet instantiated-ni.
julia> a::Int16 = 42
42
julia> typeof(a)
Int16
julia> b::Integer = 42
42
julia> typeof(b)
Int64
Vedd figyelembe, hogy ha absztrakt típust próbálunk használni, (ebben az esetben) nem kapunk hibaüzenetet, de a fordító létrehoz egy megfelelő konkrét típust: Integer helyett Int64-et.
Tanulófeladat
