Zsh में, फ़ंक्शन खोज पथ ($ fpath) निर्देशिकाओं के एक सेट को परिभाषित करता है, जिसमें ऐसी फाइलें होती हैं जिन्हें स्वचालित रूप से लोड करने के लिए चिह्नित किया जा सकता है जब उनके पास पहली बार होने वाले फ़ंक्शन की आवश्यकता होती है।
Zsh के पास ऑटोलोदिंग फ़ाइलों के दो तरीके हैं: Zsh का मूल तरीका और एक अन्य मोड जो ksh की ऑटोलडिंग के जैसा होता है। यदि KSH_AUTOLOAD विकल्प सेट है तो बाद वाला सक्रिय है। Zsh का मूल मोड डिफ़ॉल्ट है और मैं यहां दूसरे तरीके पर चर्चा नहीं करूंगा (ksh-style autoloading के बारे में विवरण के लिए "man zshmisc" और "man zshoptions")।
ठीक है। मान लें कि आपको एक निर्देशिका मिली ~ ~ / .zfunc 'और आप इसे फ़ंक्शन खोज पथ का हिस्सा बनाना चाहते हैं, आप ऐसा करते हैं:
fpath=( ~/.zfunc "${fpath[@]}" )
यह आपकी निजी निर्देशिका को खोज पथ के सामने जोड़ता है। यदि आप अपने स्वयं के साथ zsh के इंस्टॉलेशन से कार्यों को ओवरराइड करना चाहते हैं, तो यह महत्वपूर्ण है (जैसे, जब आप किसी अपडेटेड फंक्शन का उपयोग करना चाहते हैं, जैसे zsh के CVS रिपॉजिटरी से शेल के पुराने संस्करण के साथ)।
यह भी ध्यान देने योग्य है, कि '$ fpath' से निर्देशिकाओं को पुनरावर्ती रूप से नहीं खोजा गया है। यदि आप चाहते हैं कि आपकी निजी निर्देशिका को फिर से खोजा जाए, तो आपको खुद का ध्यान रखना होगा, इस तरह (निम्नलिखित स्निपेट को सेट करने के लिए `EXTENDED_GLOB 'विकल्प की आवश्यकता होती है):
fpath=(
~/.zfuncs
~/.zfuncs/**/*~*/(CVS)#(/N)
"${fpath[@]}"
)
यह अप्रशिक्षित आंख को गुप्त लग सकता है, लेकिन यह वास्तव में "सीवीएस" नामक निर्देशिकाओं को अनदेखा करते हुए '~ / .zfunc' के नीचे सभी निर्देशिकाओं को जोड़ता है, (जो कि उपयोगी है, यदि आप पूरी जांच करने की योजना बना रहे हैं। अपने निजी खोज पथ में zsh के सीवीएस से फ़ंक्शन ट्री)।
मान लें कि आपको एक फ़ाइल मिली है ~ ~ / .zfunc / hello 'जिसमें निम्न पंक्ति है:
printf 'Hello world.\n'
अब आपको केवल अपने पहले संदर्भ पर स्वचालित रूप से लोड होने वाले फ़ंक्शन को चिह्नित करना है :
autoload -Uz hello
"क्या है -यूज़ के बारे में?", आप पूछते हैं ठीक है, यह सिर्फ विकल्पों का एक सेट है जो `ऑटोलॉड 'का कारण होगा सही काम करने के लिए, इससे कोई फर्क नहीं पड़ता कि क्या विकल्प सेट किए जा रहे हैं। फ़ंक्शन लोड होने के दौरान `यू 'उर्फ विस्तार को अक्षम करता है और` z' शैली zsh- शैली को ऑटोलिडिंग करता है, भले ही `KSH_AUTOLOAD 'जो भी कारण से सेट हो।
उसके बाद ध्यान रखा गया है, आप अपने नए 'हैलो' फ़ंक्शन का उपयोग कर सकते हैं:
zsh% हैलो
नमस्ते दुनिया।
इन फाइलों को सोर्स करने के बारे में एक शब्द: यह सिर्फ गलत है । यदि आप स्रोत कि `~ / .zfunc / हैलो 'फाइल करते हैं, तो यह सिर्फ" हैलो वर्ल्ड "प्रिंट करेगा। एक बार। और कुछ नहीं। कोई फ़ंक्शन परिभाषित नहीं किया जाएगा। और इसके अलावा, विचार केवल फ़ंक्शन के कोड को लोड करना है जब यह आवश्यक हो । `ऑटोलोड’ कॉल के बाद फ़ंक्शन की परिभाषा नहीं पढ़ी जाती है। फ़ंक्शन को केवल आवश्यकतानुसार बाद में ऑटोलोडेड होने के लिए चिह्नित किया गया है।
और अंत में, $ FPATH और $ fpath के बारे में एक नोट: Zsh उन लोगों को जुड़े मापदंडों के रूप में रखता है। निचला केस पैरामीटर एक सरणी है। ऊपरी मामला संस्करण एक स्ट्रिंग स्केलर है, जिसमें प्रविष्टियों के बीच कॉलन द्वारा शामिल लिंक किए गए सरणी से प्रविष्टियां हैं। यह किया जाता है, क्योंकि स्केलर की सूची को संभालना एरे का उपयोग करके अधिक प्राकृतिक है, जबकि स्केल के पैरामीटर का उपयोग करने वाले कोड के लिए पीछे की संगतता भी बनाए रखना है। यदि आप $ FPATH (स्केलर वन) का उपयोग करना चुनते हैं, तो आपको सावधान रहने की आवश्यकता है:
FPATH=~/.zfunc:$FPATH
काम करेगा, जबकि निम्नलिखित नहीं होगा:
FPATH="~/.zfunc:$FPATH"
कारण यह है कि दोहरे उद्धरण चिह्नों के भीतर टिल्ड विस्तार का प्रदर्शन नहीं किया जाता है। यह आपकी समस्याओं का स्रोत है। यदि echo $FPATHएक टिल्ड प्रिंट करता है और एक विस्तारित मार्ग नहीं है, तो यह काम नहीं करेगा। सुरक्षित होने के लिए, मैं इस तरह से एक टिल्ड के बजाय $ HOME का उपयोग करूँगा:
FPATH="$HOME/.zfunc:$FPATH"
यह कहा जा रहा है, मैं बहुत से सरणी पैरामीटर का उपयोग करूँगा जैसे मैंने इस स्पष्टीकरण के शीर्ष पर किया था।
आपको $ FPATH पैरामीटर का निर्यात भी नहीं करना चाहिए। यह केवल वर्तमान शेल प्रक्रिया द्वारा आवश्यक है और इसके किसी भी बच्चे द्वारा नहीं।
अपडेट करें
'$ Fpath' में फ़ाइलों की सामग्री के बारे में:
जेड-स्टाइल ऑटोलॉडिंग के साथ, एक फ़ाइल की सामग्री उस फ़ंक्शन का शरीर है जिसे वह परिभाषित करता है। इस प्रकार "हेल्लो" नामक एक फाइल जिसमें एक लाइन होती है, echo "Hello world.""हेलो" नामक एक फ़ंक्शन को पूरी तरह से परिभाषित करती है। आप hello () { ... }कोड के चारों ओर रखने के लिए स्वतंत्र हैं
, लेकिन यह बहुत ही अच्छा होगा।
दावा है कि एक फ़ाइल में केवल एक फ़ंक्शन हो सकता है, हालांकि पूरी तरह से सही नहीं है।
विशेष रूप से यदि आप फ़ंक्शन आधारित पूर्ण प्रणाली (compsys) के कुछ कार्यों को देखते हैं, तो आप जल्दी से महसूस करेंगे कि यह एक गलत धारणा है। आप फ़ंक्शन फ़ाइल में अतिरिक्त फ़ंक्शन को परिभाषित करने के लिए स्वतंत्र हैं। आप किसी भी प्रकार के इनिशियलाइज़ेशन करने के लिए भी स्वतंत्र हैं, कि आपको पहली बार फंक्शन को करने की आवश्यकता हो सकती है। हालाँकि, जब आप करते हैं तो आप हमेशा एक फ़ंक्शन को परिभाषित करते हैं जिसका नाम फ़ाइल में फ़ाइल की तरह होता है और फ़ाइल के अंत में उस फ़ंक्शन को कॉल करता है , इसलिए यह फ़ंक्शन संदर्भित होने पर पहली बार चलता है।
यदि - उप-फ़ंक्शंस के साथ - आपने फ़ाइल के भीतर फ़ाइल की तरह एक फ़ंक्शन को परिभाषित नहीं किया है, तो आप उस फ़ंक्शन के साथ इसमें परिभाषाएँ (अर्थात् फ़ाइल में उप-फ़ंक्शन) को समाप्त करेंगे। हर बार जब आप फ़ंक्शन को फ़ाइल की तरह नामित किया जाता है, तो आप अपने सभी उप-कार्यों को प्रभावी ढंग से परिभाषित कर रहे होंगे। आम तौर पर, यह वह नहीं है जो आप चाहते हैं, इसलिए आप एक फ़ंक्शन को फिर से परिभाषित करेंगे, जिसे फ़ाइल के भीतर फ़ाइल की तरह नाम दिया गया है।
मैं एक छोटा कंकाल शामिल करूंगा, जिससे आपको अंदाजा होगा कि यह कैसे काम करता है:
# Let's again assume that these are the contents of a file called "hello".
# You may run arbitrary code in here, that will run the first time the
# function is referenced. Commonly, that is initialisation code. For example
# the `_tmux' completion function does exactly that.
echo initialising...
# You may also define additional functions in here. Note, that these
# functions are visible in global scope, so it is paramount to take
# care when you're naming these so you do not shadow existing commands or
# redefine existing functions.
hello_helper_one () {
printf 'Hello'
}
hello_helper_two () {
printf 'world.'
}
# Now you should redefine the "hello" function (which currently contains
# all the code from the file) to something that covers its actual
# functionality. After that, the two helper functions along with the core
# function will be defined and visible in global scope.
hello () {
printf '%s %s\n' "$(hello_helper_one)" "$(hello_helper_two)"
}
# Finally run the redefined function with the same arguments as the current
# run. If this is left out, the functionality implemented by the newly
# defined "hello" function is not executed upon its first call. So:
hello "$@"
यदि आप यह मूर्खतापूर्ण उदाहरण चलाते हैं, तो पहला रन इस तरह दिखाई देगा:
zsh% हैलो
आरंभ करीत आहे ...
नमस्ते दुनिया।
और लगातार कॉल इस तरह दिखाई देंगे:
zsh% हैलो
नमस्ते दुनिया।
मै उम्मीद करता हू कि यह बातें अब साफ है।
(उन सभी चालों का उपयोग करने वाले अधिक जटिल वास्तविक दुनिया उदाहरणों में से एक है, जो पहले से ही ज़ेड के फ़ंक्शन आधारित पूर्णता प्रणाली से ` _tmux 'फ़ंक्शन का उल्लेख करता है।)