जूलिया। लिपियों और पार्सिंग कमांड लाइन तर्क

हम प्रोग्रामिंग भाषा जूलिया से निपटना जारी रखते हैं। चूंकि डेटा विश्लेषण और प्रसंस्करण पर केंद्रित भाषा के लिए बस बैच ऑपरेशन का होना आवश्यक है, इसलिए जूलिया भाषा में स्क्रिप्ट को लागू करने और कमांड लाइन से उनके लिए तर्क पारित करने की सुविधाओं पर विचार करें। यह विषय किसी के लिए सामान्य लग सकता है, लेकिन, भाषा की नवीनता को देखते हुए, मुझे आशा है कि जूलिया में प्रस्तुत इसके लिए कमांड लाइन तर्क और पुस्तकालयों को पार्स करने के तरीकों का एक छोटा सा अवलोकन अभी भी उपयोगी होगा।

शुरू करने के लिए, स्क्रिप्ट कैसे बनाई जाती है, इसके बारे में कुछ शब्द। कोई भी स्क्रिप्ट एक विशेष प्रारूप में एक पंक्ति से शुरू होती है जो दुभाषिया को इंगित करती है। रेखा की शुरुआत एक क्रम से होती है जिसे शेबंग के नाम से जाना जाता है। जूलिया के लिए, यह पंक्ति है:

#!/usr/bin/env julia 

बेशक, आप ऐसा नहीं कर सकते, लेकिन तब आपको स्क्रिप्ट को कमांड से चलाना होगा:

 julia .jl 

इसके अलावा, किसी भी स्क्रिप्ट को एक नए चरित्र के साथ समाप्त होना चाहिए। यह POSIX मानक की एक आवश्यकता है, जो एक स्ट्रिंग की परिभाषा से एक नई लाइन वर्ण द्वारा समाप्त किए गए वर्णों के अनुक्रम के रूप में होती है।

स्क्रिप्ट को सीधे चलाने के लिए, इसमें executable विशेषता होनी चाहिए। आप कमांड के साथ टर्मिनल में ऐसी विशेषता जोड़ सकते हैं:

 chmod +x .jl 

ये नियम, शायद, एमएस विंडोज को छोड़कर, सभी आधुनिक ऑपरेटिंग सिस्टम के लिए मान्य हैं।

ARGS सरणी

आइए मापदंडों को पारित करने के लिए पहले विकल्प पर जाएं। कमांड लाइन तर्क जूलिया स्क्रिप्ट में सरणी स्थिरांक Base.ARGS के माध्यम से उपलब्ध हैं। आइए सरलतम स्क्रिप्ट तैयार करें:

 #!/usr/bin/env julia @show typeof(ARGS) @show ARGS 

यह स्क्रिप्ट केवल ARGS सरणी के प्रकार और सामग्री को कंसोल के लिए प्रिंट करती है।

बहुत बार, फ़ाइल नाम कमांड लाइन तर्क के रूप में पारित किया जाता है। और यहाँ एक तर्क के रूप में पारित फ़ाइल टेम्पलेट को संसाधित करने की एक ख़ासियत है। उदाहरण के लिए, कमांड का उपयोग करके हमारी स्क्रिप्ट ./args.jl *.jl और प्राप्त करें:

 >./args.jl *.jl typeof(ARGS) = Array{String,1} ARGS = ["argparse.jl", "args.jl", "docopt.jl"] 

और अब चलो कमांड लाइन पैरामीटर को थोड़ा बदल दें, उद्धरण के साथ मुखौटा के आसपास:
./args.jl "*.jl" नतीजतन, हम प्राप्त करते हैं:

 >./args.jl "*.jl" typeof(ARGS) = Array{String,1} ARGS = ["*.jl"] 

