हाय सब लोग! इस लेख में हम कमांड लाइन (जिसे CLI, कंसोल, टर्मिनल या शेल के रूप में भी जाना जाता है) पर एक अच्छी नज़र डालेंगे।

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

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

चलिए शुरू करते हैं! =D

विषय सूची

• कंसोल, टर्मिनल, कमांड लाइन (CLI) और शेल के बीच अंतर
  • कंसोल
  • टर्मिनल
  • शेल
  • कमांड लाइन (CLI)
• मुझे टर्मिनल का उपयोग करने की परवाह क्यों करनी चाहिए?
• शेल के विभिन्न प्रकार
  • थोड़ा इतिहास - POSIX
  • मुझे कैसे पता चलेगा कि मैं कौन सा शेल चला रहा हूँ?
  • कौन सा शेल बेहतर है?
    • अनुकूलन के बारे में एक टिप्पणी
• उपयोग करने के लिए सबसे आम और उपयोगी कमांड
  • Git कमांड
• हमारी पहली स्क्रिप्ट
• निष्कर्ष

कंसोल, कमांड लाइन (CLI), टर्मिनल और शेल के बीच अंतर

मुझे लगता है कि शुरू करने के लिए एक अच्छी जगह यह जानना है कि कमांड लाइन वास्तव में क्या है।

इसका जिक्र करते समय, आपने टर्मिनल, कंसोल, कमांड लाइन, CLI, और शेल शब्द सुने होंगे। लोग अक्सर इन शब्दों का परस्पर उपयोग करते हैं लेकिन सच्चाई यह है कि वे वास्तव में अलग-अलग चीजें हैं।

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

कंसोल:

कंसोल वह भौतिक उपकरण है जो आपको कंप्यूटर के साथ बातचीत करने की अनुमति देता है।

सादे अंग्रेजी में, यह आपकी कंप्यूटर स्क्रीन, कीबोर्ड, और माउस है। एक उपयोगकर्ता के रूप में, आप अपने कंप्यूटर के साथ के माध्यम से अपने कंसोल के साथ बातचीत करते हैं।

टर्मिनल:

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

सादे अंग्रेजी में फिर से, यह वह "विंडो" है जिसमें आप वास्तविक कमांड दर्ज करते हैं जिन्हें आपका कंप्यूटर प्रोसेस करेगा।

ध्यान रखें कि टर्मिनल एक प्रोग्राम है, किसी अन्य की तरह। और किसी भी प्रोग्राम की तरह, आप इसे इंस्टॉल और अनइंस्टॉल कर सकते हैं जैसा आप चाहें। आपके कंप्यूटर में कई टर्मिनल इंस्टॉल होना और जब चाहें जो चाहें चलाना भी संभव है।

सभी ऑपरेटिंग सिस्टम एक डिफ़ॉल्ट टर्मिनल के साथ इंस्टॉल आते हैं, लेकिन चुनने के लिए कई विकल्प हैं, प्रत्येक अपनी कार्यक्षमता और सुविधाओं के साथ।

शेल:

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

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

विभिन्न शेल अलग-अलग सिंटैक्स और विशेषताओं के साथ आते हैं। आपके कंप्यूटर में कई शेल इंस्टॉल होना और जब चाहें प्रत्येक को चलाना भी संभव है।

अधिकांश लिनक्स और मैक ऑपरेटिंग सिस्टम में डिफ़ॉल्ट शेल Bash है। जबकि विंडोज पर यह PowerShell है। शेल के कुछ अन्य सामान्य उदाहरण Zsh और Fish हैं।

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

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

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

कमांड लाइन या CLI (कमांड लाइन इंटरफेस):

CLI वह इंटरफेस है जिसमें हम कंप्यूटर को प्रोसेस करने के लिए कमांड दर्ज करते हैं। सादे अंग्रेजी में एक बार फिर, यह वह स्थान है जिसमें आप कमांड दर्ज करते हैं जिन्हें कंप्यूटर प्रोसेस करेगा।

यह व्यावहारिक रूप से टर्मिनल के समान है और मेरी राय में इन शर्तों का परस्पर उपयोग किया जा सकता है।

यहां उल्लेख करने वाली एक दिलचस्प बात यह है कि अधिकांश ऑपरेटिंग सिस्टम में दो अलग-अलग प्रकार के इंटरफेस होते हैं:

• CLI, जो कंप्यूटर को कार्य निष्पादित करने के लिए इनपुट के रूप में कमांड लेता है।
• दूसरा है GUI (ग्राफिकल यूजर इंटरफेस), जिसमें उपयोगकर्ता स्क्रीन पर चीजें देख सकता है और उन पर क्लिक कर सकता है और कंप्यूटर उन घटनाओं का जवाब देकर संबंधित कार्य निष्पादित करेगा।

मुझे टर्मिनल का उपयोग करने की परवाह क्यों करनी चाहिए?

हमने अभी उल्लेख किया कि अधिकांश ऑपरेटिंग सिस्टम GUI के साथ आते हैं। तो अगर हम स्क्रीन पर चीजें देख सकते हैं और जो चाहें करने के लिए चारों ओर क्लिक कर सकते हैं, तो आप सोच सकते हैं कि आपको इस जटिल टर्मिनल/CLI/शेल चीज़ को क्यों सीखना चाहिए?

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

इस अर्थ में, कमांड लाइन के साथ सहज होने से आपको समय बचाने और अपने कार्यों को तेजी से निष्पादित करने में मदद मिलेगी।

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

