बैश रीड कमांड

Bash Read Command

पढ़ो या मरो दोस्तों। रीड कमांड पोजिशनल पैरामीटर और इको कमांड जितना ही महत्वपूर्ण है। आप उपयोगकर्ता इनपुट को कैसे पकड़ेंगे, पासवर्ड स्वीकार करेंगे, फ़ंक्शन लिखेंगे, लूप करेंगे, और फ़ाइल डिस्क्रिप्टर में झांकेंगे? पढ़ते रहिये।

क्या पढ़ा है?

पढ़ें एक बैश बिल्टिन कमांड है जो एक लाइन की सामग्री को एक चर में पढ़ता है। यह शब्द विभाजन की अनुमति देता है जो विशेष शेल चर IFS से जुड़ा होता है। यह मुख्य रूप से उपयोगकर्ता इनपुट को पकड़ने के लिए उपयोग किया जाता है लेकिन मानक इनपुट से इनपुट लेने वाले कार्यों को लागू करने के लिए इसका उपयोग किया जा सकता है।







बैश रीड बिल्टिन कमांड हेल्प

इससे पहले कि हम बैश स्क्रिप्ट में रीड कमांड का उपयोग कैसे करें, यहां बताया गया है कि हमें कैसे मदद मिलती है। वहां आपको रीड कमांड के लिए उपलब्ध सभी विकल्पों को विवरण के साथ देखना चाहिए जिन्हें हम उदाहरणों में शामिल करने का प्रयास करेंगे।



कमांड लाइन



मदद पढ़ना

उत्पादन





पढ़ना:पढ़ना [-ers] [-एक सरणी] [-डी शेयर] [-मैं संदेश भेजता हूं] [-एन नचार्स] [-एन नचार्स]
[-पी प्रॉम्प्ट] [-टी टाइमआउट] [-यू एफडी] [नाम ...]

मानक इनपुट से एक पंक्ति पढ़ें औरविभाजित करनाइसे खेतों में।

मानक इनपुट से एक पंक्ति पढ़ता है, या सेफ़ाइलविवरणक एफडी
अगरNSयूविकल्प प्रदान किया जाता है। लाइन हैविभाजित करनाखेतों मेंजैसाशब्द के साथ
विभाजन, और पहला शब्द पहले NAME को सौंपा गया है, दूसरा
दूसरे NAME को शब्द, और इसी तरह, किसी भी बचे हुए शब्दों के साथ असाइन किया गया
NSअंतिमनाम। केवल पात्र मिलेमें $IFSपहचाने जाते हैंजैसाशब्द
सीमांकक

यदि कोई NAME आपूर्ति नहीं की जाती है, तो लाइनपढ़नारखा हैमेंउत्तर चर।

विकल्प:
-प्रतिसरणी शब्दों को असाइन करेंपढ़नासरणी के अनुक्रमिक सूचकांकों के लिए
चर ARRAY, शून्य से शुरू
-डीपरिसीमकजारी रखें जब तकDELIM का पहला अक्षर हैपढ़ना, बल्कि
न्यूलाइन की तुलना में
-ई लाइन प्राप्त करने के लिए रीडलाइन का उपयोग करेंमेंएक इंटरैक्टिव खोल
-मैंटेक्स्ट टेक्स्ट का उपयोग करेंजैसाप्रारंभिक पाठके लियेपढ़ने के लिए लाइन
-एननचार्सवापसीप्रतीक्षा करने के बजाय NCHARS वर्ण पढ़ने के बाद
के लियेएक नई पंक्ति, लेकिन एक सीमांकक का सम्मान करेंअगरसे कम

NCHARS वर्ण हैंपढ़नासीमांकक से पहले
-एननचार्सवापसीकेवल NCHARS वर्ण पढ़ने के बाद ही, जब तक कि
ईओएफ का सामना करना पड़ा है यापढ़ना बारबाहर, किसी को अनदेखा करना
सीमांकक
-पीपहले बिना किसी नई लाइन के स्ट्रिंग PROMPT को शीघ्र आउटपुट दें
करने का प्रयासपढ़ना
-आरकरनाबैकस्लैश को किसी भी वर्ण से बचने की अनुमति न दें
-एसकरनानहींफेंक दियाटर्मिनल से आने वाला इनपुट
-टीसमय समाप्तसमयबाहर औरवापसीअसफलताअगरप्रतिपूर्णकी लाइन
इनपुट नहीं हैपढ़नाTIMEOUT सेकंड के भीतर। का मूल्य
TMOUT वैरिएबल डिफ़ॉल्ट टाइमआउट है। TIMEOUT एक हो सकता है
भिन्नात्मक संख्या। यदि TIMEOUT है0,पढ़नारिटर्न
तुरंत, बिना कोशिश किएपढ़नाकोई डेटा, लौट रहा है
केवल सफलताअगरइनपुट निर्दिष्ट पर उपलब्ध है
फ़ाइलवर्णनकर्ता NSबाहर जाएंस्थिति से बड़ी है128
अगरसमय समाप्त हो गया है
यूएफडीपढ़नासेफ़ाइलमानक इनपुट के बजाय डिस्क्रिप्टर FD