हम स्पष्ट अंतर देखते हैं। पहले मामले में, हमें सभी फ़ाइलों के नाम के साथ एक सरणी मिली जो एक ही निर्देशिका में हैं। दूसरे मामले में, यह केवल वही मुखौटा है जिसे कमांड लाइन के तर्क के रूप में पारित किया गया था। स्क्रिप्ट के इस भिन्न व्यवहार का कारण यह है कि बैश दुभाषिया (और साथ ही उसके करीब वाले), जिससे स्क्रिप्ट चलाई गई थी, फ़ाइल नाम टेम्पलेट को पहचानता है। "बैश पैटर्न मैचिंग" या "बैश वाइल्डकार्ड्स" के लिए खोज इंजन में अधिक पाया जा सकता है। और सभी मिलकर इसे ग्लब्स कहते हैं।

टेम्प्लेट्स में, कई कैरेक्टर को मास्क करना संभव है - *, एक कैरेक्टर को मास्क करें -? .. रेंज द्वारा खोजें [...], और, यहां तक ​​कि, कॉम्प्लेक्स कॉम्बिनेशन को निर्दिष्ट करने की क्षमता:

 >./args.jl {args,doc}* typeof(ARGS) = Array{String,1} ARGS = ["args.jl", "docopt.jl"] 

अधिक जानकारी के लिए GNU / Linux कमांड-लाइन टूल सारांश देखें।

यदि, किसी कारण से, हम बैश द्वारा प्रदान किए गए ग्लब्स तंत्र का उपयोग नहीं करना चाहते हैं, तो आप ग्लब्स.ज्ल पैकेज का उपयोग करके स्क्रिप्ट से पहले से ही मास्क द्वारा फाइलें पा सकते हैं।
निम्न कोड तर्क स्ट्रिंग में पाई गई सभी चीज़ों को फ़ाइल नामों के एकल सरणी में रूपांतरित करता है। यही है, चाहे उपयोगकर्ता ने उद्धरण चिह्नों के बिना उद्धरण चिह्नों में मुखौटा निर्दिष्ट किया हो, या केवल मौजूदा या गैर-मौजूद फ़ाइलों के नामों को सूचीबद्ध किया हो, परिणामी filelist सरणी में केवल वास्तविक फ़ाइलों या निर्देशिकाओं के नाम ही रहेंगे।

 using Glob filelist = unique(collect(Iterators.flatten(map(arg -> glob(arg), ARGS)))) 

ये सरल उदाहरण, वास्तव में, ARGS सरणी के उपयोग का एक प्रदर्शन हैं, जहां प्रोग्रामर तर्कों को पार्स करने के लिए सभी तर्क को लागू करता है। यह दृष्टिकोण अक्सर उपयोग किया जाता है जब तर्कों का सेट बेहद सरल होता है। उदाहरण के लिए, फ़ाइल नामों की एक सूची। या एक या दो विकल्प जिन्हें सरल स्ट्रिंग ऑपरेशन द्वारा नियंत्रित किया जा सकता है। ARGS तत्वों तक पहुंच किसी भी अन्य सरणी के तत्वों के समान है। केवल याद रखें कि जूलिया में सरणी के पहले तत्व का सूचकांक 1 है।

पैकेज ArgParse.jl

यह पार्सिंग लॉजिक को लागू करने की आवश्यकता के बिना कमांड लाइन की विशेषताओं और विकल्पों का वर्णन करने के लिए एक लचीला उपकरण है।
हम पैकेज प्रलेखन से थोड़ा संशोधित उदाहरण का उपयोग करेंगे - http://carlobaldassi.imtqy.com/ArgParse.jl/stable/ :

 #!/usr/bin/env julia using ArgParse function parse_commandline() s = ArgParseSettings() @add_arg_table s begin "--opt1" help = "an option with an argument" "--opt2", "-o" help = "another option with an argument" arg_type = Int default = 0 "--flag1" help = "an option without argument, ie a flag" action = :store_true "arg1" help = "a positional argument" required = true end return parse_args(s) end function main() @show parsed_args = parse_commandline() println("Parsed args:") for (arg,val) in parsed_args print(" $arg => ") show(val) println() end end main() 