बस कुछ उदाहरण देने के लिए, हम एक स्क्रिप्ट बना सकते हैं जो हमारे लिए एक नया ऑनलाइन रेपो बनाता है, या जो हमारे लिए क्लाउड प्रदाता पर एक निश्चित इन्फ्रास्ट्रक्चर बनाता है, या जो हमारे स्क्रीन वॉलपेपर को हर घंटे बदलने जैसे सरल कार्य को निष्पादित करता है।

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

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

इसलिए CLI के साथ सहज होने से आप सभी अवसरों पर कंप्यूटर के साथ बातचीत कर पाएंगे।

अंतिम कारण यह है कि यह कूल दिखता है और मजेदार है। आप फिल्मी हैकर्स को अपने कंप्यूटर पर इधर-उधर क्लिक करते नहीं देखते, है ना? ;)

शेल के विभिन्न प्रकार

आपके टर्मिनल में चलाए जा सकने वाले वास्तविक कमांड में गोता लगाने से पहले, मुझे लगता है कि वहां मौजूद शेल के विभिन्न प्रकारों को पहचानना और यह पहचानना महत्वपूर्ण है कि आप वर्तमान में कौन सा शेल चला रहे हैं।

विभिन्न शेल अलग-अलग सिंटैक्स और विभिन्न सुविधाओं के साथ आते हैं, इसलिए वास्तव में कौन सा कमांड दर्ज करना है, यह जानने के लिए, आपको पहले यह जानना होगा कि आप कौन सा शेल चला रहे हैं।

थोड़ा इतिहास – POSIX

शेल के लिए, POSIX नामक एक सामान्य मानक है।

POSIX शेल के लिए बहुत इसी तरह काम करता है जैसे ECMAScript जावास्क्रिप्ट के लिए काम करता है। यह एक मानक है जो कुछ विशेषताओं और सुविधाओं को निर्दिष्ट करता है जिनका सभी शेल को पालन करना चाहिए।

यह मानक 1980 के दशक में स्थापित किया गया था और अधिकांश वर्तमान शेल उस मानक के अनुसार विकसित किए गए थे। इसलिए अधिकांश शेल समान सिंटैक्स और समान सुविधाओं को साझा करते हैं।

मुझे कैसे पता चलेगा कि मैं कौन सा शेल चला रहा हूँ?

यह जानने के लिए कि आप वर्तमान में कौन सा शेल चला रहे हैं, बस अपना टर्मिनल खोलें और echo $0 दर्ज करें। यह वर्तमान चल रहे प्रोग्राम का नाम प्रिंट करेगा, जो इस मामले में वास्तविक शेल है।

कौन सा शेल बेहतर है?

अधिकांश शेल के बीच बहुत अधिक अंतर नहीं है। चूंकि उनमें से अधिकांश उसी मानक का पालन करते हैं, आप पाएंगे कि उनमें से अधिकांश समान रूप से काम करते हैं।

हालांकि कुछ मामूली अंतर हैं जिन्हें आप जानना चाह सकते हैं:

• जैसा कि उल्लेख किया गया है, Bash सबसे व्यापक रूप से उपयोग किया जाता है और मैक और लिनक्स पर डिफ़ॉल्ट रूप से इंस्टॉल आता है।
• Zsh Bash के समान है, लेकिन यह इसके बाद बनाया गया था और इसके ऊपर कुछ अच्छे सुधारों के साथ आता है। यदि आप इसके अंतरों के बारे में अधिक विवरण चाहते हैं, तो यहां इसके बारे में एक अच्छा लेख है।
• Fish एक और आमतौर पर इस्तेमाल किया जाने वाला शेल है जो कुछ अच्छी अंतर्निहित सुविधाओं और कॉन्फ़िगरेशन के साथ आता है जैसे ऑटोकंप्लीशन और सिंटैक्स हाइलाइटिंग। Fish के बारे में बात यह है कि यह POSIX अनुपालन नहीं है, जबकि Bash और Zsh हैं। इसका मतलब है कि कुछ कमांड जिन्हें आप Bash और Zsh पर चला पाएंगे, Fish पर नहीं चलेंगे और इसके विपरीत। यह Fish स्क्रिप्टिंग को Bash और Zsh की तुलना में अधिकांश कंप्यूटरों के साथ कम संगत बनाता है।
• Ash या Dash जैसे अन्य शेल भी हैं (नामकरण सब कुछ को और अधिक भ्रमित करता है, मुझे पता है...) जो POSIX शेल के स्ट्रिप्ड-डाउन संस्करण हैं। इसका मतलब है कि वे केवल POSIX में आवश्यक सुविधाओं की पेशकश करते हैं, और कुछ नहीं। जबकि Bash और Zsh POSIX की आवश्यकता से अधिक सुविधाएँ जोड़ते हैं।

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

तो एक आम अभ्यास इस "बढ़े हुए" शेल जैसे Bash या Zsh का उपयोग सामान्य बातचीत के लिए करना है, और स्क्रिप्ट निष्पादित करने के लिए Ash या Dash जैसे "स्ट्रिप्ड" शेल का उपयोग करना है।

जब हम बाद में स्क्रिप्टिंग पर पहुंचेंगे, तो हम देखेंगे कि हम किसी दिए गए स्क्रिप्ट को निष्पादित करने के लिए कौन सा शेल परिभाषित कर सकते हैं।

यदि आप इन शेल के बीच अधिक विस्तृत तुलना में रुचि रखते हैं, तो यहां एक वीडियो है जो इसे वास्तव में अच्छी तरह से समझाता है:

अगर मुझे एक शेल की सिफारिश करनी होती, तो मैं Bash की सिफारिश करूंगा क्योंकि यह सबसे मानक और आमतौर पर इस्तेमाल किया जाने वाला है। इसका मतलब है कि आप अपने ज्ञान को अधिकांश वातावरणों में अनुवाद कर पाएंगे।

लेकिन फिर भी, सच्चाई यह है कि अधिकांश शेल के बीच बहुत अधिक अंतर नहीं है। तो किसी भी मामले में आप कुछ कोशिश कर सकते हैं और देख सकते हैं कि आपको कौन सा सबसे अच्छा लगता है। ;)

अनुकूलन के बारे में एक टिप्पणी

मैंने अभी उल्लेख किया कि Fish ऑटोकंप्लीशन और सिंटैक्स हाइलाइटिंग जैसे अंतर्निहित कॉन्फ़िगरेशन के साथ आता है। यह Fish में अंतर्निहित आता है, लेकिन Bash या Zsh में आप इन सुविधाओं को कॉन्फ़िगर भी कर सकते हैं।

बिंदु यह है कि शेल अनुकूलन योग्य हैं। आप प्रोग्राम के काम करने के तरीके को संपादित कर सकते हैं, आपके पास कौन से कमांड उपलब्ध हैं, आपका प्रॉम्प्ट क्या जानकारी दिखाता है, और बहुत कुछ।

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

इसके अलावा, ऑनलाइन कई प्लगइन्स उपलब्ध हैं जो आपको अपने शेल को आसान तरीके से अनुकूलित करने की अनुमति देते हैं। आप बस उन्हें इंस्टॉल करते हैं और उस प्लगइन द्वारा प्रदान की जाने वाली सुविधाएं प्राप्त करते हैं। कुछ उदाहरण OhMyZsh और Starship हैं।

ये अनुकूलन विकल्प टर्मिनल के लिए भी सही हैं।

तो न केवल आपके पास चुनने के लिए कई शेल और टर्मिनल विकल्प हैं - आपके पास प्रत्येक शेल और टर्मिनल के लिए कई कॉन्फ़िगरेशन विकल्प भी हैं।

यदि आप शुरू कर रहे हैं, तो यह सारी जानकारी थोड़ी भारी लग सकती है। लेकिन बस जान लें कि कई विकल्प उपलब्ध हैं, और प्रत्येक विकल्प को अनुकूलित भी किया जा सकता है। बस इतना ही।

उपयोग करने के लिए सबसे आम और उपयोगी कमांड

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

ध्यान रखें कि ये उदाहरण मेरी वर्तमान कॉन्फ़िगरेशन (Linux OS पर Bash) पर आधारित होंगे। लेकिन अधिकांश कमांड अधिकांश कॉन्फ़िगरेशन पर लागू होने चाहिए।

• Echo टर्मिनल में जो भी पैरामीटर हम इसे पास करते हैं उसे प्रिंट करता है।

echo Hello freeCodeCamp! // Output: Hello freeCodeCamp! 

• pwd का अर्थ है प्रिंट वर्किंग डायरेक्टरी और यह कंप्यूटर पर "स्थान" या डायरेक्टरी को प्रिंट करता है जहां हम वर्तमान में हैं।

pwd // Output: /home/German 

• ls आपको उस डायरेक्टरी की सामग्री प्रस्तुत करता है जिसमें आप वर्तमान में हैं। यह आपको फाइलों और अन्य डायरेक्टरी दोनों को प्रस्तुत करेगा जो आपकी वर्तमान डायरेक्टरी में हैं।

उदाहरण के लिए, यहां मैं एक रिएक्ट प्रोजेक्ट डायरेक्टरी पर हूं जिस पर मैं हाल ही में काम कर रहा हूं:

ls // Output: node_modules package.json package-lock.json public README.md src 

यदि आप इस कमांड को फ्लैग या पैरामीटर -a पास करते हैं तो यह आपको छिपी हुई फाइलें या डायरेक्टरी भी दिखाएगा। जैसे .git या .gitignore फाइलें

ls -a // Output: . .env .gitignore package.json public src .. .git node_modules package-lock.json README.md 

• cd चेंज डायरेक्टरी का संक्षिप्त रूप है और यह आपको आपकी वर्तमान डायरेक्टरी से दूसरी डायरेक्टरी में ले जाएगा।

मेरे होम डायरेक्टरी पर रहते हुए, मैं cd Desktop दर्ज कर सकता हूं और यह मुझे डेस्कटॉप डायरेक्टरी में ले जाएगा।

यदि मैं एक डायरेक्टरी ऊपर जाना चाहता हूं, अर्थात उस डायरेक्टरी में जाना जिसमें वर्तमान डायरेक्टरी है, तो मैं cd .. दर्ज कर सकता हूं।

यदि आप अकेले cd दर्ज करते हैं, तो यह आपको सीधे आपके होम डायरेक्टरी में ले जाएगा।

• mkdir मेक डायरेक्टरी का संक्षिप्त रूप है और यह आपके लिए एक नई डायरेक्टरी बनाएगा। आपको कमांड को डायरेक्टरी नाम पैरामीटर पास करना होगा।

यदि मैं "Test" नामक एक नई डायरेक्टरी बनाना चाहता था तो मैं mkdir test दर्ज करूंगा।

• rmdir रिमूव डायरेक्टरी का संक्षिप्त रूप है और यह वही करता है। इसे mkdir की तरह ही डायरेक्टरी नाम पैरामीटर की आवश्यकता होती है: rmdir test।