बाहर निकलें स्थिति:
NSवापसीकोड शून्य है, जब तक कि एंड-ऑफ-फाइल का सामना नहीं किया जाता है,पढ़ना बारबाहर
(में कौन मामलायह128 से अधिक है), एक चर असाइनमेंट त्रुटि

उपयोगकर्ता इनपुट को पकड़ना

उपयोगकर्ता इनपुट को पकड़े बिना इंटरएक्टिव बैश स्क्रिप्ट कुछ भी नहीं हैं। रीड बिल्टिन ऐसे तरीके प्रदान करता है जो उपयोगकर्ता इनपुट को बैश स्क्रिप्ट के भीतर पकड़ा जा सकता है।

इनपुट की एक पंक्ति पकड़ना

इनपुट की एक पंक्ति को पकड़ने के लिए NAMEs और विकल्पों को पढ़ने की आवश्यकता नहीं होती है। जब NAME निर्दिष्ट नहीं होता है, तो उपयोगकर्ता इनपुट को संग्रहीत करने के लिए REPLY नामक एक चर का उपयोग किया जाता है।



आदेश

{
फेंक दिया -एन 'कुछ टाइप करें और एंटर दबाएं:';
पढ़ना;
फेंक दियाआपने टाइप किया${जवाब दें}
}

उत्पादन

कुछ टाइप करें और एंटर दबाएं: कुछ(नई पंक्ति)
आपने कुछ टाइप किया

इनपुट के एक शब्द को पकड़ना

इनपुट के एक शब्द को पकड़ने के लिए, -d विकल्प की आवश्यकता होती है। एक शब्द के मामले में हम -d को एक स्थान पर सेट करेंगे, '-d' पढ़ें। वह तब होता है जब उपयोगकर्ता स्पेस बार को पढ़ता है, शब्द के साथ उत्तर लोड करेगा।

ध्यान दें कि जब -d विकल्प सेट किया जाता है, तो बैकस्पेस अपेक्षा के अनुरूप काम नहीं करता है। बैकस्पेस के लिए, इनपुट के एक शब्द को पकड़ने की कोशिश करते समय, -e विकल्प का उपयोग किया जा सकता है, पढ़ें -e '-d'।

आदेश

{
फेंक दिया -एन 'कुछ टाइप करें और स्पेस हिट करें:';
पढ़ना '-डी ';
फेंक दिया '';
फेंक दिया 'आपने टाइप किया'${जवाब दें}'
}

उत्पादन

कुछ टाइप करें और स्पेस हिट करें: कुछ(स्थान)
आपने कुछ टाइप किया

शीघ्र उपयोगकर्ता

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

एक शब्द के लिए शीघ्र उपयोगकर्ता

इनपुट के एक शब्द को पकड़ने में, हमने '-d' पढ़ने से पहले टाइप कुछ और हिट स्पेस: मानक आउटपुट के लिए इको का उपयोग किया। -पी विकल्प मानक इनपुट से पढ़ने से पहले एक संदेश प्रदर्शित करने की अनुमति देता है।

आदेश

{
पढ़ना -पी 'कुछ टाइप करें और स्पेस हिट करें:' '-डी ';
फेंक दिया '';
फेंक दिया 'आपने टाइप किया'${जवाब दें}'
}

उत्पादन

कुछ टाइप करें और स्पेस हिट करें: कुछ(स्थान)
आपने कुछ टाइप किया

एक रहस्य के लिए संकेत उपयोगकर्ता

टर्मिनल में दिखाए बिना उपयोगकर्ता इनपुट को पकड़ते समय, -s विकल्प काम में आता है। read -s -p आपको उपयोगकर्ता इनपुट को निम्नानुसार पकड़ने और छिपाने की अनुमति देता है।

आदेश

