शून्यता में

शून्यता के बारे में

कई भाषाओं में 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 हैं।

ऊपर के उदाहरण में वेक्टर टाइप Union{Missing, Int64} पर सेट है, जो दूसरी भाषाओं के Option या Maybe जैसे टाइपों से कुछ मिलता-जुलता है।

अगर डेटा में 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

अपरिभाषित डेटा

इसका इस्तेमाल आप शायद कम ही करेंगे। कुछ अपवाद ये हैं:

• कंपोज़िट टाइप (जैसे struct) ऐसे बनाए जा सकते हैं जिनके फील्ड शुरू में इनिशियलाइज़ न हों। Julia आम तौर पर डिफॉल्ट वैल्यू इस्तेमाल करने की कोशिश करता है, पर ऐसा वह तभी कर पाता है जब उसके पास फील्ड का टाइप अनुमान लगाने के लिए पर्याप्त जानकारी हो।
• कुछ मामलों में किसी वेक्टर को undef से इनिशियलाइज़ करना लचीला और अच्छा प्रदर्शन देने वाला तरीका हो सकता है। उदाहरण के लिए, Circular Buffer अभ्यास के समुदाय के हलों में इसका इस्तेमाल किया गया है (यह एक उन्नत तकनीक है, पर इस अभ्यास को कठिन अभ्यास की श्रेणी में रखा गया है)।

किसी वैल्यू तक पहुँचने की कोशिश में undef नतीजा मिलना एक एरर स्थिति है, जिसे आम तौर पर UndefRefError से चिह्नित किया जाता है।