Julia Language
enums

वाक्य - विन्यास

• @enum EnumType वैल = 1 वैल वैल
• :प्रतीक

टिप्पणियों

एक परिभाषित प्रकार को परिभाषित करना

प्रगणित प्रकार एक प्रकार है जो संभावित मानों की एक सीमित सूची में से एक को पकड़ सकता है। जूलिया में, एनुमरेटेड प्रकार को आमतौर पर "एनम टाइप" कहा जाता है। उदाहरण के लिए, व्यक्ति सप्ताह के सातों दिनों, वर्ष के बारह महीनों, मानक 52-कार्ड डेक के चार सूटों या अन्य समान स्थितियों का वर्णन करने के लिए enum प्रकारों का उपयोग कर सकता है।

हम मानक 52-कार्ड डेक के सूट और रैंकों को मॉडल करने के लिए प्रगणित प्रकारों को परिभाषित कर सकते हैं। @enum मैक्रो का उपयोग @enum प्रकार को परिभाषित करने के लिए किया जाता है।

@enum Suit ♣ ♦ ♥ ♠
@enum Rank ace=1 two three four five six seven eight nine ten jack queen king

यह दो प्रकारों को परिभाषित करता है: Suit और Rank । हम जांच सकते हैं कि मूल्य वास्तव में अपेक्षित प्रकार हैं:

julia> ♦
♦::Suit = 1

julia> six
six::Rank = 6

ध्यान दें कि प्रत्येक सूट और रैंक एक संख्या के साथ संबद्ध किया गया है। डिफ़ॉल्ट रूप से, यह संख्या शून्य से शुरू होती है। इसलिए दूसरा सूट, हीरे को नंबर 1 सौंपा गया था। Rank के मामले में, नंबर एक पर शुरू करने के लिए अधिक समझदारी हो सकती है। यह =1 एनोटेशन के साथ ace की परिभाषा की व्याख्या करके हासिल किया गया था।

एनुमरेटेड प्रकार बहुत अधिक कार्यक्षमता के साथ आते हैं, जैसे कि समानता (और वास्तव में पहचान) और इसमें निर्मित तुलनाएँ:

julia> seven === seven
true

julia> ten ≠ jack
true

julia> two < three
true

किसी अन्य के मूल्यों की तरह अडिग प्रकार , enumerated प्रकार के मूल्यों को भी टुकड़ों में बांटा और में संग्रहित किया जा सकता Dict रों।

हम इस उदाहरण को एक Card प्रकार को परिभाषित करके पूरा कर सकते हैं जिसमें Rank और Suit क्षेत्र है:

immutable Card
    rank::Rank
    suit::Suit
end

और इसलिए हम कार्ड बना सकते हैं

julia> Card(three, ♣)
Card(three::Rank = 3,♣::Suit = 0)

लेकिन प्रगणित प्रकार भी अपने स्वयं के convert तरीकों के साथ आते हैं, इसलिए हम वास्तव में बस कर सकते हैं

julia> Card(7, ♠)
Card(seven::Rank = 7,♠::Suit = 3)

और चूंकि 7 को सीधे Rank बदला जा सकता है, यह निर्माण बॉक्स से बाहर काम करता है।

हम इन कार्डों के निर्माण के लिए वाक्यविन्यास चीनी को परिभाषित करना चाहते हैं; निहित गुणा इसे करने के लिए एक सुविधाजनक तरीका प्रदान करता है। परिभाषित करें

julia> import Base.*

julia> r::Int * s::Suit = Card(r, s)
* (generic function with 156 methods)

और फिर

julia> 10♣
Card(ten::Rank = 10,♣::Suit = 0)

julia> 5♠
Card(five::Rank = 5,♠::Suit = 3)

इन-बिल्ट convert फ़ंक्शंस का फ़ायदा उठाते हुए।

प्रतीकों का उपयोग हल्के enums के रूप में

हालाँकि, अधिकांश उपयोग के मामलों के लिए @enum मैक्रो काफी उपयोगी है, यह कुछ उपयोग मामलों में अत्यधिक हो सकता है। @enum नुकसान में शामिल हैं:

• यह एक नया प्रकार बनाता है
• इसका विस्तार करना थोड़ा कठिन है
• यह रूपांतरण, गणना, और तुलना जैसी कार्यक्षमता के साथ आता है, जो कुछ अनुप्रयोगों में बहुत अधिक हो सकता है

ऐसे मामलों में जहां एक हल्का-वजन विकल्प वांछित है, Symbol प्रकार का उपयोग किया जा सकता है। प्रतीक आंतरिक तार हैं ; वे पात्रों के दृश्यों का प्रतिनिधित्व करते हैं, जैसे कि बहुत कुछ करते हैं, लेकिन वे विशिष्ट रूप से संख्याओं से जुड़े होते हैं। यह अद्वितीय एसोसिएशन तेज प्रतीक समानता की तुलना में सक्षम बनाता है।

हम फिर से एक Card प्रकार को लागू कर सकते हैं, इस बार Symbol क्षेत्रों का उपयोग करके:

const ranks = Set([:ace, :two, :three, :four, :five, :six, :seven, :eight, :nine,
                   :ten, :jack, :queen, :king])
const suits = Set([:♣, :♦, :♥, :♠])
immutable Card
    rank::Symbol
    suit::Symbol
    function Card(r::Symbol, s::Symbol)
        r in ranks || throw(ArgumentError("invalid rank: $r"))
        s in suits || throw(ArgumentError("invalid suit: $s"))
        new(r, s)
    end
end

हम कंस्ट्रक्टर को दिए गए किसी भी गलत मान के लिए जाँच करने के लिए इनर कंस्ट्रक्टर को लागू करते हैं। @enum प्रकारों के उपयोग के उदाहरण के विपरीत, Symbol s में कोई भी स्ट्रिंग हो सकती है, और इसलिए हमें इस बात से सावधान रहना चाहिए कि हम किस प्रकार के Symbol स्वीकार करते हैं। यहां ध्यान दें कि शॉर्ट-सर्किट सशर्त ऑपरेटरों का उपयोग।

अब हम Card वस्तुओं का निर्माण कर सकते हैं जैसे हम उम्मीद करते हैं:

julia> Card(:ace, :♦)
Card(:ace,:♦)

julia> Card(:nine, :♠)
Card(:nine,:♠)

julia> Card(:eleven, :♠)
ERROR: ArgumentError: invalid rank: eleven
 in Card(::Symbol, ::Symbol) at ./REPL[17]:5

julia> Card(:king, :X)
ERROR: ArgumentError: invalid suit: X
 in Card(::Symbol, ::Symbol) at ./REPL[17]:6

Symbol s का एक प्रमुख लाभ उनकी रनटाइम एक्स्टेंसिबिलिटी है। यदि रनटाइम में, हम स्वीकार करना चाहते हैं (उदाहरण के लिए) :eleven एक नए रैंक के रूप में :eleven , यह केवल push!(ranks, :eleven) रन करने के लिए पर्याप्त है push!(ranks, :eleven) । @enum प्रकारों के साथ ऐसा रनटाइम एक्स्टेंसिबिलिटी संभव नहीं है।