{
पढ़ना -एस -पी 'कुछ ऐसा टाइप करें जिसे मैं गुप्त रखने का वादा करता हूं:'
फेंक दिया '';
फेंक दिया 'आपका राज मेरे पास सुरक्षित है';सेट नहींजवाब दे दो ;
फेंक दिया '${जवाब दें}'
}

उत्पादन

कुछ ऐसा टाइप करें जिसे मैं गुप्त रखने का वादा करता हूं:
आपका राज मेरे पास सुरक्षित है

पढ़ने का उपयोग कर कार्य

यहाँ बैश में फ़ंक्शंस के उदाहरण दिए गए हैं जो रीड और स्टैंडर्ड इनपुट का उपयोग करते हैं

मूल अवधारणा

रीड का उपयोग करने वाले कार्य पाइप्ड मानक इनपुट और मापदंडों का उपयोग करते हैं। प्रक्रिया के लिए मुख्य इनपुट जैसे फ़ाइल में लाइनें एक पाइप के माध्यम से मानक इनपुट के माध्यम से पारित की जाती हैं। अन्य इनपुट यदि-कोई हो और विकल्प को पैरामीटर के रूप में पास किया जाता है।

पढ़ना -टी 1NAME1 NAME2 ...

पढ़नाएक हैअंतर्निहित आदेश

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

NAME1 NAME2 चर नाम हैं

... कई चर नाम सूचीबद्ध किए जा सकते हैं

अब जब आधारभूत कार्य सेट हो गए हैं, तो आइए देखें कि रीड का उपयोग करके लागू किए गए परिचित कार्य क्या दिखते हैं।

रीड . का उपयोग करके फ़ंक्शन में शामिल हों

मान लीजिए कि हम एक जॉइन फंक्शन चाहते हैं जो शब्दों की एक सूची लेता है और एक सीमांकक से जुड़े शब्दों की एक और सूची देता है। यहां बताया गया है कि हम रीड का उपयोग करके जॉइन फंक्शन को कैसे लागू कर सकते हैं।

लिपि

#!/बिन/बैश
## शामिल हों
## संस्करण 0.0.2 - रिकर्सन पैरामीटर ठीक करें
#############################################
में शामिल होने के() { { स्थानीयसीमक;सीमक='$ {1-}';स्थानीयबाहरी सीमांकक;
बाहरी सीमांकक='$ {2-.}';}
स्थानीयकार
स्थानीयकमांडर
स्थानीयभारतीय विदेश सेवा
भारतीय विदेश सेवा='${indelimiter}'
पढ़ना -टी 1कार सीडीआरओ|| वापसी
परीक्षण '${सीडीआर}' || { फेंक दिया '${कार}';वापसी;}
फेंक दिया '${कार}${आउटडिलीमीटर}${सीडीआर}' | ${FUNCNAME} '${indelimiter}'
'${आउटडिलीमीटर}'
}
#############################################
## create-stub2.sh v0.1.2 . द्वारा उत्पन्न
## सोमवार को, 17 जून 2019 12:24:59 +0900
## देख
#############################################

स्रोत: join.sh
कमांड लाइन

फेंक दियाएक बी| में शामिल होने के

उत्पादन

ए.बी

कमांड लाइन

फेंक दियाएक बी| में शामिल होने के | में शामिल होने के. |

उत्पादन

प्रति|बी

रीड . का उपयोग करके मानचित्र कार्य करता है

मान लीजिए कि हम एक नक्शा फ़ंक्शन चाहते हैं जो एक सूची लेता है और एक अन्य सूची देता है जिसमें समान संख्या में तत्व होते हैं जो किसी अन्य फ़ंक्शन द्वारा संशोधित किए जाते हैं। यहां बताया गया है कि हम रीड का उपयोग करके मैप फ़ंक्शन को कैसे लागू कर सकते हैं।

लिपि

#!/बिन/बैश
## नक्शा
## संस्करण 0.0.1 - प्रारंभिक
#############################################
नक्शा() { { स्थानीयफंक्शन_नाम;function_name='$ {1}';}
स्थानीयकार
स्थानीयकमांडर
स्थानीयभारतीय विदेश सेवा
भारतीय विदेश सेवा='${indelimiter-}'
पढ़ना -टी 1कार सीडीआरओ|| वापसी
परीक्षण '$ (घोषणा -f $ {function_name})' || वापसी
परीक्षण '${कार}' || { सच;वापसी;}
${function_name} ${कार}
फेंक दिया '${सीडीआर}' | ${FUNCNAME} '${function_name}'
}
#############################################
## create-stub2.sh v0.1.2 . द्वारा उत्पन्न
## मंगलवार को, 18 जून 2019 08:33:49 +0900
## देख
#############################################

