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

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

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

चलिए चलते हैं! =डी

सामग्री की तालिका

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

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

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

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

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

कंसोल:

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

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

टर्मिनल:

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

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

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

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

शैल:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

आखिरी कारण यह है कि यह अच्छा लग रहा है और यह मजेदार है। आप मूवी हैकर्स को अपने कंप्यूटर के आसपास क्लिक करते नहीं देखते हैं, है ना?;)

विभिन्न प्रकार के गोले

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

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

थोड़ा सा इतिहास - Posix

गोले के लिए, Posix . नामक एक सामान्य मानक है ।

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

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

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

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

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

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

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

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

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

तो सामान्य बातचीत के लिए बैश या ज़श जैसे इस "उन्नत" शेल का उपयोग करना और स्क्रिप्ट निष्पादित करने के लिए ऐश या डैश जैसे "स्ट्रिप्ड" शेल का उपयोग करना एक आम बात है।

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

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

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

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

कस्टमाइज़ेशन के बारे में एक टिप्पणी

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

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

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

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

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

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

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

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

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

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

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

echo Hello freeCodeCamp! // Output: Hello freeCodeCamp!

• पीडब्ल्यूडी प्रिंट कार्यशील निर्देशिका के लिए खड़ा है और यह उस "स्थान" या निर्देशिका को प्रिंट करता है जिस पर हम वर्तमान में कंप्यूटर में हैं।

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 Desktop . दर्ज कर सकता हूँ और यह मुझे डेस्कटॉप निर्देशिका में ले जाएगा।

अगर मैं एक निर्देशिका ऊपर जाना चाहता हूं, जिसका अर्थ है उस निर्देशिका में जाना जिसमें वर्तमान निर्देशिका है, मैं cd .. दर्ज कर सकता हूं

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

• एमकेडीआईआर निर्देशिका बनाने के लिए खड़ा है और यह आपके लिए एक नई निर्देशिका बनाएगा। आपको निर्देशिका नाम पैरामीटर कमांड पास करना होगा।

अगर मैं "टेस्ट" नामक एक नई निर्देशिका बनाना चाहता हूं तो मैं mkdir test enter दर्ज करूंगा ।

• आरएमडीआईआर निर्देशिका निकालें के लिए खड़ा है और यह बस यही करता है। इसे mkdir . की तरह ही निर्देशिका नाम पैरामीटर की आवश्यकता है :rmdir test ।

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

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

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

अगर मैं उसी निर्देशिका में अपनी txt फ़ाइल की प्रतिलिपि बनाना चाहता हूं, तो मैं निम्नलिखित दर्ज कर सकता हूं:

cp test.txt testCopy.txt

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

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

cp test.txt ./testFolder/

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

cp test.txt ./testFolder/testCopy.txt

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

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

mv test.txt ./testFolder/

यदि हम चाहें तो फ़ाइल का नाम भी उसी कमांड में बदल सकते हैं:

mv test.txt ./testFolder/testCopy.txt

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

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

• पूंछ वही काम करता है लेकिन यह आपको फ़ाइल का अंत दिखाएगा।

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.

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

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

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

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

    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 test.txt ।

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

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

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

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

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

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

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

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

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

• बाहर निकलें आपका टर्मिनल बंद कर देगा और (यह एक आदेश नहीं है लेकिन यह बहुत अच्छा भी है) ctrl+alt+t आपके लिए एक नया टर्मिनल खोलेगा।

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

• टैब . दबाकर आपके द्वारा अब तक लिखे गए पाठ के आधार पर आपको स्वतः पूर्णता प्राप्त होगी। टैब को दो बार hitting दबाकर आपके द्वारा अब तक लिखे गए पाठ के आधार पर आपको सुझाव प्राप्त होंगे।

उदाहरण के लिए यदि मैं edit test लिखता हूं और दो बार टैब करें , मुझे मिलता है testFolder/ test.txt . अगर मैं edit test. और टैब hit दबाएं मेरा टेक्स्ट edit test.txt के लिए स्वतः पूर्ण हो जाता है

गिट कमांड

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

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

• गिट इनिट आपके लिए एक नया स्थानीय भंडार तैयार करेगा।

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

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

• गिट कमिट रिपॉजिटरी में आपके परिवर्तन करता है। कमिट हमेशा -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  // output:
On branch master
nothing to commit, working tree clean

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

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.

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

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

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

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

git remote -v // output:
origin	https://github.com/coccagerman/testRepo.git (fetch)
origin	https://github.com/coccagerman/testRepo.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 <branch name> ।

git branch // output:
* main

• गिट चेकआउट आपको एक शाखा से दूसरी शाखा में ले जाता है। यह आपकी गंतव्य शाखा को पैरामीटर के रूप में लेता है।

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

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

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