अगर हम इस स्क्रिप्ट को बिना तर्क के चलाते हैं, तो हमें उनकी रचना पर संदर्भ जानकारी का आउटपुट मिलता है:

 >./argparse.jl required argument arg1 was not provided usage: argparse.jl [--opt1 OPT1] [-o OPT2] [--flag1] arg1 

इसके अलावा, वर्ग कोष्ठक में हम वैकल्पिक तर्क देखते हैं। जबकि arg1 के रूप में चिह्नित तर्क (अर्थात, हम इसके लिए क्या विकल्प देते हैं) अनिवार्य है।

इसे फिर से चलाएँ, लेकिन आवश्यक विशेषता arg1 निर्दिष्ट करें।

 >./argparse.jl test parsed_args = parse_commandline() = Dict{String,Any}("flag1"=>false,"arg1"=>"test","opt1"=>nothing,"opt2"=>0) Parsed args: flag1 => false arg1 => "test" opt1 => nothing opt2 => 0 

हम देख सकते हैं कि parsed_args एक साहचर्य सारणी है, जहाँ चाबियाँ parse_commandline फ़ंक्शन में की गई घोषणा के अनुसार विशेषताओं के नाम हैं, और उनके मान वही हैं जो डिफ़ॉल्ट रूप से सेट किए गए थे या कमांड लाइन तर्कों के मान के रूप में पारित किए गए थे। इसके अलावा, मान उस प्रकार के होते हैं जो घोषणा के दौरान स्पष्ट रूप से निर्दिष्ट होते हैं।

@add_arg_table मैक्रो का उपयोग करके तर्क @add_arg_table किए जाते हैं। विकल्पों की घोषणा करना संभव है:

  "--opt2", "-o" help = "another option with an argument" arg_type = Int default = 0 

या तर्क

  "arg1" help = "a positional argument" required = true 

इसके अलावा, विकल्पों को पूर्ण और लघु रूप (एक ही समय में --opt2 और -o ) का संकेत दिया जा सकता है। या, केवल एक ही रूप में। प्रकार को arg_type फ़ील्ड में निर्दिष्ट किया गया है। डिफ़ॉल्ट मान को default = ... का उपयोग करके सेट किया जा सकता है default = ... डिफ़ॉल्ट मान का एक विकल्प तर्क की आवश्यकता है - required = true ।
उदाहरण के लिए, किसी तर्क की मौजूदगी या अनुपस्थिति के आधार पर, स्वचालित कार्रवाई की घोषणा करना संभव है, उदाहरण के लिए true या false । यह action = :store_true का उपयोग करके किया जाता है

  "--flag1" help = "an option without argument, ie a flag" action = :store_true 

help फील्ड में वह टेक्स्ट होता है जो कमांड लाइन पर प्रॉम्प्ट में प्रदर्शित होगा।
यदि स्टार्टअप में हम सभी विशेषताओं को निर्दिष्ट करते हैं, तो हम प्राप्त करते हैं:

 >./argparse.jl --opt1 "2+2" --opt2 "4" somearg --flag parsed_args = parse_commandline() = Dict{String,Any}("flag1"=>true,"arg1"=>"somearg","opt1"=>"2+2","opt2"=>4) Parsed args: flag1 => true arg1 => "somearg" opt1 => "2+2" opt2 => 4 

एटम / जूनो आईडीई से डीबगिंग के लिए, स्क्रिप्ट की पहली पंक्तियों में आप एआरजीएस सरणी को आरंभीकृत करने के लिए निम्नलिखित, कुछ गंदे, लेकिन काम करने वाले कोड को जोड़ सकते हैं।

 if (Base.source_path() != Base.basename(@__FILE__)) vcat(Base.ARGS, ["--opt1", "2+2", "--opt2", "4", "somearg", "--flag"] ) end 