• touch आपको अपनी वर्तमान डायरेक्टरी में एक खाली फाइल बनाने की अनुमति देता है। पैरामीटर के रूप में यह फाइल नाम लेता है, जैसे touch test.txt।

• rm आपको फाइलें हटाने की अनुमति देता है, उसी तरह जैसे rmdir आपको डायरेक्टरी हटाने की अनुमति देता है।
  rm test.txt

• cp आपको फाइल या डायरेक्टरी कॉपी करने की अनुमति देता है। यह कमांड दो पैरामीटर लेता है: पहला वह फाइल या डायरेक्टरी है जिसे आप कॉपी करना चाहते हैं, और दूसरा आपकी कॉपी का गंतव्य है (आप अपनी फाइल/डायरेक्टरी को कहां कॉपी करना चाहते हैं)।

यदि मैं उसी डायरेक्टरी में अपनी txt फाइल की एक कॉपी बनाना चाहता हूं, तो मैं निम्नलिखित दर्ज कर सकता हूं:

cp test.txt testCopy.txt 

देखें कि डायरेक्टरी नहीं बदलती, क्योंकि "गंतव्य" के लिए मैं फाइल का नया नाम दर्ज करता हूं।

यदि मैं फाइल को एक अलग डायरेक्टरी में कॉपी करना चाहता था, लेकिन वही फाइल नाम रखना चाहता था, तो मैं इसे दर्ज कर सकता हूं:

cp test.txt ./testFolder/ 

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

cp test.txt ./testFolder/testCopy.txt 

• mv मूव का संक्षिप्त रूप है, और यह हमें एक फाइल या डायरेक्टरी को एक स्थान से दूसरे स्थान पर ले जाने देता है। अर्थात, इसे एक नई डायरेक्टरी में बनाएं और इसे पिछले वाले में हटा दें (वैसे ही जैसे आप काटकर चिपकाकर कर सकते हैं)।

फिर से, यह कमांड दो पैरामीटर लेता है, वह फाइल या डायरेक्टरी जिसे हम ले जाना चाहते हैं और गंतव्य।

mv test.txt ./testFolder/ 

हम उसी कमांड में फाइल का नाम भी बदल सकते हैं अगर हम चाहते हैं:

mv test.txt ./testFolder/testCopy.txt 

• head आपको किसी फाइल या पाइप्ड डेटा की शुरुआत को सीधे टर्मिनल से देखने की अनुमति देता है।

head test.txt // Output: this is the beginning of my test file 

• tail उसी तरह काम करता है लेकिन यह आपको फाइल का अंत दिखाएगा।

tail test.txt // Output: this is the end of my test file 

• --help फ्लैग का उपयोग अधिकांश कमांड पर किया जा सकता है और यह उस दिए गए कमांड का उपयोग कैसे करें, इस पर जानकारी लौटाएगा।

cd --help // output: cd: cd [-L|[-P [-e]] [-@]] [dir] Change the shell working directory. 

वर्तमान डायरेक्टरी को DIR पर बदलें। डिफ़ॉल्ट DIR HOME शेल वेरिएबल का मान है।

वेरिएबल CDPATH DIR वाले डायरेक्टरी के लिए खोज पथ को परिभाषित करता है। CDPATH में वैकल्पिक डायरेक्टरी नाम कोलन : से अलग किए जाते हैं।

एक नल डायरेक्टरी नाम वर्तमान डायरेक्टरी के समान है यदि DIR ... से शुरू होता है।

• इसी तरह, man कमांड किसी विशेष कमांड के बारे में जानकारी लौटाएगा।

 man cp // output: CP(1) User Commands CP(1) NAME cp - copy files and directories SYNOPSIS cp [OPTION]... [-T] SOURCE DEST cp [OPTION]... SOURCE... DIRECTORY cp [OPTION]... -t DIRECTORY SOURCE... DESCRIPTION Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY. Mandatory arguments to long options are mandatory for short options too. -a, --archive same as -dR --preserve=all --attributes-only don't copy the file data, just the attributes ... 

आप man bash भी दर्ज कर सकते हैं और यह इस शेल के बारे में जानने के लिए सब कुछ पर एक विशाल मैनुअल लौटाएगा। ;)

• code आपका डिफ़ॉल्ट कोड एडिटर खोलेगा। यदि आप कमांड को अकेले दर्ज करते हैं, तो यह केवल एडिटर को आपके द्वारा खोली गई नवीनतम फाइल/डायरेक्टरी के साथ खोलता है।

आप एक दी गई फाइल को पैरामीटर के रूप में पास करके भी खोल सकते हैं: code test.txt।

या नई फाइल खोलें नए फाइल नाम को पैरामीटर के रूप में पास करके: code thisIsAJsFile.js।

• edit टेक्स्ट फाइलों को आपके डिफ़ॉल्ट कमांड लाइन टेक्स्ट एडिटर में खोलेगा (जो यदि आप मैक या लिनक्स पर हैं तो नैनो या विम होने की संभावना है)।

यदि आप अपनी फाइल खोलते हैं और फिर अपने एडिटर से बाहर नहीं निकल सकते, तो पहले इस मीम को देखें:

![vimExit](https://www.freecodecamp.org/news/content/images/2022/03/vimExit.png) 

और फिर :q! टाइप करें और एंटर दबाएं।

मीम मजेदार है क्योंकि हर कोई CLI टेक्स्ट एडिटर्स के साथ पहली बार संघर्ष करता है, क्योंकि अधिकांश क्रियाएं (जैसे एडिटर से बाहर निकलना) कीबोर्ड शॉर्टकट के साथ की जाती हैं। इन एडिटर्स का उपयोग एक पूरी तरह से अलग विषय है, इसलिए यदि आप अधिक सीखने में रुचि रखते हैं तो ट्यूटोरियल देखें। ;)

• ctrl+c आपको टर्मिनल द्वारा चलाए जा रहे वर्तमान प्रोसेस से बाहर निकलने की अनुमति देता है। उदाहरण के लिए, यदि आप npx create-react-app के साथ एक रिएक्ट ऐप बना रहे हैं और किसी बिंदु पर बिल्ड को रद्द करना चाहते हैं, तो बस ctrl+c दबाएं और यह रुक जाएगा।

• टर्मिनल से टेक्स्ट कॉपी करना ctrl+shift+c के साथ किया जा सकता है और पेस्ट करना ctrl+shift+v के साथ किया जा सकता है

• clear आपके टर्मिनल को पिछली सभी सामग्री से साफ कर देगा।

• exit आपके टर्मिनल को बंद कर देगा और (यह कमांड नहीं है लेकिन यह भी कूल है) ctrl+alt+t आपके लिए एक नया टर्मिनल खोलेगा।

• ऊपर और नीचे की कुंजी दबाकर आप आपके द्वारा दर्ज किए गए पिछले कमांड के माध्यम से नेविगेट कर सकते हैं।

• Tab दबाकर आपको अब तक लिखे गए टेक्स्ट के आधार पर ऑटोकंप्लीशन मिलेगा। Tab दो बार दबाकर आपको अब तक लिखे गए टेक्स्ट के आधार पर सुझाव मिलेंगे।

उदाहरण के लिए यदि मैं edit test लिखता हूं और Tab दो बार, मुझे testFolder/ test.txt मिलता है। यदि मैं edit test. लिखता हूं और Tab दबाता हूं तो मेरा टेक्स्ट ऑटोकंप्लीट होकर edit test.txt हो जाता है

Git कमांड

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

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

• git init आपके लिए एक नया स्थानीय रिपॉजिटरी बनाएगा।

git init // output: Initialized empty Git repository in /home/German/Desktop/testFolder/.git/ 

• git add एक या अधिक फाइलों को स्टेजिंग में जोड़ता है। आप या तो स्टेजिंग में जोड़ने के लिए एक विशिष्ट फाइल का विवरण दे सकते हैं या git add . टाइप करके सभी बदली हुई फाइलों को जोड़ सकते हैं।

• git commit आपके परिवर्तनों को रिपॉजिटरी में कमिट करता है। कमिट हमेशा -m फ्लैग और कमिट संदेश के साथ होना चाहिए।

git commit -m 'This is a test commit' // output: [master (root-commit) 6101dfe] This is a test commit 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 test.js 

• git status आपको बताता है कि आप वर्तमान में किस ब्रांच पर हैं और क्या आपके पास कमिट करने के लिए परिवर्तन हैं या नहीं।

git status // output: On branch master nothing to commit, working tree clean 

• git clone आपको उस डायरेक्टरी में एक रिपॉजिटरी को क्लोन (कॉपी) करने की अनुमति देता है जिसमें आप वर्तमान में हैं। ध्यान रखें कि आप दोनों रिमोट रिपॉजिटरी (GitHub, GitLab, आदि में) और स्थानीय रिपॉजिटरी (जो आपके कंप्यूटर में संग्रहीत हैं) को क्लोन कर सकते हैं।

git clone https://github.com/coccagerman/MazeGenerator.git // output: Cloning into 'MazeGenerator'... remote: Enumerating objects: 15, done. remote: Counting objects: 100% (15/15), done. remote: Compressing objects: 100% (15/15), done. remote: Total 15 (delta 1), reused 11 (delta 0), pack-reused 0 Unpacking objects: 100% (15/15), done. 

• git remote add origin आपके प्रोजेक्ट के लिए उपयोग किए जाने वाले रिमोट रिपॉजिटरी के URL को विस्तृत करने के लिए उपयोग किया जाता है। यदि आप इसे किसी बिंदु पर बदलना चाहते हैं, तो आप git remote set-url origin कमांड का उपयोग करके ऐसा कर सकते हैं।

git remote add origin https://github.com/coccagerman/testRepo.git 

ध्यान रखें कि आपको पहले अपना रिमोट रेपो बनाने की आवश्यकता है ताकि उसका URL प्राप्त हो सके। हम बाद में एक छोटी स्क्रिप्ट के साथ कमांड लाइन से ऐसा कैसे कर सकते हैं, देखेंगे। ;)

• git remote -v आपको वर्तमान रिमोट रिपॉजिटरी को सूचीबद्ध करने देता है जिसका आप उपयोग कर रहे हैं।

git remote -v // output: origin https://github.com/coccagerman/testRepo.git (fetch) origin https://github.com/coccagerman/testRepo.git (push) 

• git push आपके कमिट किए गए परिवर्तनों को आपके रिमोट रेपो में अपलोड करता है।

git push // output: Counting objects: 2, done. Delta compression using up to 8 threads. Compressing objects: 100% (2/2), done. Writing objects: 100% (2/2), 266 bytes | 266.00 KiB/s, done. Total 2 (delta 0), reused 0 (delta 0) 

