tcl
प्रक्रिया के तर्क

टिप्पणियों

एक प्रक्रिया जो तर्कों को स्वीकार नहीं करती है

proc myproc {} {
    puts "hi"
}
myproc
# => hi

एक खाली तर्क सूची (प्रक्रिया नाम, "myproc" के बाद दूसरा तर्क) का अर्थ है कि प्रक्रिया तर्कों को स्वीकार नहीं करेगी।

एक प्रक्रिया जो दो तर्कों को स्वीकार करती है

proc myproc {alpha beta} {
    ...
    set foo $alpha
    set beta $bar     ;# note: possibly useless invocation
}

myproc 12 34          ;# alpha will be 12, beta will be 34

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

एक प्रक्रिया जो तर्कों की एक चर संख्या को स्वीकार करती है

### Definition
proc myproc {alpha {beta {}} {gamma green}} {
    puts [list $alpha $beta $gamma]
}

### Use
myproc A
# => A {} green
myproc A B
# => A B green
myproc A B C
# => A B C

यह प्रक्रिया एक, दो या तीन तर्कों को स्वीकार करती है: वे पैरामीटर जिनके नाम दो-आइटम सूची में पहला आइटम हैं, वैकल्पिक हैं। पैरामीटर चर ( alpha , beta , gamma ) के रूप में कई तर्क मान उपलब्ध हैं, जो बाएं से दाएं असाइन किए गए हैं। पैरामीटर चर जो किसी भी तर्क मान को प्राप्त नहीं करते हैं, उनके मूल्यों को उस सूची के दूसरे आइटम से प्राप्त करते हैं, जिसका वे हिस्सा थे।

ध्यान दें कि वैकल्पिक तर्क तर्क सूची के अंत में आने चाहिए। यदि तर्क _N-1 वैकल्पिक है, तो तर्क _N भी वैकल्पिक होना चाहिए। एक मामले में, जहां उपयोगकर्ता तर्क _एन है, लेकिन नहीं तर्क _N-1, तर्क _N-1 की जरूरत का डिफ़ॉल्ट मान स्पष्ट रूप से, पहले तर्क _एन उल्लेख किया जाना है, जबकि प्रक्रिया बुला में हैं।

myproc A B C D
# (ERROR) wrong # args: should be "myproc alpha ?beta? ?gamma?"

प्रक्रिया तीन से अधिक तर्कों को स्वीकार नहीं करती है: ध्यान दें कि तर्क सिंटैक्स का वर्णन करने वाला सहायक त्रुटि संदेश स्वचालित रूप से बनाया जाता है।

एक प्रक्रिया जो किसी भी तर्क को स्वीकार करती है

proc myproc args { ... }
proc myproc {args} { ... } ;# equivalent

यदि विशेष पैरामीटर नाम args तर्क सूची में अंतिम आइटम है, तो यह कमांड लाइन में उस बिंदु पर सभी तर्कों की एक सूची प्राप्त करता है। यदि कोई नहीं हैं, तो सूची खाली है।

वहाँ वैकल्पिक भी शामिल होते हैं तर्क है, इससे पहले, हो सकता है args :

proc myproc {alpha {beta {}} args} { ... }

यह प्रक्रिया एक या अधिक तर्कों को स्वीकार करेगी। पहले दो, यदि मौजूद हैं, तो alpha और beta द्वारा उपभोग किया जाएगा: बाकी तर्कों की सूची को args को सौंपा जाएगा।

वह प्रक्रिया जो किसी चर के नाम / संदर्भ को स्वीकार करती है

proc myproc {varName alpha beta} {
    upvar 1 $varName var
    set var [expr {$var * $alpha + $beta}]
}
set foo 1
myproc foo 10 5
puts $foo
# => 15

इस विशेष मामले में, प्रक्रिया को वर्तमान दायरे में एक चर का नाम दिया जाता है। एक Tcl प्रक्रिया के अंदर, ऐसे चर स्वचालित रूप से दिखाई नहीं देते हैं, लेकिन upvar कमांड किसी अन्य स्टैक स्तर से एक चर के लिए एक उपनाम बना सकता है: 1 का अर्थ है कॉलर का स्टैक स्तर, # 0 का अर्थ है वैश्विक स्तर, आदि। इस मामले में, स्टैक स्तर 1 और नाम foo (पैरामीटर चर varName ) upvar को उस चर को खोजने देता है और एक उपनाम बनाता है जिसे var कहा जाता है। var पर प्रत्येक पढ़ने या लिखने का संचालन कॉलर के स्टैक स्तर पर foo करने के लिए भी होता है।

{*} सिंटैक्स

कभी-कभी आपके पास एक सूची होती है, लेकिन आप जिस आइटम को सूची में आइटम पास करना चाहते हैं, वह प्रत्येक आइटम को एक अलग तर्क के रूप में प्राप्त करने की मांग करता है। उदाहरण के लिए: winfo children कमांड विंडोज़ की एक सूची देता है, लेकिन destroy कमांड केवल विंडो नाम तर्कों का एक क्रम लेगा।

set alpha [winfo children .]
# => .a .b .c
destroy $alpha
# (no response, no windows are destroyed)

समाधान {*} सिंटैक्स का उपयोग करना है:

destroy {*}[winfo children .]

या

destroy {*}$alpha

{*} सिंटैक्स क्या करता है वह निम्न मान लेना (बीच में कोई व्हाट्सएप नहीं है!) और उस मूल्य के आइटम को कमांड लाइन में इस तरह से विभाजित करें जैसे कि वे व्यक्तिगत तर्क थे।

यदि निम्न मान एक खाली सूची है, तो इसमें कुछ भी नहीं मिला है:

puts [list a b {*}{} c d]
# => a b c d

यदि एक या अधिक आइटम हैं, तो उन्हें सम्मिलित किया जाता है:

puts [list a b {*}{1 2 3} c d]
# => a b 1 2 3 c d