लिनक्स शेल के साथ डोजेन ट्रिक जो आपका समय बचा सकता है

• सबसे पहले, आप इस लेख को रूसी में यहां पढ़ सकते हैं।

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

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

कट के तहत - लिनक्स शेल में एक दर्जन चालें मेरे व्यक्तिगत अनुभव से।

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

1. चर विस्तार के साथ विभाजित स्ट्रिंग

लोग अक्सर पैटर्न द्वारा या विभाजक के साथ स्ट्रिंग के एक हिस्से को बदलने के लिए कट या यहां तक ​​कि जाग का उपयोग करते हैं।
इसके अलावा, बहुत से लोग $ {VARIABLE: start_position: length} का उपयोग करके बैश ऑपरेशन का उपयोग करते हैं, जो बहुत तेज़ी से काम करता है।

लेकिन बैश #, ##,% और %% का उपयोग करके टेक्स्ट स्ट्रिंग्स के साथ हेरफेर करने का एक शक्तिशाली तरीका प्रदान करता है - इसे बैश वैरिएबल एक्सपैशन कहा जाता है।
इस सिंटैक्स का उपयोग करके, आप बाहरी आदेशों को निष्पादित किए बिना पैटर्न द्वारा जरूरतमंदों को काट सकते हैं, इसलिए यह वास्तव में तेजी से काम करेगा।

