इन्फर्नो शेल

अक्सर पूछे जाने वाले प्रश्न: ओएस इन्फर्नो क्या है और इसकी आवश्यकता क्यों है?

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

फिर भी, मैं अधिक निष्पक्षता के लिए, कमियों के साथ शुरुआत करूँगा। मुख्य बात यह है कि शेल बहुत धीमा है। यह ज्ञात नहीं है कि क्यों, लेकिन सभी गोले नरक हैं (वास्तव में उनमें से कई हैं, लेकिन अब हम /dis/sh.dis बारे में बात कर रहे हैं) वे बहुत धीमी हैं। यह बेहद अजीब है क्योंकि आमतौर पर लिम्बो (JIT मोड में) लिखे गए अनुप्रयोगों की गति C की गति और पर्ल जैसी तेज़ स्क्रिप्टिंग भाषाओं के बीच है। इसलिए, sh पर पूर्ण-पूर्ण अनुप्रयोग काम नहीं करेंगे। लेकिन, फिर भी, हर छींक के लिए लिम्बो को उजागर करना भी असुविधाजनक है, इसलिए सभी शुरुआती स्क्रिप्ट और अन्य छोटी चीजों को अभी भी sh में sh । दूसरा गंभीर दोष यह है कि इसे टेक्स्ट कंसोल, कमांड हिस्ट्री की कमी, ऑटो- कम्पलीट , सुविधाजनक एडिटिंग में कमी होने पर टाइपिंग बहुत परेशान करती है (लेकिन मुझे सिर्फ rlwrap उपयोगिता के बारे में बताया गया था, rlwrap -a माध्यम से ईएमयू चलाने से लगता है कि इस समस्या का समाधान हो गया है)। तीसरा - इस खोल का वाक्यविन्यास अप्रकाशित उद्धरणों का उपयोग करते हुए असामान्य है, जो कि किसी भी अन्य शेल के लिए बैकलाइट का उपयोग करके अपनी लिपियों के सिंटैक्स को उजागर करने का प्रयास करते समय (हीनल के लिए तैयार बैकलाइट की कमी के कारण) एक पूर्ण दुःस्वप्न की ओर जाता है। मैं आज इस समस्या को हल करने जा रहा हूं, सिंटैक्स हाइलाइटिंग को विम के लिए लागू करके, जिसके लिए मैं शेल से निपटने के लिए बैठ गया ... और परिणामस्वरूप सिंटैक्स हाइलाइटिंग के बजाय, मैं विरोध नहीं कर सका, और मैं यह लेख लिख रहा हूं। :)

सामग्री

• क्या, किस से, हमारी स्क्रिप्ट से क्या बना है?
• एप्लिकेशन लॉन्च करें
  
  • अतिरिक्त कमांड I / O रीडायरेक्ट
  • $ स्थिति
• लाइनें, लाइन सूची, कमांड ब्लॉक
  
  • पंक्ति
  • कमांड ब्लॉक
  • लाइनों की सूची
• पर्यावरण चर
  
  • / एन.वी.
  • सूचियों
  • स्कोप
  • परिवर्तनीय संदर्भ
• अवरोधन कमांड आउटपुट
• बिल्ट-इन कमांड
• यदि, कार्यों के लिए जोड़ें
  
  • हम अपने "कार्य" करते हैं
  • आपके लिए बनाना
• दिलचस्प छोटी बातें
• सारांश

क्या, किस से, हमारी स्क्रिप्ट से क्या बना है?

बॉक्स से बाहर / /dis/sh.dis द्वारा समर्थित कार्यक्षमता प्रभावशाली है! सशर्त बयान और लूप भी नहीं हैं! कोई सुविधाएँ नहीं। और फिर वहाँ क्या है, और इन स्थितियों में कोई कैसे मौजूद हो सकता है? अब देखें। तो क्या है:

• लॉन्च एप्लिकेशन (पाइपलाइन और I / O पुनर्निर्देशन सहित)
• लाइनें, लाइन सूची, कमांड ब्लॉक
• पर्यावरण चर
• फ़ाइल का नाम टेम्प्लेट (*;; [...])
• और कुछ अंतर्निहित कमांड और स्ट्रिंग्स के साथ काम करने के लिए आदेश