स्रोत: map.sh
आदेश

एन एस() { स्थानीय -मैं मैं=$ {1};फेंक दिया$((मैं** 2 ));}
फेंक दिया {1..10} |नक्शा पाउ

उत्पादन

1
4
9
16
25
36
49
64
81
100

रीड . का उपयोग करके फ़िल्टर फ़ंक्शन

मान लीजिए कि हम एक फ़िल्टर फ़ंक्शन चाहते हैं जो एक सूची लेता है और किसी अन्य फ़ंक्शन द्वारा निर्धारित शर्तों को पूरा करने वाले तत्वों की एक सबलिस्ट देता है। यहां बताया गया है कि हम रीड का उपयोग करके फ़िल्टर फ़ंक्शन को कैसे कार्यान्वित कर सकते हैं।

लिपि

#!/बिन/बैश
## फ़िल्टर
## संस्करण 0.0.1 - प्रारंभिक
#############################################
फिल्टर() { { स्थानीयफंक्शन_नाम;function_name='$ {1}';}
स्थानीयकार
स्थानीयकमांडर
स्थानीयभारतीय विदेश सेवा
भारतीय विदेश सेवा='${indelimiter-}'
पढ़ना -टी 1कार सीडीआरओ|| वापसी
परीक्षण '$ (घोषणा -f $ {function_name})' || वापसी
परीक्षण '${कार}' || { सच;वापसी;}
${function_name} '${कार}' || फेंक दिया -एन '${कार}'
फेंक दिया '${सीडीआर}' | ${FUNCNAME} '${function_name}'
}
#############################################
## create-stub2.sh v0.1.2 . द्वारा उत्पन्न
## मंगलवार को, 18 जून 2019 13:19:54 +0900
## देख
#############################################

स्रोत: फिल्टर.शो

आदेश

अजीब() { स्थानीय -मैं मैं=$ {1};परीक्षण !$((मैं% 2 )) -ईक्यू 1;}
फेंक दिया {1..10} |फ़िल्टर विषम

उत्पादन

1 3 5 7 9

रीड . का उपयोग करते हुए लूप्स

रीड का उपयोग करने वाले लूप आपको उस फ़ाइल की पंक्तियों के माध्यम से पुनरावृति करने की अनुमति देते हैं जो उत्पन्न की जानी है या पहले से मौजूद है।

लेफ्टहैंड साइड के लिए बेसिक जबकि रीड लूप (lhs)

हमारे पास एक कमांड या फ़ंक्शन (एलएचएस) है जो एक फ़ाइल में लाइनें उत्पन्न कर सकता है जिसे रीड और थोड़ी देर के लूप का उपयोग करके लूप किया जा सकता है।

निर्माण

एलएचएस| जबकि पढ़ना
करना
सच
किया हुआ
एलएचएस एक हैआदेशजो लाइनों की एक सूची देता है

आदेश

स्व-परीक्षा प्रश्न 5 | जबकि पढ़नामैं
करना
फेंक दिया ${i}
किया हुआ

उत्पादन

1
2
3
4
5

राइटहैंड साइड के लिए बेसिक जबकि रीड लूप (rhs)

हमारे पास लाइनों के साथ एक फ़ाइल (rhs) है जिसे रीड और थोड़ी देर के लूप का उपयोग करके लूप किया जा सकता है।

निर्माण

जबकि पढ़ना
करना
सच
किया हुआ <आरएचएस

आरएचएस एक हैफ़ाइललाइनों युक्त

आदेश

स्व-परीक्षा प्रश्न 5 >आरएचएस
जबकि पढ़नामैं
करना
फेंक दिया ${i}
किया हुआ <आरएचएस

उत्पादन

1
2
3
4
5

कस्टम lhs जबकि लूप रीड का उपयोग कर रहा है

हमारे पास शब्दों की एक धारा है जिसे हम पढ़ने के माध्यम से लूप करना चाहते हैं।

निर्माण

(
भारतीय विदेश सेवा=''
एलएचएस| जबकि पढ़ना
करना
सच
किया हुआ
)

lhs शब्दों की एक सूची है

आदेश

(
भारतीय विदेश सेवा=''
फेंक दिया {1..5} | जबकि पढ़नामैं
करना
फेंक दिया '${i}
किया हुआ
)