• git branch आपके रेपो पर उपलब्ध सभी ब्रांच को सूचीबद्ध करता है और आपको बताता है कि आप वर्तमान में किस ब्रांच पर हैं। यदि आप एक नई ब्रांच बनाना चाहते हैं, तो आपको बस नए ब्रांच नाम को पैरामीटर के रूप में जोड़ना होगा जैसे git branch <branch name>।

git branch // output: * main 

• git checkout आपको एक ब्रांच से दूसरी ब्रांच पर ले जाता है। यह आपके गंतव्य ब्रांच को पैरामीटर के रूप में लेता है।

git checkout newBranch // output: Switched to branch 'newBranch' 

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

यदि आपके रिमोट रेपो में नया कोड है, तो कमांड वास्तविक फाइलें लौटाएगा जो पुल में संशोधित हुई थीं। यदि नहीं, तो हमें Already up to date मिलता है।

git pull // output: Already up to date. 

• git diff आपको उस ब्रांच और दूसरे के बीच अंतर देखने की अनुमति देता है जिसमें आप वर्तमान में हैं।

git diff newBranch // output: diff --git a/newFileInNewBranch.js b/newFileInNewBranch.js deleted file mode 100644 index e69de29..0000000 

एक साइड टिप्पणी के रूप में, ब्रांच या रेपो के बीच अंतर की तुलना करते समय, आमतौर पर Meld जैसे विज़ुअल टूल का उपयोग किया जाता है। ऐसा नहीं है कि आप इसे सीधे टर्मिनल में विज़ुअलाइज़ नहीं कर सकते, लेकिन ये टूल स्पष्ट विज़ुअलाइज़ेशन के लिए बहुत अच्छे हैं।

• git merge आपके वर्तमान ब्रांच को दूसरे के साथ मर्ज (जोड़ता) करता है। ध्यान रखें कि परिवर्तनों को केवल आपके वर्तमान ब्रांच में शामिल किया जाएगा, दूसरे में नहीं।

git merge newBranch // output: Updating f15cf51..3a3d62f Fast-forward newFileInNewBranch.js | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 newFileInNewBranch.js 

• git log आपके द्वारा रेपो में किए गए सभी पिछले कमिट को सूचीबद्ध करता है।

git log // output: commit 3a3d62fe7cea7c09403c048e971a5172459d0948 (HEAD -> main, tag: TestTag, origin/main, newBranch) Author: German Cocca <german.cocca@avature.net> Date: Fri Apr 1 18:48:20 2022 -0300 Added new file commit f15cf515dd3ec398210108dce092debf26ff9e12 Author: German Cocca <german.cocca@avature.net> ... 

• --help फ्लैग आपको दिए गए कमांड के बारे में जानकारी दिखाएगा, ठीक उसी तरह जैसे यह bash के साथ काम करता है।

git diff --help // output: GIT-DIFF(1) Git Manual GIT-DIFF(1) NAME git-diff - Show changes between commits, commit and working tree, etc SYNOPSIS git diff [options] [<commit>] [--] [<path>...] git diff [options] --cached [<commit>] [--] [<path>...] ... 

हमारी पहली स्क्रिप्ट

अब हम कमांड लाइन के वास्तव में मजेदार और शानदार हिस्से, स्क्रिप्टिंग के लिए तैयार हैं!

जैसा कि मैंने पहले उल्लेख किया है, एक स्क्रिप्ट कमांड या निर्देशों की एक श्रृंखला से ज्यादा कुछ नहीं है जिसे हम किसी भी समय निष्पादित कर सकते हैं। यह समझाने के लिए कि हम एक कैसे कोड कर सकते हैं, हम एक सरल उदाहरण का उपयोग करेंगे जो हमें एक ही कमांड चलाकर एक GitHub रेपो बनाने की अनुमति देगा। ;)

• पहली चीज जो करनी है वह है एक .sh फाइल बनाना। आप इसे जहां चाहें रख सकते हैं। मैंने अपने को newGhRepo.sh कहा।

• इसे अपनी पसंद के टेक्स्ट/कोड एडिटर पर खोलें।

• हमारी पहली पंक्ति पर, हम निम्नलिखित लिखेंगे: #! /bin/sh

इसे शेबैंग कहा जाता है, और इसका कार्य यह घोषित करना है कि कौन सा शेल इस स्क्रिप्ट को चलाने जा रहा है।

पहले जब हमने उल्लेख किया था कि हम सामान्य बातचीत के लिए एक दिए गए शेल का उपयोग कर सकते हैं और स्क्रिप्ट निष्पादित करने के लिए एक और दिए गए शेल का उपयोग कर सकते हैं? खैर, शेबैंग वह निर्देश है जो तय करता है कि कौन सा शेल स्क्रिप्ट चलाता है।

जैसा कि उल्लेख किया गया है, हम स्क्रिप्ट चलाने के लिए एक "स्ट्रिप्ड डाउन" शेल (जिसे sh शेल के रूप में भी जाना जाता है) का उपयोग कर रहे हैं क्योंकि वे अधिक कुशल हैं (हालांकि अंतर ध्यान देने योग्य नहीं हो सकता है, ईमानदारी से, यह सिर्फ एक व्यक्तिगत प्राथमिकता है)। मेरे कंप्यूटर में dash मेरा sh शेल है।

यदि हम चाहते थे कि यह स्क्रिप्ट bash के साथ चले तो शेबैंग #! /bin/bash होगा

• हमारी अगली पंक्ति होगी repoName=$1