मैक्रो @__FILE__ उस फ़ाइल का नाम है जिसमें मैक्रो तैनात है। और REPL के लिए यह नाम Base.source_path() माध्यम से प्राप्त वर्तमान प्रोग्राम फ़ाइल के नाम से अलग है। Base.ARGS भिन्न मान के Base.ARGS सरणी Base.ARGS को प्रारंभ करना असंभव है, लेकिन एक ही समय में, आप नई लाइनें जोड़ सकते हैं, क्योंकि सरणी स्वयं एक स्थिर नहीं है। जूलिया के लिए एक सरणी एक स्तंभ है, इसलिए हम vcat (ऊर्ध्वाधर vcat ) का उपयोग करते हैं।

हालाँकि, जूनो संपादक की सेटिंग में, आप स्क्रिप्ट चलाने के लिए तर्क सेट कर सकते हैं। लेकिन उन्हें हर बार अलग-अलग डीबग की गई स्क्रिप्ट के लिए हर बार बदलना होगा।

पैकेज DocOpt.jl

यह विकल्प docopt मार्कअप भाषा दृष्टिकोण का एक कार्यान्वयन है - http://docopt.org/ । इस भाषा का मुख्य विचार एक रूप में विकल्पों और तर्कों का एक घोषणात्मक विवरण है, जो एक स्क्रिप्ट का आंतरिक विवरण भी हो सकता है। एक विशेष टेम्पलेट भाषा का उपयोग किया जाता है।

हम इस पैकेज के लिए प्रलेखन से एक उदाहरण का उपयोग करेंगे https://github.com/docopt/DocOpt.jl

 #!/usr/bin/env julia doc = """Naval Fate. Usage: naval_fate.jl ship new <name>... naval_fate.jl ship <name> move <x> <y> [--speed=<kn>] naval_fate.jl ship shoot <x> <y> naval_fate.jl mine (set|remove) <x> <y> [--moored|--drifting] naval_fate.jl -h | --help naval_fate.jl --version Options: -h --help Show this screen. --version Show version. --speed=<kn> Speed in knots [default: 10]. --moored Moored (anchored) mine. --drifting Drifting mine. """ using DocOpt # import docopt function args = docopt(doc, version=v"2.0.0") @show args 

नोटेशन doc = ... जूलिया doc स्ट्रिंग का निर्माण है, जिसमें डॉकटॉप के लिए संपूर्ण घोषणा है। बिना तर्क के कमांड लाइन पर चलने का परिणाम होगा:

 >./docopt.jl Usage: naval_fate.jl ship new <name>... naval_fate.jl ship <name> move <x> <y> [--speed=<kn>] naval_fate.jl ship shoot <x> <y> naval_fate.jl mine (set|remove) <x> <y> [--moored|--drifting] naval_fate.jl -h | --help naval_fate.jl --version 

यदि हम संकेत का उपयोग करते हैं और "एक नया जहाज बनाने" की कोशिश करते हैं, तो हमें साहचर्य args सरणी का एक प्रिंटआउट मिलता है, जो कमांड लाइन को पार्स करने के परिणाम से उत्पन्न हुआ था

 >./docopt.jl ship new Bystriy args = Dict{String,Any}( "remove"=>false, "--help"=>false, "<name>"=>["Bystriy"], "--drifting"=>false, "mine"=>false, "move"=>false, "--version"=>false, "--moored"=>false, "<x>"=>nothing, "ship"=>true, "new"=>true, "shoot"=>false, "set"=>false, "<y>"=>nothing, "--speed"=>"10") 

docopt फ़ंक्शन docopt रूप docopt घोषित किया गया है:

 docopt(doc::AbstractString, argv=ARGS; help=true, version=nothing, options_first=false, exit_on_error=true) 

नामित तर्क help , version , oprtions_first , exit_on_error डिफ़ॉल्ट रूप से तर्क कमांड पार्सर के व्यवहार को निर्दिष्ट करते हैं। उदाहरण के लिए, त्रुटियों के मामले में - निष्पादन को पूरा करने के लिए, संस्करण अनुरोध पर, मान version=… लौटाएं version=… -h अनुरोध पर - मुद्दा मदद। options_first उपयोग यह इंगित करने के लिए किया जाता है कि विकल्प स्थितीय तर्क से पहले होने चाहिए।