शायद, आखिरी बिंदु को देखकर, आपने सोचा, “अहा! कुछ विशेष टीमें। निश्चित रूप से वे बाकी काम करते हैं, सब कुछ कॉर्नी है। "... लेकिन नहीं, आपने अनुमान नहीं लगाया है। अंतर्निहित आदेशों में से, आमतौर पर तीन का उपयोग किया जाता है: exit , run और load ; और आमतौर पर इस्तेमाल किए जाने वाले स्ट्रिंग कमांड्स quote और unquote । run , यह वर्तमान शेल में निर्दिष्ट स्क्रिप्ट को निष्पादित करता है (एनालॉग . या बैश में source )।

लेकिन load - हाँ, यह एक बम है! यह आपको अतिरिक्त मॉड्यूल लोड करने की अनुमति देता है जो लिंबो पर वर्तमान शेल में लिखे गए हैं और आपको शेल में बिल्कुल किसी भी कार्यक्षमता को जोड़ने की अनुमति देते हैं - अगर, के लिए, कार्य, अपवाद, नियमित अभिव्यक्ति, गणितीय संचालन आदि। आदि एक unload कमांड भी है जो आपको इन मॉड्यूल को गतिशील रूप से अनलोड करने की अनुमति देता है। :) फिर भी, लोड करने योग्य मॉड्यूल के बिना भी, शेल बिल्कुल पूर्ण और कार्यात्मक है - जिसे मैं "नंगे श" पर और इसके लिए लागू करके लेख के अंत में साबित करूंगा!

ओह, कुछ और मैं उल्लेख करना भूल गया। (क्या आपको लगता है कि अब यह निश्चित रूप से "अहा!" नहीं है।) वह अभी भी टिप्पणियों का समर्थन करता है। # शुरू। :)

एप्लिकेशन लॉन्च करें

किसी भी * निक्स शेल के समान:

• अनुप्रयोग ( .dis फ़ाइलें) और स्क्रिप्ट चलाता है ( .dis फ़ाइलें जिनमें पहली पंक्ति shebang #! )
• टीमों को अलग किया जाता है ;
• के माध्यम से पृष्ठभूमि में चल रहे आदेश &
• कमांड पाइपलाइनों के माध्यम से |
• > , >> और < माध्यम से stdin / stdout को पुनर्निर्देशित करता है

 ; echo one two | wc 1 2 8 

लेकिन मतभेद हैं।

अतिरिक्त कमांड I / O रीडायरेक्ट

• फ़ाइल डिस्क्रिप्टर निर्दिष्ट करना (stderr को पुनर्निर्देशित करना या अतिरिक्त डिस्क्रिप्टर को 0, 1 और 2 द्वारा उपलब्ध विवरण के लिए खोलना)
  
  • cmd <stdin.txt >stdout.txt >[2]stderr.txt
  • cmd >[1=2] (stderr के लिए स्टड पुनर्निर्देशित)
  • cmd <[3]file.txt (फ़ाइल से पढ़ने के लिए एक अतिरिक्त फ़ाइल डिस्क्रिप्टर 3 ओपन के साथ कमांड लॉन्च किया गया है)
  • cmda |[2] cmdb (पहले कमांड के cmda |[2] cmdb बजाय, इसका cmda |[2] cmdb पाइपलाइन इनपुट पर भेजा जाता है, और स्टडआउट बस स्क्रीन पर प्रदर्शित होता है)
  • cmda |[1=2] cmdb (stderr को फिर से पाइपलाइन में भेजा जाता है, stdout cmda को नहीं, बल्कि यह स्टड को नहीं, बल्कि cmdb को जोड़ता है - जो पढ़ने के लिए खुलता है और लिखने में नहीं, बेशक)
  
  
• पढ़ने और लिखने के लिए एक ही समय में खोलना
  
  • cmd <>in_pipe <>[1]out_pipe (एक ही समय में अलग-अलग फ़ाइलों को पढ़ने और लिखने के लिए cmd <>in_pipe <>[1]out_pipe और cmd <>in_pipe <>[1]out_pipe खुले हैं)
  
  
• नॉनलाइनर कन्वेयर
  
  • cmd <{;;} >{;;} ( cmd <{;;} >{;;} दोनों ब्लॉक सेमी के साथ समानांतर में लॉन्च किए गए हैं, जबकि cmd को दो पैरामीटर मिलते हैं - फ़ाइल का नाम a la /fd/ , जो पहले के स्टडआउट करने के लिए पाइप के माध्यम से जुड़े हुए हैं। कमांड ब्लॉक और दूसरी कमांड ब्लॉक की स्टडिन)
  
  

अंतिम विशेषता विशेष रूप से दिलचस्प है। उदाहरण के लिए, इसकी मदद से दो cmp फ़ाइलों की तुलना करने के लिए मानक कमांड फ़ाइलों की तुलना नहीं कर सकता है, लेकिन दो अन्य आदेशों के परिणाम: cmp <{ ls /dir1 } <{ ls /dir2 } ।

$ स्थिति

निकास स्थिति एप्लिकेशन कोड को लागू करने के लिए एक असामान्य रूप से असामान्य दृष्टिकोण। पारंपरिक ऑपरेटिंग सिस्टम में, कोई भी प्रोग्राम एक संख्या के साथ समाप्त होता है: 0 यदि सब कुछ क्रम में है, और कोई अन्य यदि यह विफल रहता है। नरक में, कोई भी कार्यक्रम या तो समाप्त हो जाता है (यदि सब कुछ क्रम में है) या एक अपवाद फेंकता है, जिसका मूल्य त्रुटि पाठ के साथ एक स्ट्रिंग है।

एक समझौता अपनाया गया है, जिसके अनुसार यह रेखा "असफल:" के साथ शुरू होनी चाहिए यदि यह एक नियमित त्रुटि है - अर्थात। एप्लिकेशन "क्रैश" नहीं हुआ, लेकिन बस इस त्रुटि को वापस करके बाहर निकलना चाहता है जिसने इस एप्लिकेशन को लॉन्च किया (आमतौर पर यह एक शेल है)। यदि त्रुटि "विफल:" से शुरू नहीं होती है, तो आवेदन समाप्त होने के बाद, इसकी प्रक्रिया मेमोरी में ("टूटी हुई" स्थिति में) रहेगी, ताकि डिबगर्स द्वारा इसकी जांच की जा सके और पता चल सके कि यह अपवाद क्यों हुआ (केवल कोर बचत के अनुरूप, बचत के बजाय) वे स्मृति में एक डिस्क पर लटकाते हैं)।

