Badges nominatifs

De nombreux langages disposent d'un moyen, comme null ou none, pour indiquer une valeur inexistante. Comme Julia est conçu pour traiter de gros volumes de données (souvent désordonnées), il possède plusieurs formes de néant.

L'objectif général est de signaler les valeurs manquantes ou suspectes au moment où on les rencontre, puis de continuer sans lever d'exception.

nothing

Si une valeur n'existe vraiment pas, elle est représentée par nothing. C'est probablement ce qui se rapproche le plus de ce que font C (NULL) ou Python (None).

julia> n = nothing

julia> isnothing(n)
true

julia> typeof(n)
Nothing

nothing est donc une valeur singleton de type Nothing, et on peut la tester.

Un usage courant de nothing est d'être une valeur de retour (ou plutôt une non-valeur) pour les fonctions qu'on n'utilise que pour leurs effets de bord (affichage, configuration réseau, ou autre).

missing

Quand une valeur existe en théorie mais qu'on ne sait pas ce qu'elle est, on utilise missing. Par exemple, lorsqu'on compte les véhicules qui circulent sur une route, il peut arriver que les observateurs humains aient besoin d'une pause, ou que les capteurs automatiques tombent en panne, alors que le trafic continue de s'écouler.

missing est donc un espace réservé, qui avertit les humains qu'ils doivent décider comment gérer ce manque dans les données.

julia> mv = [1, 2, missing]
3-element Vector{Union{Missing, Int64}}:
 1
 2
  missing

julia> typeof(mv)
Vector{Union{Missing, Int64}} (alias for Array{Union{Missing, Int64}, 1})

julia> ismissing.(mv)  # broadcast function, displays as 1 for true, 0 for false
3-element BitVector:
 0
 0
 1

Peu d'autres langages intègrent cette fonctionnalité nativement, mais des équivalents proches existent : NA en R ou NULL en SQL.

Les expressions renvoient généralement missing par défaut si des valeurs missing sont présentes. Si tu veux que ces valeurs soient ignorées, utilise la fonction skipmissing() pour le rendre explicite :

julia> mv = [1, 2, missing]
3-element Vector{Union{Missing, Int64}}:
 1
 2
  missing

julia> sum(mv)  # missing in, missing out
missing

julia> skipmissing(mv)
skipmissing(Union{Missing, Int64}[1, 2, missing])

julia> collect(skipmissing(mv))
2-element Vector{Int64}:
 1
 2

julia> sum(skipmissing(mv))  # functions like sum() can work with iterators
3

Comme skipmissing crée un itérateur, il faut l'envelopper dans collect() si on a besoin d'un vecteur.

Il est parfois utile de remplacer les valeurs missing par une valeur par défaut. La macro @coalesce() est utile pour cela : elle renvoie la première valeur non manquante (ou missing s'il n'y en a pas d'autre).

julia> str = ["I", "exist", missing]
3-element Vector{Union{Missing, String}}:
 "I"
 "exist"
 missing

julia> [@coalesce(s, "-") for  s in str]
3-element Vector{String}:
 "I"
 "exist"
 "-"

NaN

Abréviation de « Not a Number », NaN signale un problème de calcul dans les situations où l'on attendait un nombre.

julia> v = [0, 1, -1]
3-element Vector{Int64}:
  0
  1
 -1

julia> v / 0
3-element Vector{Float64}:
 NaN
  Inf
 -Inf
 
julia> sum(v / 0)
NaN

Tout calcul sur des données contenant un NaN donnera un résultat NaN.

Il n'existe actuellement aucune fonction spéciale pour supprimer les valeurs NaN, mais la fonction standard filter() peut le faire très simplement. Seules les valeurs pour lesquelles une condition donnée vaut true seront copiées dans le tableau résultat :

julia> filter(!isnan, [1, 2, NaN])
2-element Vector{Float64}:
 1.0
 2.0