git pull // output:
Already up to date.

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

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

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

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

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 // 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 ध्वज आपको किसी दिए गए आदेश के बारे में जानकारी दिखाएगा, ठीक उसी तरह जैसे यह बैश के साथ काम करता है।

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>...]
       ...

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

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

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

• सबसे पहले एक .sh बनाना है फ़ाइल। आप इसे जहां चाहें वहां लगा सकते हैं। मैंने अपना newGhRepo.sh . कॉल किया ।

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

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

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

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

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

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

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

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

एक पैरामीटर वर्णों का एक समूह है जो स्क्रिप्ट/कमांड के बाद दर्ज किया जाता है। जैसे 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. फिर उपयोगकर्ता जो भी इनपुट प्रदान करता है उसे पढ़ें और रेपोनाम वैरिएबल को इनपुट असाइन करें (read -r -p $'Repository name:' repoName )

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

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

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

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

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

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

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

इसके बाद GitHub API (https://api.github.com/user/repos द्वारा प्रदान किया गया समापन बिंदु आता है। )

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

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

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

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

• बढ़िया, अब हमारा काम लगभग पूरा हो चुका है! अब हमें जो चाहिए वह है दूरस्थ URL हमारे नए बनाए गए GitHub रेपो का।

इसे प्राप्त करने के लिए हम फिर से कर्ल और गिटहब एपीआई का उपयोग इस तरह करने जा रहे हैं:

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

Here we're declaring a variable called GIT_URL and assigning it to whatever the following command returns.

The -H flag sets the header of our request.

Then we pass the GitHub API endpoint, which should contain our user name and repo name (https://api.github.com/repos/coccagerman/"$repoName" ).

Then we're piping the return value of our request. Piping just means passing the return value of a process as the input value of another process. We can do it with the | symbol like <process1> | <process2> ।

And finally we run the jq command, which is a tool for processing JSON inputs. Here we tell it to get the value of .clone_url which is where our remote git URL will be according to the data format provided by the GitHub API.

• And as last step, we rename our master branch to main, add the remote origin we just obtained, and push our code to GitHub! =D

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

Our full script should look something like this:

#! /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

• Now it's time to test our script! To execute it there're two things we can do.

One option is to enter the shell name and pass the file as parameter, like:dash ../ger/code/projects/scripts/newGhRepo.sh ।

And the other is to make the file executable by running chmod u+x ../ger/code/projects/scripts/newGhRepo.sh ।

Then you can just execute the file directly by running ../ger/code/projects/scripts/newGhRepo.sh ।

और बस! We have our script up and running. Everytime we need a new repo we can just execute this script from whatever directory we're in.

But there's something a bit annoying about this. We need to remember the exact route of the script directory. Wouldn't it be cool to execute the script with a single command that it's always the same independently of what directory we're at?

In come bash aliases to solve our problem.

Aliases are a way bash provides for making names for exact commands we want to run.

To create a new alias, we need to edit the bash configuration files in our system. This files are normally located in the home directory. Aliases can be defined in different files (mainly .bashrc or .bash_aliases ).

I have a .bash_aliases file on my system, so let's edit that.

• In our CLI we enter cd to go over home directory.

• Then we can enter ls -a to list all files (includen hidden ones) and check if we have either a .bashrc or .bash_aliases file in our system.

• We open the file with our text/code editor of choice.

• And we write our new alias like this:
  alias newghrepo="dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh"

Here I'm declaring the alias name, the actual command I'm going to enter to run the script (newghrepo ).

And between quotes, define what that alias is going to do ("dash /home/German/Desktop/ger/code/projects/scripts/newGhRepo.sh" )

See that I'm passing the absolute path of the script, so that this command works the same no matter what my current directory is.

If you don't know what the absolute path of your script is, go to the script directory on your terminal and enter readlink -f newGhRepo.sh . That should return the full path for you.;)

• After we're done editing, we save our file, restart our terminal, and voilà! Now we can run our script by just entering newghrepo , no matter in what directory we currently are. Much quicker than opening the browser and clicking around to create our repo! =D

I hope this gives you a little taste of the kind of optimizations that are possible with scripting. It certainly requires a bit more work the first time you write, test, and set up the script. But after that, you'll never have to perform that task manually again.;)

Round up

The terminal can feel like an intimidating and intricate place when you're starting out. But it's certainly worth it to put time and effort into learning the ins and outs of it. The efficiency benefits are too good to pass up!

If you're interested in learning more about the terminal and Bash, Zach Gollwitzer has an awesome crash course series on youtube.
He has also great tutorials on other topics such as Node and Javascript, so I recommend that you follow him.;)

As always, I hope you enjoyed the article and learned something new. If you want, you can also follow me on linkedin or twitter.

Cheers and see you in the next one! =D