नीचे दिए गए उदाहरण से पता चलता है कि स्ट्रिंग से तीसरा कॉलम (शेल) कैसे प्राप्त किया जाए, जहां बृहदान्त्र द्वारा अलग किए गए मान "उपयोगकर्ता नाम: homedir: शेल" कट या चर विस्तार का उपयोग करके (हम *: मास्क और ## कमांड का उपयोग करते हैं, जिसका अर्थ है: कट अंतिम बृहदान्त्र पाए जाने तक सभी वर्ण बाईं ओर:

$ STRING="username:homedir:shell" $ echo "$STRING"|cut -d ":" -f 3 shell $ echo "${STRING##*:}" shell 

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

आइए उबंटू पर एक उदाहरण देखें - 1000 बार के लिए लूप में हमारी कमांड निष्पादित करें

 $ cat test.sh #!/usr/bin/env bash STRING="Name:Date:Shell" echo "using cut" time for A in {1..1000} do cut -d ":" -f 3 > /dev/null <<<"$STRING" done echo "using ##" time for A in {1..1000} do echo "${STRING##*:}" > /dev/null done 

अंतर कई दर्जन बार है!

बेशक, ऊपर का उदाहरण बहुत कृत्रिम है। वास्तविक उदाहरण में हम एक स्थिर स्ट्रिंग के साथ काम नहीं करेंगे, हम एक वास्तविक फ़ाइल पढ़ना चाहते हैं। और ' कट ' कमांड के लिए, हम इसे रीडायरेक्ट / आदि / पास करते हैं। ## के मामले में, हमें आंतरिक ' रीड ' कमांड का उपयोग करके एक लूप और रीड फाइल बनाना होगा। तो इस केस को कौन जीतेगा?

 $ cat test.sh #!/usr/bin/env bash echo "using cut" time for count in {1..1000} do cut -d ":" -f 7 </etc/passwd > /dev/null done echo "using ##" time for count in {1..1000} do while read do echo "${REPLY##*:}" > /dev/null done </etc/passwd done 

कुछ और उदाहरण:

समान वर्ण के बाद मान निकालें:

 $ VAR="myClassName = helloClass" $ echo ${VAR##*= } helloClass 

राउंड ब्रैकेट में टेक्स्ट निकालें:

 $ VAR="Hello my friend (enemy)" $ TEMP="${VAR##*\(}" $ echo "${TEMP%\)}" enemy 

टैब के साथ 2. बैश स्वतः पूर्णता

बैश-समापन पैकेज लगभग हर लिनक्स वितरण का एक हिस्सा है। आप इसे /etc/bash.bashrc या /etc/profile.d/bash_completion.sh में सक्षम कर सकते हैं, लेकिन आमतौर पर यह पहले से ही डिफ़ॉल्ट रूप से सक्षम हो जाता है। सामान्य तौर पर, स्वत: पूर्णता लिनक्स शेल पर पहले सुविधाजनक क्षणों में से एक है जो सबसे पहले एक नवागंतुक से मिलता है।

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

आपको उपनाम को चलाने के लिए PATH चर को संपादित करने या निर्दिष्ट निर्देशिका में फ़ाइलें बनाने की आवश्यकता नहीं है। आपको केवल उन्हें प्रोफ़ाइल या स्टार्टअप स्क्रिप्ट में जोड़ने और उन्हें किसी भी स्थान से निष्पादित करने की आवश्यकता है।

आमतौर पर हम फ़ाइलों और निर्देशिकाओं के लिए लोअरकेस अक्षरों का उपयोग * निक्स में कर रहे हैं, इसलिए यह अपरकेस अलायसेस बनाने के लिए बहुत आरामदायक हो सकता है - उस स्थिति में बैश-पूरा होने से आपकी आज्ञा का लगभग एक ही अक्षर से अनुमान लगाया जाएगा:

 $ alias TAsteriskLog="tail -f /var/log/asteriks.log" $ alias TMailLog="tail -f /var/log/mail.log" $ TA[tab]steriksLog $ TM[tab]ailLog 

3. टैब के साथ बैश आटोक्लेम्पशन - भाग 2

अधिक जटिल मामलों के लिए, शायद आप अपनी निजी स्क्रिप्ट को $ HOME / bin में डालना चाहेंगे।
लेकिन हमारे पास काम है।

फ़ंक्शंस को पथ या अलग फ़ाइलों की आवश्यकता नहीं होती है। और (ध्यान) बाश पूरा होने वाले कार्यों के साथ भी काम करता है।

चलो। में अंतिम Lastogogin फ़ंक्शन बनाते हैं। (पुनः लोड करना न भूलें।)

 function LastLogin { STRING=$(last | head -n 1 | tr -s " " " ") USER=$(echo "$STRING"|cut -d " " -f 1) IP=$(echo "$STRING"|cut -d " " -f 3) SHELL=$( grep "$USER" /etc/passwd | cut -d ":" -f 7) echo "User: $USER, IP: $IP, SHELL=$SHELL" } 

(वास्तव में कोई महत्वपूर्ण नहीं है कि यह फ़ंक्शन क्या कर रहा है, यह सिर्फ एक उदाहरण स्क्रिप्ट है जिसे हम अलग स्क्रिप्ट या यहां तक ​​कि उपनाम के लिए रख सकते हैं, लेकिन फ़ंक्शन बेहतर हो सकता है) ।

कंसोल में (कृपया ध्यान दें कि फ़ंक्शन नाम में बैश-पूरा करने के लिए पहला अक्षर है):

 $ L[tab]astLogin User: saboteur, IP: 10.0.2.2, SHELL=/bin/bash 

4.1। संवेदनशील डेटा

यदि आप कंसोल में किसी भी कमांड से पहले स्पेस देते हैं, तो यह कमांड हिस्ट्री में दिखाई नहीं देगा, इसलिए यदि आपको कमांड में प्लेन टेक्स्ट पासवर्ड डालने की आवश्यकता है, तो यह इस फीचर का उपयोग करने का एक अच्छा तरीका है - नीचे उदाहरण में देखें, इको "हैलो" 2 " इतिहास में दिखाई नहीं देगा:

 $ echo "hello" hello $ history 2 2011 echo "hello" 2012 history 2 $ echo "my password secretmegakey" # there are two spaces before 'echo' my password secretmegakey $ history 2 2011 echo "hello" 2012 history 2 

4.2। कमांड लाइन तर्कों में संवेदनशील डेटा

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

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

आमतौर पर आप चर का उपयोग कर सकते हैं, जो पहले से ही लक्षित वातावरण पर परिभाषित किया गया था, और आपकी स्क्रिप्ट में पासवर्ड ही नहीं होंगे।

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

 secret.sh PASSWORD=LOVESEXGOD 

 myapp.sh source ~/secret.sh sqlplus -l user/"$PASSWORD"@database:port/sid @mysqfile.sql 

लेकिन यह सुरक्षित नहीं है।

यदि कोई अन्य व्यक्ति आपके होस्ट में प्रवेश कर सकता है, तो वह पीएस कमांड को निष्पादित कर सकता है और पासवर्ड सहित पूरी कमांड लाइन तर्कों के साथ आपकी sqlplus प्रक्रिया देख सकता है। इसलिए, सुरक्षित टूल आमतौर पर फाइलों से सीधे पासवर्ड / कुंजी / संवेदनशील डेटा को पढ़ने में सक्षम होना चाहिए।

उदाहरण के लिए - सुरक्षित ssh के पास कमांड लाइन में पासवर्ड प्रदान करने के लिए भी कोई विकल्प नहीं है। लेकिन वह फ़ाइल से ssh कुंजी पढ़ सकता है (और आप ssh कुंजी फ़ाइल पर सुरक्षित अनुमतियाँ सेट कर सकते हैं)।

और गैर-सुरक्षित wget में एक विकल्प "--password" है जो आपको कमांड लाइन में पासवर्ड प्रदान करने की अनुमति देता है। और हर समय wget चल रहा होगा, हर कोई ps कमांड निष्पादित कर सकता है और आपके द्वारा प्रदान किया गया पासवर्ड देख सकता है।

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

फ़ाइल secret.key में मास्टर कुंजी है - एक एकल पंक्ति:

 $ echo "secretpassword" > secret.key; chmod 600 secret.key 

स्ट्रिंग को एन्क्रिप्ट करने के लिए एईएस-256-सीबीसी का उपयोग करने देता है:

 $ echo "string_to_encrypt" | openssl enc -pass file:secret.key -e -aes-256-cbc -a U2FsdGVkX194R0GmFKCL/krYCugS655yLhf8aQyKNcUnBs30AE5lHN5MXPjjSFML 

आप इस एन्क्रिप्टेड स्ट्रिंग को git या किसी अन्य स्थान पर संग्रहीत किसी भी कॉन्फ़िगरेशन फ़ाइल में रख सकते हैं - secret.key के बिना इसे डिक्रिप्ट करना लगभग असंभव है।
डिक्रिप्ट को उसी आदेश को निष्पादित करने के लिए -d के साथ बदलें -d:

 $ echo 'U2FsdGVkX194R0GmFKCL/krYCugS655yLhf8aQyKNcUnBs30AE5lHN5MXPjjSFML' | openssl enc -pass file:secret.key -d -aes-256-cbc -a string_to_encrypt 

5. grep कमांड

सभी को grep कमांड पता होना चाहिए। और नियमित भावों के अनुकूल हो। और अक्सर आप कुछ ऐसा लिख ​​सकते हैं:

 tail -f application.log | grep -i error 

या इस तरह भी:

 tail -f application.log | grep -i -P "(error|warning|failure)" 

लेकिन यह मत भूलो कि grep में बहुत सारे अद्भुत विकल्प हैं। उदाहरण -v के लिए, जो आपकी खोज को पुनः प्रदर्शित करता है और "सूचना" संदेशों को छोड़कर सभी दिखाता है:

 tail -f application.log | grep -v -i "info" 

अतिरिक्त सामान:

विकल्प पी बहुत उपयोगी है, क्योंकि डिफ़ॉल्ट ग्रीप द्वारा "पुरानी नियमित अभिव्यक्ति:" और पुरानी पीसीआर का उपयोग किया जाता है, जो कि समूहीकरण के बारे में भी नहीं जानता है।
-मैं मामले की अनदेखी करता हूं।
-लाइन-बफर पार्स लाइन मानक 4k बफर तक पहुंचने की प्रतीक्षा करने के बजाय तुरंत (पूंछ -f | grep के लिए उपयोगी)।

यदि आप नियमित अभिव्यक्ति को अच्छी तरह से जानते हैं, तो एक-मिलान / / -ओ के साथ आप वास्तव में पाठ को काटने के साथ एक महान काम कर सकते हैं। माईसर के खोल को निकालने के लिए बस अगले दो कमांड्स की तुलना करें:

 $ grep myuser /etc/passwd| cut -d ":" -f 7 $ grep -Po "^myuser(:.*){5}:\K.*" /etc/passwd 

दूसरा कमांड अधिक संकलित दिखता है, लेकिन यह केवल grep और कटौती के बजाय grep चलाता है, इसलिए निष्पादन के लिए कम समय लगेगा।

6. लॉग फ़ाइल का आकार कैसे कम करें

* Nix में, यदि आप लॉग फ़ाइल को हटाते हैं, जो वर्तमान में एक एप्लिकेशन द्वारा उपयोग किया जाता है, तो आप केवल सभी लॉग को हटा नहीं सकते हैं, आप नए लॉग को पुनरारंभ करने तक एप्लिकेशन को लिखने से रोक सकते हैं।

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

तो, लॉग फ़ाइल को हटाए बिना कैसे साफ़ करें:

 echo "" > application.log 

या हम truncate कमांड का उपयोग कर सकते हैं:

 truncate --size=1M application.log 

उल्लेख करें, वह छोटा कमांड शेष फ़ाइल को हटा देगा, जिससे आप नवीनतम लॉग ईवेंट खो देंगे। एक और उदाहरण की जाँच करें कि पिछले 1000 लाइनों को कैसे संग्रहीत किया जाए:

 echo "$(tail -n 1000 application.log)" > application.log 

PS लिनक्स में हमारे पास मानक सेवा रोटेटलॉग है। आप अपने लॉग को स्वचालित truncate / रोटेट में जोड़ सकते हैं या मौजूदा लॉग लाइब्रेरी का उपयोग कर सकते हैं जो आपके लिए ऐसा कर सकते हैं (जैसे जावा में log4j)।

7. देखो तुम्हारे लिए देख रहा है!

एक स्थिति है जब आप किसी घटना के समाप्त होने की प्रतीक्षा कर रहे हैं। उदाहरण के लिए, जबकि कोई अन्य उपयोगकर्ता शेल में जाता है (आप लगातार कमांड को निष्पादित करते हैं ), या किसी को scp या ftp का उपयोग करके आपकी मशीन में फाइल कॉपी करनी चाहिए और आप पूरा होने का इंतजार कर रहे हैं (एलएस दर्जनों बार दोहरा रहे हैं)।

ऐसे मामलों में, आप उपयोग कर सकते हैं

 watch <command> 

डिफ़ॉल्ट रूप से, Ctrl + C दबाए जाने तक स्क्रीन के पूर्व-साफ़ के साथ हर 2 सेकंड में निष्पादित किया जाएगा। आप कॉन्फ़िगर कर सकते हैं कि कितनी बार निष्पादित किया जाना चाहिए।

जब आप लाइव लॉग देखना चाहते हैं तो यह बहुत उपयोगी है।

8. बैश क्रम

पर्वतमाला बनाने के लिए बहुत उपयोगी निर्माण है। उदाहरण के लिए कुछ इस तरह के बजाय:

 for srv in 1 2 3 4 5; do echo "server${srv}";done server1 server2 server3 server4 server5 

आप निम्नलिखित लिख सकते हैं:

 for srv in server{1..5}; do echo "$srv";done server1 server2 server3 server4 server5 

इसके अलावा आप स्वरूपित पर्वतमाला उत्पन्न करने के लिए seq कमांड का उपयोग कर सकते हैं। उदाहरण के लिए हम seq का उपयोग मानों को बनाने के लिए कर सकते हैं, जिसे स्वचालित रूप से चौड़ाई (00, 01 के बजाय 0, 1) द्वारा समायोजित किया जाएगा:

 for srv in $(seq -w 5 10); do echo "server${srv}";done server05 server06 server07 server08 server09 server10 

कमांड प्रतिस्थापन के साथ एक और उदाहरण - फ़ाइलों का नाम बदलें। बिना विस्तार के फ़ाइल नाम प्राप्त करने के लिए हम ' basename ' कमांड का उपयोग कर रहे हैं:

 for file in *.txt; do name=$(basename "$file" .txt);mv $name{.txt,.lst}; done 

'%' के साथ और भी कम:

 for file in *.txt; do mv ${file%.txt}{.txt,.lst}; done 

PS वास्तव में उन फ़ाइलों का नाम बदलने के लिए जिन्हें आप ' नाम बदलने ' के लिए आज़मा सकते हैं जिनमें बहुत सारे विकल्प हैं।

एक और उदाहरण - नए जावा प्रोजेक्ट के लिए संरचना बनाने की अनुमति देता है:

 mkdir -p project/src/{main,test}/{java,resources} 

9. पूंछ, कई फाइलें, कई उपयोगकर्ता ...

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

लेकिन मानक पूंछ यह भी कर सकती है:

 tail -f /var/logs/*.log 

उपयोगकर्ताओं को याद करने देता है, जो एप्लिकेशन लॉग देखने के लिए 'टेल-एल' उपनाम का उपयोग कर रहे हैं।
कई उपयोगकर्ता 'टेल -f' का उपयोग करके लॉग फाइल को एक साथ देख सकते हैं। उनमें से कुछ अपने सत्र के साथ बहुत सटीक नहीं हैं। वे किसी कारण से पृष्ठभूमि में 'टेल-ऑफ' छोड़ सकते हैं और इसके बारे में भूल सकते हैं।

यदि एप्लिकेशन को फिर से शुरू किया गया था, तो ये चल रही 'टेल-एफ' प्रक्रियाएं हैं जो लगातार लॉग फ़ाइल देख रही हैं, कई दिनों या महीनों तक लटका रह सकती हैं।

आमतौर पर यह एक बड़ी समस्या नहीं है, लेकिन बड़े करीने से नहीं।

यदि आप लॉग देखने के लिए उपनाम का उपयोग कर रहे हैं, तो आप इस उपनाम को --pid विकल्प के साथ संशोधित कर सकते हैं:

 alias TFapplog='tail -f --pid=$(cat /opt/app/tmp/app.pid) /opt/app/logs/app.log' 

उस स्थिति में, सभी पूंछों को स्वचालित रूप से समाप्त कर दिया जाएगा जब लक्ष्य आवेदन को फिर से शुरू किया जाएगा।

10. निर्दिष्ट आकार के साथ फ़ाइल बनाएँ

dd ब्लॉक और बाइनरी डेटा के साथ काम करने के लिए सबसे लोकप्रिय टूल में से एक था। उदाहरण के लिए शून्य से भरी 1 एमबी फ़ाइल होगी:

 dd if=/dev/zero of=out.txt bs=1M count=10 

लेकिन मैं सलाह देता हूं कि आप फैलोकेट का उपयोग करें:

 fallocate -l 10M file.txt 

फ़ाइल सिस्टम पर, जो समर्थन फ़ंक्शन (xfs, ext4, Btrfs ...) को आवंटित करते हैं, dd टूल के विपरीत, फ़ॉलेट को तुरंत निष्पादित किया जाएगा। अतिरिक्त में, आबंटित का अर्थ है ब्लॉकों का वास्तविक आवंटन, न कि एक अतिरिक्त फ़ाइल बनाना।

11. ज़ार

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

पहला - आप प्रक्रिया के लिए तर्कों की बहुत लंबी सूची प्राप्त कर सकते हैं, और यह कमांड लाइन की लंबाई (डिफ़ॉल्ट रूप से ~ 4 kb) से अधिक हो सकती है।

लेकिन आप एक विकल्प का उपयोग करके निष्पादन को सीमित कर सकते हैं, इसलिए xargs कई बार कमांड चलाएगा, एक समय में निर्दिष्ट तर्क भेजेगा:

 $ # lets print 5 arguments and send them to echo with xargs: $ echo 1 2 3 4 5 | xargs echo 1 2 3 4 5 $ # now let's repeat, but limit argument processing by 3 per execution $ echo 1 2 3 4 5 | xargs -n 3 echo 1 2 3 4 5 

आगे जा रहे हैं। लंबी सूची को संसाधित करने में बहुत समय लग सकता है, क्योंकि यह एक ही धागे में चलता है। लेकिन अगर हमारे पास कई कोर हैं, तो हम समानांतर में चलने के लिए xargs बता सकते हैं:

 echo 1 2 3 4 5 6 7 8 9 10| xargs -n 2 -P 3 echo 

ऊपर दिए गए उदाहरण में, हम xargs को 3 थ्रेड्स में सूची संसाधित करने के लिए कहते हैं; प्रत्येक थ्रेड निष्पादन के लिए 2 तर्क ले और संसाधित करेगा। यदि आपको नहीं पता कि आपके पास कितने कोर हैं, तो " nproc " का उपयोग करके इसे ऑप्टिमाइज़ करें:

 echo 1 2 3 4 5 6 7 8 9 10 | xargs -n 2 -P $(nproc) echo 

12. नींद? जबकि? पढ़ें!

कुछ समय के लिए आपको कई सेकंड इंतजार करना होगा। या पढ़ने के लिए उपयोगकर्ता इनपुट की प्रतीक्षा करें:

 read -p "Press any key to continue " -n 1 

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

 read -p "Press any key to continue (auto continue in 30 seconds) " -t 30 -n 1 

तो आप सिर्फ स्लीप कमांड के बारे में भूल सकते हैं।

मुझे संदेह है कि मेरी सभी चालें दिलचस्प नहीं लगती हैं, लेकिन मुझे ऐसा लग रहा था कि एक दर्जन से अधिक संख्या अच्छी है।

इस पर मैं अलविदा कहता हूं, और मैं सर्वेक्षण में भाग लेने के लिए आभारी रहूंगा।

बेशक ऊपर चर्चा करने और टिप्पणियों में अपनी शांत चाल साझा करने के लिए स्वतंत्र महसूस करें!