अब, आइए इस घोषणात्मक भाषा और प्रवेश मानों के तर्क पार्सर की प्रतिक्रिया पर करीब से नज़र डालें।

घोषणा मनमाने ढंग से पाठ के साथ शुरू होती है, जो कमांड लाइन के लिए पाठ के अलावा, स्क्रिप्ट के प्रलेखन का हिस्सा हो सकती है। सेवा शब्द "यूज़:" इस स्क्रिप्ट के लिए उपयोग पैटर्न की घोषणा करता है।

 Usage: naval_fate.jl ship new <name>... naval_fate.jl ship <name> move <x> <y> [--speed=<kn>] 

तर्क के रूप में घोषित किया जाता है <name> , <x> , <y> । ध्यान दें कि पहले प्राप्त किए गए args साहचर्य सरणी में, ये तर्क कुंजियों के रूप में कार्य करते हैं। हमने लॉन्च फॉर्म का उपयोग किया ./docopt.jl ship new Bystriy , ताकि हमें निम्नलिखित स्पष्ट रूप से प्रारंभिक मान ./docopt.jl ship new Bystriy :

  "<name>"=>["Bystriy"], "ship"=>true, "new"=>true, 

Docopt भाषा के अनुसार, वर्ग ब्रैकेट में वैकल्पिक तत्व निर्दिष्ट किए जाते हैं। उदाहरण के लिए [--speed=<kn>] । अनिवार्य तत्व कोष्ठक में निर्दिष्ट हैं, लेकिन एक निश्चित स्थिति के साथ। उदाहरण के लिए (set|remove) उनमें से एक के लिए आवश्यकता सेट करता है। यदि तत्व कोष्ठक के बिना निर्दिष्ट किया गया है, उदाहरण के लिए naval_fate.jl --version , यह कहता है कि इस विशेष रन विकल्प में, --version एक आवश्यक विकल्प है।

अगला भाग विकल्प विवरण अनुभाग है। यह शब्द "विकल्प:" से शुरू होता है
प्रत्येक को एक अलग लाइन पर विकल्प घोषित किया जाता है। पंक्ति की शुरुआत के बाईं ओर पैडिंग महत्वपूर्ण है। प्रत्येक विकल्प के लिए, आप पूर्ण और संक्षिप्त रूप निर्दिष्ट कर सकते हैं। साथ ही टूलटिप में प्रदर्शित विकल्प का विवरण। इस मामले में, विकल्प -h | --help, --version -h | --help, --version स्वचालित रूप से पहचाने जाते हैं। उनकी प्रतिक्रिया docopt फंक्शन के लिए तर्कों द्वारा दी गई है। घोषणा पर विचार करना दिलचस्प है:

  --speed=<kn> Speed in knots [default: 10]. 

यहां फ़ॉर्म ...=<kn> कुछ मान की उपस्थिति को परिभाषित करता है, और [default: 10] डिफ़ॉल्ट मान को परिभाषित करता है। हम फिर से मानों में प्राप्त मानों की ओर मुड़ते हैं:

 "--speed"=>"10" 

मूल अंतर, उदाहरण के लिए, ArgParse पैकेज से, यह है कि मान टाइप नहीं किए गए हैं। यही है, default: 10 मान स्ट्रिंग "10" के रूप में सेट किया गया है।
अन्य तर्कों के लिए, जो तर्कों को पार्स करने के परिणामस्वरूप प्रस्तुत किए जाते हैं, आपको उनके मूल्यों पर ध्यान देना चाहिए:

  "remove"=>false, "--help"=>false, "--drifting"=>false, "mine"=>false, "move"=>false, "--version"=>false, "--moored"=>false, "<x>"=>nothing, "shoot"=>false, "set"=>false, "<y>"=>nothing, 

