नाम बैज

कई भाषाओं में null या none जैसा कोई तरीका होता है, जो बताता है कि कोई वैल्यू मौजूद ही नहीं है। चूँकि Julia को बड़ी मात्रा में (अक्सर अव्यवस्थित) डेटा संभालने के लिए बनाया गया है, इसलिए इसमें शून्यता के कई रूप मौजूद हैं।

इसका मुख्य उद्देश्य यह है कि जैसे-जैसे कोई गायब या संदिग्ध वैल्यू सामने आए, उसे चिह्नित कर दिया जाए और फिर बिना एक्सेप्शन उठाए काम आगे बढ़ता रहे।

nothing

अगर कोई वैल्यू वाकई मौजूद ही नहीं है, तो उसे nothing से दर्शाया जाता है। यह शायद C (NULL) या Python (None) के व्यवहार के सबसे करीब है।

julia> n = nothing

julia> isnothing(n)
true

julia> typeof(n)
Nothing

तो nothing, Nothing टाइप की एक सिंगलटन वैल्यू है, और हम इसकी जाँच कर सकते हैं।

nothing का एक आम उपयोग उन फंक्शन के लिए रिटर्न (नॉन-)वैल्यू के तौर पर होता है जिनका इस्तेमाल सिर्फ उनके साइड इफेक्ट के लिए किया जाता है (प्रिंट करना, नेटवर्क कॉन्फिगर करना, या जो भी हो)।

missing

ऐसी स्थितियों के लिए, जहाँ कोई वैल्यू सिद्धांत रूप में मौजूद तो है पर हमें पता नहीं कि वह क्या है, missing का उपयोग किया जाता है। उदाहरण के लिए, सड़क पर चलने वाले वाहनों की गिनती करते समय कभी मानव निरीक्षकों को आराम की ज़रूरत पड़ सकती है, कभी स्वचालित सेंसर खराब हो जाते हैं, पर यातायात बहता रहता है।

इस तरह missing एक प्लेसहोल्डर है, जो लोगों को चेतावनी देता है कि डेटा में इस कमी को कैसे संभालना है, इस बारे में उन्हें फैसला लेना है।

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

कुछ ही अन्य भाषाओं में यह सुविधा अंदर से मौजूद होती है, पर इसके करीबी समान रूप R में NA और SQL में NULL हैं।

अगर missing वैल्यू मौजूद हों, तो एक्सप्रेशन आम तौर पर डिफॉल्ट रूप से missing लौटाते हैं। अगर आप चाहते हैं कि इन वैल्यू को नज़रअंदाज़ कर दिया जाए, तो इसे साफ़-साफ़ बताने के लिए skipmissing() फंक्शन का उपयोग कीजिए:

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

चूँकि skipmissing एक इटरेटर बनाता है, अगर आपको वेक्टर चाहिए तो इसे collect() में लपेटिए।

कभी-कभी missing वैल्यू की जगह कोई डिफॉल्ट वैल्यू रख देना काम का होता है। इसके लिए @coalesce() मैक्रो उपयोगी है, क्योंकि यह पहली ऐसी वैल्यू लौटाता है जो missing नहीं है (और अगर कुछ और बचा ही न हो तो missing)।

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

"Not a Number" का छोटा रूप, NaN उन स्थितियों में गणना की समस्या को चिह्नित करता है जहाँ संख्या की अपेक्षा थी।

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

जिस डेटा में कोई NaN शामिल हो, उस पर किसी भी तरह की गणना का परिणाम NaN ही आएगा।

फिलहाल NaN वैल्यू हटाने के लिए कोई खास फंक्शन नहीं है, पर मानक filter() फंक्शन यह काम बड़ी आसानी से कर सकता है। परिणाम ऐरे में केवल वे वैल्यू कॉपी की जाएँगी जिनके लिए दी गई कोई शर्त true होगी:

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