इसलिए, एक रनिंग कमांड के पूरा होने के बाद, इसका "एग्जिट कोड" - अर्थात अपवाद-त्रुटि पाठ $status परिवेश चर में होगा ("विफल:" उपसर्ग स्वचालित रूप से इसे हटा दिया जाएगा, यदि अपवाद पाठ को छोड़कर "विफल:" में कुछ और शामिल नहीं था, तो " $status " रेखा $status में "विफल" हो जाएगी)।

लाइनें, लाइन सूची, कमांड ब्लॉक

Infernov खोल केवल तार और तारों की सूची से संबंधित है।

पंक्ति

एक स्ट्रिंग या तो एक शब्द है जिसमें रिक्त स्थान या कुछ विशेष वर्ण या एकल उद्धरण में संलग्न कोई वर्ण नहीं है। इस तरह के एक तार में केवल "पलायन योग्य" चरित्र ही एकल उद्धरण है, और यह दो ऐसे उद्धरणों के साथ लिखा गया है:

 ; echo 'quote '' <-- here' quote ' <-- here 

कोई \ n, \ t, चर का प्रक्षेप, आदि। पंक्तियों में समर्थित नहीं है। यदि आपको एक स्ट्रिंग में एक लाइनफीड चरित्र सम्मिलित करने की आवश्यकता है, तो या तो इसे (एंटर दबाकर) पेस्ट करें या स्ट्रिंग को इस वर्ण वाले चर के साथ समतल करें। नरक में, एक यूनिकोड (1) उपयोगिता है जो किसी भी वर्ण को उसके कोड द्वारा आउटपुट कर सकती है, यह वही है जो इसकी मदद से किया गया है (निर्माण "{} नीचे वर्णित है, लेकिन अब इस पर विचार करें bash `` का एक एनालॉग):

 ; cr="{unicode -t 0D} ; lf="{unicode -t 0A} ; tab="{unicode -t 09} ; echo -n 'a'$cr$lf'b'$tab'c' | xd -1x 0000000 61 0d 0a 62 09 63 0000006 

डबल कोट्स स्ट्रिंग्स के लिए उपयोग नहीं किए जाते हैं (वैसे, डबल डबल कोट्स का उपयोग किसी चीज के लिए शेल में नहीं किया जाता है)।

कमांड ब्लॉक

कमांड का एक ब्लॉक घुंघराले ब्रैकेट के अंदर लिखा जाता है, और पूरे ब्लॉक को शेल द्वारा एक लाइन (घुंघराले ब्रैकेट में वर्ण सहित) के रूप में संसाधित किया जाता है।

 ; { echo one; echo two } one two ; '{ echo one; echo two }' one two 

एकल उद्धरण में एक स्ट्रिंग से एकमात्र अंतर यह है कि sh कमांड कमांड ब्लॉक के सिंटैक्स की जांच करता है और उन्हें अधिक कॉम्पैक्ट लाइनों में सुधार करता है।

 ; echo { cmd | } sh: stdin: parse error: syntax error ; echo { cmd | cmd } {cmd|cmd} ; echo { echo one echo two } {echo one;echo two} 

लाइनों की सूची

स्ट्रिंग्स की सूची केवल शून्य या अधिक स्ट्रिंग्स हैं जो व्हाट्सएप वर्णों द्वारा अलग किए गए हैं। उन्हें कोष्ठकों में संलग्न किया जा सकता है, लेकिन अधिकांश मामलों में यह आवश्यक नहीं है।

कोई भी शेल कमांड केवल लाइनों की एक सूची है , जहां पहली पंक्ति में एक कमांड या कोड का एक ब्लॉक होता है, और शेष लाइनें उनके लिए पैरामीटर हैं।

 ; echo one two three one two three ; echo (one two) (three) one two three ; (echo () (one (two three))) one two three ; ({echo Hello, $1!} World) Hello, World! 

स्ट्रिंग्स की सूचियों को संक्षिप्त करने के लिए, ^ ऑपरेटर का उपयोग करें। इसे दो सूचियों पर लागू किया जा सकता है, जिसमें तत्वों की एक ही संख्या होती है (फिर तत्वों को जोड़े में समाप्‍त किया जाता है), या सूची में से किसी एक में केवल एक तत्‍व होना चाहिए, फिर दूसरी सूची के प्रत्‍येक तत्‍व के साथ सम्‍मिलित किया जाएगा। एक विशेष मामले के रूप में, यदि दोनों सूचियों में केवल एक तत्व होता है, तो दो लाइनों का सामान्य संयोजन प्राप्त होता है।

 ; echo (abc) ^ (1 2 3) a1 b2 c3 ; echo (ab) ^ 1 a1 b1 ; echo 1 ^ (ab) 1a 1b ; echo a ^ b ab 

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

पर्यावरण चर

एक काल्पनिक खोल में चर के साथ काम करना भ्रामक रूप से पारंपरिक गोले के समान दिखता है, लेकिन अपने आप को इस से मूर्ख मत बनने दो!

 ; a = 'World' ; echo Hello, $a! Hello, World! 

/ एन.वी.

इन्फर्नो ओएस में पर्यावरण चर पारंपरिक ओएस की तुलना में अलग तरीके से लागू किए जाते हैं। पर्यावरण चर के साथ काम करने के लिए और उन्हें एक बुरे सपने के माध्यम से प्रत्येक प्रक्रिया को पारित करने के लिए एक अतिरिक्त POSIX API शुरू करने के बजाय जैसे int execvpe(const char *file, char *const argv[], char *const envp[]); पर्यावरण चर /env निर्देशिका में बस फाइलें हैं। यह दिलचस्प संभावनाएं प्रदान करता है, उदाहरण के लिए, एक एप्लिकेशन नेटवर्क पर अन्य अनुप्रयोगों के लिए अपने पर्यावरण चर तक पहुंच प्रदान कर सकता है - बस निर्यात करके ( सुनो (1) और निर्यात (4) ) इसके /env ।

आप /env में फ़ाइलें बनाकर, हटाकर और संशोधित करके पर्यावरण चर बना / हटा / संशोधित कर सकते हैं। लेकिन ध्यान रखें कि करंट शॉ मेमोरी में सभी पर्यावरण वेरिएबल्स की एक प्रति रखता है, इसलिए /env में फ़ाइलों के माध्यम से किए गए परिवर्तनों को लॉन्च किए जाने वाले एप्लिकेशन दिखाई देंगे, लेकिन वर्तमान श नहीं। दूसरी ओर, शेल ( = ऑपरेटर) के माध्यम से सामान्य तरीके से चर को बदलते हुए, आप स्वचालित रूप से /env में फ़ाइलों को अपडेट करते हैं।

शेल चर नामों में कोई भी वर्ण शामिल हो सकते हैं, जिनमें जिन्हें फ़ाइल नाम (उदाहरण के लिए, नाम, .. और युक्त / ) की अनुमति नहीं है। ऐसे नामों वाले वेरिएबल्स केवल वर्तमान श में उपलब्ध होंगे, और लॉन्च किए गए एप्लिकेशन उन्हें नहीं देखेंगे।

सूचियों

एक और महत्वपूर्ण अंतर यह है कि सभी चर में केवल तारों की सूची होती है । आप एक चर में एक पंक्ति नहीं डाल सकते हैं - यह हमेशा एक पंक्ति की एक सूची होगी।

एक खाली सूची को एक चर (स्पष्ट रूप से a=() या a= से होकर a= ) के माध्यम से सहेजना) चर का विलोपन है।