उत्पादन

1 2 3 4 5

मानक इनपुट के बजाय किसी भी एफडी से पढ़ना

रीड बिल्टिन विकल्प अक्सर अछूता छोड़ दिया जाता है, जो आपको यह निर्दिष्ट करने की अनुमति देता है कि किस फाइल डिस्क्रिप्टर को पढ़ना है, -यू एफडी पढ़ें। डिफ़ॉल्ट रूप से FD को मानक इनपुट के रूप में लिया जाता है।

मूल अवधारणा

जब कोई फ़ाइल खोली जाती है तो फ़ाइल डिस्क्रिप्टर असाइन किए जाते हैं। बैश में IO पुनर्निर्देशन एक फ़ाइल को एक विशिष्ट फ़ाइल डिस्क्रिप्टर के साथ खुला छोड़ने की अनुमति देता है। हमें फ़ाइल को लिखने, उससे पढ़ने और काम पूरा होने पर उसे बंद करने की अनुमति है।

_()
{
बिल्ली /देव/शून्य>मायफीफो;#खाली मायफीफो
कार्यकारी 3<मायफीफो;# फ़ाइल myfifo को fd 3 के रूप में खोलें
फेंक दिया 'नमस्ते दुनिया! - एफडी 3' से >मायफीफो;# myfifo . को लिखें
पढ़ना यू 3;# एफडी 3 से लाइन पढ़ें
कार्यकारी 3> और-;# बंद एफडी 3
फेंक दिया ${जवाब दें} # आउटपुट लाइन बंद होने से पहले एफडी 3 से पढ़ी जाती है
}
_# नमस्ते दुनिया! एफडी 3 . से

फाइल डिस्क्रिप्टर के साथ एक ट्रेन का निर्माण और -यू एफडी पढ़ें

सिर्फ मनोरंजन के लिए मैंने फाइल डिस्क्रिप्टर के साथ एक ट्रेन बनाने और -यू एफडी पढ़ने का फैसला किया। प्रत्येक फाइल डिस्क्रिप्टर को एक नंबर लिखा जाता है। प्रत्येक फ़ाइल डिस्क्रिप्टर नीचे फ़ाइल डिस्क्रिप्टर 1 से पढ़ता है और स्वयं को जोड़ता है।

कमांड लाइन

दे घुमा केlinuxhint.com/निर्माण/टेस्ट-रीड-fd.sh ट्रेन10

उत्पादन

एफडी शुरू कर रहा है ...
एफडी शुरू करना3...
एफडी3initialized
एफडी शुरू करना4...
एफडी4initialized
एफडी आरंभिक
fd . से पढ़ना3तथा4...
4 3
सफाई से पहले एफ.डी
0 1 2 3 4 5
सफाई करना ...
एफडी की सफाई...
किया हुआएफडी की सफाई
सफाई के बाद एफ.डी
0 1 2 3

रीड-यू एफडी का उपयोग करके फ़ंक्शन छोड़ें

यदि आप दौड़ रहे हैं

आपका नाम -प्रति
MINGW64_NT-10.0डेस्कटॉप-XVVVVVV 2.7.0(0.307/5/3)
2017।-02-17 14:बीसx86_64 एमएसआईएस
दे घुमा के --संस्करण
जीएनयूदे घुमा के, संस्करण 4.4.12(1)-रिहाई(x86_64-पीसी-एमएसआईएस)

यह एक बग के कारण एक स्किप फ़ंक्शन को लागू करने के लिए संभव हो सकता है जो स्क्रिप्ट स्रोत को पढ़ने से पहले फ़ंक्शन के बाहर बैश स्क्रिप्ट में निम्न पंक्ति को छोड़ देता है। ध्यान दें कि यह अधिकांश प्रणालियों पर काम नहीं करता है। उदाहरण के लिए,

आपका नाम -प्रति
लिनक्स 4.9.0-8-amd64#1 डेबियन एसएमपी 4.9.144-3.1 (2019-02-19) x86_64 जीएनयू/लिनक्स
दे घुमा के --संस्करण
जीएनयूदे घुमा के, संस्करण 4.4.12(1)-रिहाई(x86_64-पीसी-लिनक्स-ग्नू)

स्किप नहीं उड़ता।

समारोह

छोड़ें() { पढ़ना यू 31;}

आदेश

छोड़ें
फेंक दियालाइन स्किप हो गई
सच

उत्पादन

(खाली)

जमीनी स्तर

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