यहां हम repoName नामक एक वेरिएबल घोषित कर रहे हैं, और इसे स्क्रिप्ट द्वारा प्राप्त पहले पैरामीटर के मान पर असाइन कर रहे हैं।

एक पैरामीटर वर्णों का एक समूह है जो स्क्रिप्ट/कमांड के बाद दर्ज किया जाता है। cd कमांड की तरह, हमें डायरेक्टरी बदलने के लिए एक डायरेक्टरी पैरामीटर निर्दिष्ट करने की आवश्यकता होती है (यानी: cd testFolder)।

स्क्रिप्ट के भीतर पैरामीटर की पहचान करने का एक तरीका डॉलर साइन और उस क्रम का उपयोग करना है जिसमें उस पैरामीटर की अपेक्षा की जाती है।

यदि मैं एक से अधिक पैरामीटर की अपेक्षा कर रहा हूं तो मैं लिख सकता हूं:

paramOne=$1 paramTwo=$2 paramThree=$3 ... 

• तो हम अपने स्क्रिप्ट के पैरामीटर के रूप में रिपॉजिटरी नाम की उम्मीद कर रहे हैं। लेकिन क्या होता है यदि उपयोगकर्ता इसे दर्ज करना भूल जाता है? हमें इसके लिए योजना बनाने की आवश्यकता है इसलिए अगला हम एक शर्त कोड करने जा रहे हैं जो उपयोगकर्ता से रेपो नाम दर्ज करने के लिए कहता रहता है जब तक कि वह पैरामीटर प्राप्त नहीं हो जाता।

हम इसे इस तरह कर सकते हैं:

while [ -z "$repoName" ] do echo 'Provide a repository name' read -r -p $'Repository name:' repoName done 

यहां हम क्या कर रहे हैं:

1. जब तक repoName वेरिएबल असाइन नहीं है (while [ -z "$repoName" ])
2. कंसोल पर यह संदेश लिखें (echo 'Provide a repository name')
3. फिर उपयोगकर्ता द्वारा प्रदान किए गए इनपुट को पढ़ें और इनपुट को repoName वेरिएबल पर असाइन करें (read -r -p $'Repository name:' repoName)

• अब जब हमारे पास हमारा रेपो नाम है, तो हम अपना स्थानीय Git रेपो इस तरह बना सकते हैं:

echo "# $repoName" >> README.md git init git add . git commit -m "First commit" 

यह एक रीडमी फाइल बना रहा है और रेपो नाम के साथ एक सिंगल लाइन लिख रहा है (echo "# $repoName" >> README.md) और फिर Git रेपो को इनिशियलाइज़ कर रहा है और पहला कमिट बना रहा है।

• फिर हमारे रेपो को GitHub पर अपलोड करने का समय है। ऐसा करने के लिए हम निम्नलिखित कमांड में GitHub API का लाभ उठाने जा रहे हैं:

curl -u coccagerman https://api.github.com/user/repos -d '{"name": "'"$repoName"'", "private":false}'

curl कई समर्थित प्रोटोकॉल में से एक का उपयोग करके सर्वर से या सर्वर पर डेटा ट्रांसफर करने का एक कमांड है।

अगला हम -u फ्लैग का उपयोग उस उपयोगकर्ता को घोषित करने के लिए कर रहे हैं जिसके लिए हम रेपो बना रहे हैं (-u coccagerman)।