• $var में वेरिएबल से लाइनों की एक सूची मिल रही है, और इसमें इन लाइनों में से एक या अधिक शून्य हो सकते हैं
• $#var को स्ट्रिंग लिस्ट में तत्वों की संख्या $#var मिल रही है
• $"var , स्ट्रिंग सूची के सभी तत्वों के $var से एक पंक्ति में अलग किया गया है (अंतरिक्ष अलग)

 ; var = 'first str' second ; echo $var first str second ; echo $#var 2 ; echo $"var first str second 

जैसा कि आप देख सकते हैं, $var और $"var का आउटपुट नेत्रहीन रूप से भिन्न नहीं होता है, क्योंकि echo अपने सभी मापदंडों को एक स्थान के साथ प्रदर्शित करता है, और $" एक स्थान के साथ चर के सभी तत्वों को भी जोड़ता है। लेकिन पहले echo कमांड को दो पैरामीटर मिले, और अंतिम एक।

जब भी आप किसी चीज के साथ किसी चर के मान का अनुमान लगाते हैं, तो शेल संघनन संचालक को सम्मिलित करता है ^ (जो, जैसा कि आप याद करते हैं, तार की सूचियों के साथ काम करता है, तार नहीं)। यह सुविधाजनक है, हालांकि आदत से बाहर यह अप्रत्याशित हो सकता है:

 ; flags = abc ; files = file1 file2 ; echo -$flags $files.b -a -b -c file1.b file2.b ; echo { echo -$flags $files.b } {echo -^$flags $files^.b} 