यही है, सभी उपयोग के मामलों के लिए डॉक्टॉप घोषणा में निर्दिष्ट टेम्पलेट के बिल्कुल सभी तत्व मूल नामों के साथ विश्लेषण के परिणामस्वरूप प्रस्तुत किए जाते हैं। कमांड लाइन पर मौजूद सभी वैकल्पिक तर्क यहाँ झूठे हैं। तर्क <x> , <y> भी लॉन्च लाइन से गायब हैं और मूल्य कुछ भी नहीं है। अन्य तर्क जिनके लिए पार्सिंग पैटर्न का मिलान हुआ, उन्हें सच्चे मूल्य मिले:

  "ship"=>true, "new"=>true, 

और हम पहले ही टेम्पलेट के निम्नलिखित तत्वों के लिए विशिष्ट मान प्राप्त कर चुके हैं:

  "<name>"=>["Bystriy"], "--speed"=>"10" 

पहला मान कमांड लाइन पर एक तर्क प्रतिस्थापन के रूप में स्पष्ट रूप से सेट किया गया था, और दूसरा डिफ़ॉल्ट मान के साथ एक विकल्प था।

यह भी ध्यान दें कि वर्तमान स्क्रिप्ट के नाम की गणना स्वचालित रूप से की जा सकती है।
उदाहरण के लिए, हम दर्ज कर सकते हैं:

 doc = """Naval Fate. Usage: $(Base.basename(@__FILE__)) ship new <name>… """ 

कमांड लाइन तर्क पार्सर को रखने के लिए एक अतिरिक्त सिफारिश इसे फ़ाइल की शुरुआत में रखना है। फिलहाल जूलिया की एक अप्रिय विशेषता मॉड्यूल का एक लंबा कनेक्शन है। उदाहरण के लिए using Plots; using DataFrames using Plots; using DataFrames कुछ सेकंड के लिए प्रतीक्षा करने के लिए एक स्क्रिप्ट भेज सकते हैं। यह सर्वर-साइड, एकल-लोड स्क्रिप्ट के लिए कोई समस्या नहीं है, लेकिन यह उन उपयोगकर्ताओं को नाराज करेगा जो केवल कमांड कमांड तर्क के लिए एक संकेत देखना चाहते हैं। इसीलिए, पहले आपको कमांड लाइन के तर्कों को मदद और जांचने की आवश्यकता है, और उसके बाद ही, काम के लिए आवश्यक पुस्तकालयों को डाउनलोड करने के लिए आगे बढ़ें।

निष्कर्ष

लेख जूलिया में पार्स तर्कों के सभी तरीकों पर विचार करने का नाटक नहीं करता है। हालांकि, माना गया विकल्प, वास्तव में, 3 संभावित विकल्पों को कवर करता है। ARGS सरणी का पूरी तरह से मैनुअल विश्लेषण। कड़ाई से घोषित लेकिन स्वचालित रूप से ArgParse में तर्क पार्स। और पूरी तरह से घोषणात्मक, हालांकि सख्त नहीं, डॉकॉप्ट का रूप। उपयोग के मामले का चुनाव पूरी तरह से पार्स तर्कों की जटिलता पर निर्भर करता है। डॉकॉप्ट का उपयोग करने वाला विकल्प उपयोग करने में सबसे आसान लगता है, हालांकि इसके लिए प्राप्त तर्कों के मूल्यों के लिए एक स्पष्ट प्रकार के रूपांतरण की आवश्यकता होती है। हालाँकि, यदि स्क्रिप्ट फ़ाइल नाम के अलावा कुछ भी स्वीकार नहीं करती है, तो सामान्य println("Run me with file name") फ़ंक्शन का उपयोग करके उस पर सहायता जारी करने का लाभ उठाना संभव है, और ARGS से सीधे फ़ाइल नामों को पार्स करें पहले खंड में।

संदर्भ

• https://github.com/vtjnash/Glob.jl
• https://argparsejl.readthedocs.io/en/latest/argparse.html
• https://github.com/carlobaldassi/ArgParse.jl/
• http://docopt.org/
• https://github.com/docopt/DocOpt.jl