अगला GitHub API द्वारा प्रदान किया गया एंडपॉइंट आता है (https://api.github.com/user/repos)

और अंत में हम इस कमांड को पैरामीटर पास करने के लिए -d फ्लैग का उपयोग कर रहे हैं। इस मामले में हम रिपॉजिटरी नाम बता रहे हैं (जिसके लिए हम अपने repoName वेरिएबल का उपयोग कर रहे हैं) और private विकल्प को false पर सेट कर रहे हैं, क्योंकि हम अपना रेपो पब्लिक चाहते हैं।

API में कई अन्य कॉन्फ़िगरेशन विकल्प उपलब्ध हैं, इसलिए अधिक जानकारी के लिए डॉक्स देखें।

• इस कमांड को चलाने के बाद, GitHub हमें प्रमाणीकरण के लिए अपना निजी टोकन दर्ज करने के लिए प्रेरित करेगा।

यदि आपके पास अभी तक निजी टोकन नहीं है, तो आप इसे GitHub में Settings > Developer settings > Personal access tokens में जनरेट कर सकते हैं

• कूल, हम लगभग हो गए! अब हमें अपने नए बने GitHub रेपो का रिमोट URL चाहिए।

इसे प्राप्त करने के लिए हम फिर से curl और GitHub API का उपयोग करने जा रहे हैं, जैसे:

GIT_URL=$(curl -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/coccagerman/"$repoName" | jq -r '.clone_url') 

यहां हम GIT_URL नामक एक वेरिएबल घोषित कर रहे हैं और इसे निम्नलिखित कमांड जो भी लौटाता है उस पर असाइन कर रहे हैं।

-H फ्लैग हमारे अनुरोध का हेडर सेट करता है।

फिर हम GitHub API एंडपॉइंट पास करते हैं, जिसमें हमारा उपयोगकर्ता नाम और रेपो नाम होना चाहिए (https://api.github.com/repos/coccagerman/"$repoName")।

फिर हम अपने अनुरोध के रिटर्न वैल्यू को पाइप कर रहे हैं। पाइपिंग का मतलब है एक प्रोसेस के रिटर्न वैल्यू को दूसरे प्रोसेस के इनपुट वैल्यू के रूप में पास करना। हम इसे | सिंबल के साथ कर सकते हैं जैसे <process1> | <process2>।

और अंत में हम jq कमांड चलाते हैं, जो JSON इनपुट प्रोसेस करने का एक टूल है। यहां हम इसे .clone_url का मान प्राप्त करने के लिए कहते हैं जो GitHub API द्वारा प्रदान किए गए डेटा फॉर्मेट के अनुसार हमारा रिमोट git URL होगा।

• और अंतिम चरण के रूप में, हम अपनी मास्टर ब्रांच का नाम main में बदलते हैं, हमारे द्वारा अभी प्राप्त रिमोट ओरिजिन को जोड़ते हैं, और अपना कोड GitHub पर पुश करते हैं! =D

git branch -M main git remote add origin $GIT_URL git push -u origin main 

हमारी पूरी स्क्रिप्ट कुछ इस तरह दिखनी चाहिए:

#! /bin/sh repoName=$1 while [ -z "$repoName" ] do echo 'Provide a repository name' read -r -p $'Repository name:' repoName done echo "# $repoName" >> README.md git init git add . git commit -m "First commit" curl -u <yourUserName> https://api.github.com/user/repos -d '{"name": "'"$repoName"'", "private":false}' GIT_URL=$(curl -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/<yourUserName>/"$repoName" | jq -r '.clone_url') git branch -M main git remote add origin $GIT_URL git push -u origin main 

• अब हमारे स्क्रिप्ट का परीक्षण करने का समय है! इसे निष्पादित करने के लिए दो चीजें हैं जो हम कर सकते हैं।

एक विकल्प है शेल नाम दर्ज करें और फाइल को पैरामीटर के रूप में पास करें, जैसे: dash ../ger/code/projects/scripts/newGhRepo.sh।

और दूसरा है chmod u+x ../ger/code/projects/scripts/newGhRepo.sh चलाकर फाइल को निष्पादन योग्य बनाना।

फिर आप फाइल को सीधे ../ger/code/projects/scripts/newGhRepo.sh चलाकर निष्पादित कर सकते हैं।

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

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

आइए Bash Aliases हमारी समस्या हल करने के लिए।

Aliases वे तरीके हैं जो Bash सटीक कमांड के लिए नाम बनाने के लिए प्रदान करता है जिन्हें हम चलाना चाहते हैं।

एक नया alias बनाने के लिए, हमें अपने सिस्टम में bash कॉन्फ़िगरेशन फाइलों को संपादित करने की आवश्यकता है। ये फाइलें सामान्य रूप से होम डायरेक्टरी में स्थित होती हैं। Aliases को अलग-अलग फाइलों में परिभाषित किया जा सकता है (मुख्य रूप से .bashrc या .bash_aliases)।

मेरे सिस्टम पर एक .bash_aliases फाइल है, तो आइए इसे संपादित करें।

• हमारे CLI में हम cd दर्ज करते हैं होम डायरेक्टरी पर जाने के लिए।

• फिर हम ls -a दर्ज कर सकते हैं सभी फाइलों को सूचीबद्ध करने के लिए (छिपी हुई सहित) और जांच सकते हैं कि क्या हमारे सिस्टम में .bashrc या .bash_aliases फाइल है।

• हम अपनी पसंद के टेक्स्ट/कोड एडिटर के साथ फाइल खोलते हैं।

• और हम अपना नया alias इस तरह लिखते हैं:
  alias newghrepo="dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh"

यहां मैं alias नाम घोषित कर रहा हूं, वास्तविक कमांड जिसे मैं स्क्रिप्ट चलाने के लिए दर्ज करने जा रहा हूं (newghrepo)।

और उद्धरणों के बीच, परिभाषित करें कि वह alias क्या करने जा रहा है ("dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh")

देखें कि मैं स्क्रिप्ट का निरपेक्ष पथ पास कर रहा हूं, ताकि यह कमांड मेरे वर्तमान डायरेक्टरी की परवाह किए बिना समान काम करे।

यदि आप नहीं जानते कि आपके स्क्रिप्ट का निरपेक्ष पथ क्या है, तो अपने टर्मिनल पर स्क्रिप्ट डायरेक्टरी पर जाएं और readlink -f newGhRepo.sh दर्ज करें। यह आपको पूरा पथ वापस कर देगा। ;)

• संपादन पूरा करने के बाद, हम अपनी फाइल सहेजते हैं, अपना टर्मिनल रीस्टार्ट करते हैं, और वोइला! अब हम बस newghrepo दर्ज करके अपना स्क्रिप्ट चला सकते हैं, चाहे हम वर्तमान में किसी भी डायरेक्टरी में हों। हमारे रेपो बनाने के लिए ब्राउज़र खोलने और चारों ओर क्लिक करने की तुलना में बहुत तेज़! =D

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

निष्कर्ष

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

यदि आप टर्मिनल और Bash के बारे में अधिक सीखने में रुचि रखते हैं, तो Zach Gollwitzer का यूट्यूब पर एक शानदार क्रैश कोर्स सीरीज है।
उनके पास Node और Javascript जैसे अन्य विषयों पर भी बेहतरीन ट्यूटोरियल हैं, इसलिए मैं सलाह देता हूं कि आप उनका अनुसरण करें। ;)

हमेशा की तरह, मुझे आशा है कि आपको लेख पसंद आया और आपने कुछ नया सीखा। यदि आप चाहें, तो आप LinkedIn या Twitter पर मेरा अनुसरण भी कर सकते हैं।

चीयर्स और अगले में मिलते हैं! =D