चर की सूची को असाइन करना भी काम करता है। यदि दाईं ओर की सूची में बाईं ओर चर की तुलना में अधिक तत्व हैं, तो अंतिम चर को बाकी सूची प्राप्त होगी, और पिछले चर में प्रत्येक में एक तत्व होगा।

 ; list = abcd ; (head tail) = $list ; echo $head a ; echo $tail bcd ; (xy) = (3 5) ; (xy) = ($y $x) ; echo 'x='^$x 'y='^$y x=5 y=3 

स्क्रिप्ट या कोड के किसी भी ब्लॉक के सभी मापदंडों की एक सूची चर $* , साथ ही अलग-अलग पैरामीटर $1 , $2 , .... में हैं।

स्कोप

कोड के प्रत्येक ब्लॉक का अपना दायरा होता है। आप संचालकों के साथ चर = और := मान निर्दिष्ट कर सकते हैं। पहला मौजूदा चर के मूल्य को बदल देगा या वर्तमान दायरे में एक नया चर बना देगा। दूसरा हमेशा एक नया वैरिएबल बनाता है, इस नाम के साथ वैरिएबल के पुराने मान (यदि यह मौजूद था) को चालू ब्लॉक के अंत तक बनाए रखता है।

 ; a = 1 ; { a = 2 ; echo $a } 2 ; echo $a 2 ; { a := 3; echo $a } 3 ; echo $a 2 ; { b := 4; echo $b } 4 ; echo b is $b b is 

परिवर्तनीय संदर्भ

चर नाम $ अक्षर के बाद की रेखा है। और यह किसी भी स्ट्रिंग - एकल उद्धरण या किसी अन्य चर में हो सकता है।

 ; 'var' = 10 ; echo $var 10 ; ref = 'var' ; echo $$ref 10 ; echo $'var' 10 ; echo $('va' ^ r) 10 

अवरोधन कमांड आउटपुट

