Crachás de nome

Muitas linguagens têm uma forma como null ou none de indicar um valor inexistente. Como Julia foi projetada para lidar com grandes volumes de dados (muitas vezes bagunçados), ela tem várias formas de representar o nada.

O objetivo geral é sinalizar valores ausentes ou suspeitos conforme eles aparecem, e então continuar sem lançar uma exceção.

nothing

Se um valor realmente não existe, ele é representado por nothing. Provavelmente é o que mais se aproxima do que o C (NULL) ou o Python (None) fazem.

julia> n = nothing

julia> isnothing(n)
true

julia> typeof(n)
Nothing

Então nothing é um valor singleton do tipo Nothing, e podemos testá-lo.

Um uso comum de nothing é como valor de retorno (ou de não retorno) de funções que existem apenas pelos seus efeitos colaterais (imprimir, configurar a rede, ou qualquer outra coisa).

missing

Para situações em que um valor existe em teoria, mas não sabemos qual é, usa-se missing. Por exemplo, ao contar veículos que trafegam por uma estrada, observadores humanos podem precisar fazer uma pausa ou sensores automáticos podem falhar, mas o tráfego continua fluindo.

Assim, missing é um marcador de posição, avisando às pessoas que elas precisam decidir como lidar com essa lacuna nos dados.

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

Poucas outras linguagens têm esse recurso embutido, mas analogias próximas são NA no R ou NULL no SQL.

As expressões geralmente retornam missing por padrão se houver valores missing. Se você quiser que esses valores sejam ignorados, use a função skipmissing() para deixar isso explícito:

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

Como skipmissing cria um iterador, envolva-o em collect() se você precisar de um vetor.

Às vezes é útil substituir valores missing por algum padrão. A macro @coalesce() é útil para isso, pois retorna o primeiro valor que não for missing (ou missing se não houver mais nada).

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

Abreviação de "Not a Number", NaN sinaliza um problema de cálculo em situações em que se esperava um número.

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

Qualquer tipo de cálculo sobre dados que incluam um NaN dará um resultado NaN.

No momento não existe uma função especial para remover valores NaN, mas a função filter() padrão consegue fazer isso de forma bem simples. Só os valores para os quais alguma condição dada é true serão copiados para o array resultante:

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