दरअसल, यह विषय कमांड के लॉन्च का वर्णन करने वाले अनुभाग को अधिक संदर्भित करता है, लेकिन यह स्पष्ट करने के लिए कि हम किस बारे में बात कर रहे थे, हमें पहले वर्णन करना था कि स्ट्रिंग्स की सूचियों के साथ कैसे काम करना है, इसलिए हमें इसे अब तक स्थगित करना पड़ा।

बहुत ही अनपेक्षित उद्धरणों से मिलो जो सिंटैक्स हाइलाइटिंग को हमेशा के लिए तोड़ देते हैं।

• `{} ( `{} कार्यान्वित करता है, और जो इसे स्ट्रिंग की सूची के रूप में प्रिंट करने के लिए प्रिंट करता है, सूची आइटम को $ifs चर के मूल्य का उपयोग करके अलग किया जाता है; यदि इसे परिभाषित नहीं किया गया है, तो माना जाता है कि इसमें तीन वर्णों का एक स्ट्रिंग है: स्पेस, टैब; और लाइन फ़ीड)
• "{} ( "{} निष्पादित करता है, और जो इसे एक लाइन के रूप में प्रिंटआउट करने के लिए प्रिंट करता है - कमांड द्वारा सभी लाइनों के आउटपुट का संघटन)

एक उदाहरण के रूप में, ls कॉल के माध्यम से फ़ाइलों की सूची लोड करें। यह देखते हुए कि फ़ाइल नामों में स्थान हो सकते हैं, `{} का मानक व्यवहार हमारे लिए काम नहीं करेगा - हमें केवल लाइन ब्रेक द्वारा सूची आइटम अलग करने की आवश्यकता है।

 ; ifs := "{unicode -t 0A} ; files := `{ ls / } ; echo $#files 82 ; ls / | wc -l 82 

लेकिन वास्तव में इसे फ़ाइल नाम टेम्प्लेट के माध्यम से आसान और अधिक विश्वसनीय बनाया जाता है, जो शेल द्वारा फ़ाइल नामों की सूची में विस्तारित किया जाता है:

 ; files2 := /* ; echo $#files2 82 

बिल्ट-इन कमांड

दो प्रकार के अंतर्निहित कमांड हैं: स्ट्रिंग्स के साथ काम करने के लिए नियमित और।

नियमित आदेश उसी तरह लागू किए जाते हैं जिस तरह से एप्लिकेशन / स्क्रिप्ट लॉन्च किए जाते हैं:

 ; run /lib/sh/profile ; load std ; unload std ; exit 

स्ट्रिंग्स के साथ काम करने की आज्ञाओं को ${ } माध्यम से बुलाया जाता है और वे (स्टैडआउट में आउटपुट नहीं करते हैं, अर्थात्, वे वापस लौटते हैं - उदाहरण के लिए, एक चर के मूल्य के लिए एक अपील) एक नियमित स्ट्रिंग - यानी उन्हें नियमित कमांड के मापदंडों में या चर को मान प्रदान करने के दाईं ओर उपयोग किया जाना चाहिए। उदाहरण के लिए, कमांड ${quote} एक पंक्ति में उसके पास गए तार की सूची से बच जाता है, और ${unquote} विपरीत ऑपरेशन करता है, एक लाइन को तार की सूची में बदल देता है।

 ; list = 'ab' cd ; echo $list abcd ; echo ${quote $list} 'ab' cd ; echo ${unquote ${quote $list}} abcd 

यदि, कार्यों के लिए जोड़ें

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

सब कुछ विशेष रूप से उपयोग किया जाता है:

• चर
• लाइन और लाइन सूची
• कोड ब्लॉक और उनके पैरामीटर

हम अपने "कार्य" करते हैं

जैसा कि मैंने उल्लेख किया है, कोई भी शेल कमांड केवल लाइनों की एक सूची है, जहां पहली पंक्ति कमांड है, और बाकी लाइनें इसके पैरामीटर हैं। और शेल कमांड ब्लॉक सिर्फ एक स्ट्रिंग है, और इसे एक चर में बचाया जा सकता है। और कोई भी कमांड ब्लॉक $* , $1 आदि में पैरामीटर प्राप्त करता है।

 ; hello = { echo Hello, $1! } ; $hello World Hello, World! 

इसके अलावा, हम कार्यात्मक प्रोग्रामिंग की सर्वश्रेष्ठ भावना में फ़ंक्शन करी भी कर सकते हैं। :)

 ; greet = {echo $1, $2!} ; hi = $greet Hi ; hello = $greet Hello ; $hi World Hi, World! ; $hello World Hello, World! 

एक अन्य उदाहरण - आप वांछित सूची आइटम को संख्या द्वारा प्राप्त करने के लिए ब्लॉक मापदंडों का उपयोग कर सकते हैं:

 ; list = abcdef ; { echo $3 } $list c 

आपके लिए बनाना

अगर मुझे इसके लिए लागू करने में दिलचस्पी थी, और अगर मैंने एक न्यूनतम कार्यात्मक बनाया है, तो मुझे पूर्ण-सुविधाजनक बनाने की कोशिश नहीं की गई थी, क्योंकि इसके लिए यह आवश्यक था (लूप को एक बार बंद किया जाना चाहिए, और यदि ऐसा करने के लिए समस्याग्रस्त है तो)।

 ; do = { $* } ; dont = { } ; if = { (cmd cond) := $* { $2 $cmd } $cond $do $dont } ; for = { (var in list) := $* code := $$#* $iter $var $code $list } ; iter = { (var code list) := $* (cur list) := $list (next unused) := $list $if {$var=$cur; $code; $iter $var $code $list} $next } ; $for i in 10 20 30 { echo i is $i } i is 10 i is 20 i is 30 ; 

दिलचस्प छोटी बातें

डिफ़ॉल्ट रूप से, शेल स्क्रिप्ट शुरू होने पर नाम स्थान की तलाश करता है, इसलिए स्क्रिप्ट उस प्रक्रिया के नाम स्थान को बदल नहीं सकती है जिसने इसे लॉन्च किया है। यह उन लिपियों के लिए उपयुक्त नहीं है जिनका कार्य सिर्फ अपने माता-पिता के नाम स्थान को कॉन्फ़िगर करना है। ऐसी स्क्रिप्ट्स की शुरुआत #!/dis/sh -n से होनी चाहिए।

loaded इन-कमांड सभी लोड किए गए मॉड्यूल से सभी अंतर्निहित कमांड को सूचीबद्ध करता है। और whatis बिल्ट-इन कमांड वेरिएबल्स, फंक्शन्स, कमांड्स आदि की जानकारी प्रदर्शित करता है।

यदि आप शेल मॉड्यूल की सूची के साथ एक चर $autoload बनाते हैं, तो ये मॉड्यूल लॉन्च किए गए प्रत्येक शेल में स्वचालित रूप से लोड हो जाएंगे।

शेल में सिंथैटिक शुगर सपोर्ट है: && और || । ये ऑपरेटर नंगे श में उपलब्ध हैं, लेकिन बिल्ट-इन and or कमांड्स को कॉल करने में परिवर्तित होते हैं, जो नंगे श में नहीं हैं, वे एसटीडी मॉड्यूल से हैं (इसलिए आप load std बाद && उपयोग कर सकते हैं)।

 ; echo { cmd && cmd } {and {cmd} {cmd}} ; echo { cmd || cmd } {or {cmd} {cmd}} 

उदाहरण के लिए, लिम्बो में लिखे गए एप्लिकेशन, जब कमांड लाइन पैरामीटर के साथ शुरू होते हैं, तो sh कमांड के ब्लॉक के साथ एक लाइन बहुत आसानी से sh (2) मॉड्यूल का उपयोग करके इसे निष्पादित कर सकती है।

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

सारांश

यह लघु लेख इन्फर्नियन शेल के लिए लगभग पूर्ण संदर्भ गाइड है। इस अर्थ में, मूल शेल की सभी कार्यक्षमता का वर्णन किया गया है, और काफी कुछ विस्तार में - सभी बारीकियों और उदाहरणों के साथ। sh(1) , , $apid , $prompt , - , sh ., .

/, :

• ( )
• ^
• =
• $var , $#var $"var

! «» , , if for ( , raise std — .. /bin/false :) run ).

, . , sh-std(1) :

• ( and , or , if )
• ( ! , ~ , no )
• ( apply , for , while , getlines )
• दोनों समारोह के प्रकार ( fn, subfn)
• अपवाद और स्थिति के साथ काम ( raise, rescue, status)
• काम तार, और सूचियों ( ${hd}, ${tl}, ${index}, ${split}, ${join})
• आदि

लेकिन ये सभी अतिरिक्त कमांड स्वयं शेल के सिंटैक्स को जटिल नहीं करते हैं, यह एक ही तुच्छ और सुरुचिपूर्ण रहता है!