🧑🏻 🤦 🐾 गीता का उन्नत उपयोग या छह महीने पहले रिटायर कैसे करें? 🧑🏿‍🤝‍🧑🏽 🚉 🥛

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

जब मैंने दस-ऊँगली छापने की विधि पर भरोसा करना शुरू किया, तो मैंने बहुत सारी नसें खर्च कीं। अंत में, यह आपके व्यक्तिगत वर्कफ़्लो में सुधार करने का सबसे अच्छा निर्णय था। अगले सबसे महत्वपूर्ण अनुकूलन में गीता का उन्नत विकास है।

गीता के बारे में कई लेख हैबर पर लिखे गए हैं, लेकिन वे आधिकारिक दस्तावेज़ीकरण से परे नहीं हैं, और लेखकों ने स्व-निर्मित बैसाखी के साथ काम को आसान बनाने का प्रस्ताव दिया है। मुझे यकीन है कि कार्यों के ठोस उदाहरणों पर गीत का अध्ययन करना आवश्यक है, और मानकीकृत साधनों का उपयोग करके इसके साथ काम करने की दक्षता में वृद्धि करना है।

इस लेख से किसे लाभ होगा?

क्या आपने पहले ही सज्जन के गीता के सेट में महारत हासिल कर ली है और क्या आप आगे बढ़ने के लिए तैयार हैं? 2 तरीके हैं:

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

लेख में वर्णित प्रयोगों के लिए आज कुछ घंटे समर्पित करें, और छह महीने के कामकाजी जीवन की अनुमानित गणना से बचाएं।

बिल्ली के लिए आपका स्वागत है!

ट्रेनिंग

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

यह ध्यान रखना बहुत महत्वपूर्ण है कि Zsh लिनक्स के लिए है , और मैक के लिए , और यहां तक कि विंडोज के लिए भी।

Zsh और Oh My Zsh स्थापित करें

एक आदेश के निर्देशों के अनुसार Zsh और Oh My Zsh स्थापित करें:

 # macOS brew install zsh zsh-completions && sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)" # Ubuntu, Debian, ... apt install zsh && sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

चूंकि कार्य गीत के साथ सहभागिता को अनुकूलित करना है, इसलिए हम Zsh में प्लग-इन की एक जोड़ी जोड़ Zsh । ~/.zshrc खोलें और सूची में plugins जोड़ें:

 plugins=(git gitfast)

कुल:

git - उपनाम और सहायक कार्यों का एक सेट;
gitfast - गीता के लिए बढ़ाया गया ऑटो-पूर्ण।

tig सेटिंग

और अंतिम स्पर्श tig कंसोल उपयोगिता की स्थापना है:

 # macOS brew install tig # Ubuntu, Debian, ... # https://jonas.imtqy.com/tig/INSTALL.html

हम इसके बारे में आगे बात करेंगे।

अभ्यास में जुट जाएं

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

पीले खंड खंड से समस्या को हल करने के लिए मुख्य उपनाम का संकेत देते हैं। केवल इसे जानें, और सामान्य विकास के लिए बाकी सब कुछ छोड़ दें।

कार्यशील निर्देशिका की स्थिति की जाँच करें

सबसे बुनियादी चीज़ से शुरू करते हैं। हमने थोड़ा काम किया और अब देखते हैं कि वर्किंग डायरेक्टरी में क्या होता है:

 $ git status On branch master Changes to be committed: (use "git reset HEAD <file>..." to unstage) new file: e.md Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git checkout -- <file>..." to discard changes in working directory) modified: b.md Untracked files: (use "git add <file>..." to include in what will be committed) d.md

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

 $ git status -sb ## master M b.md A e.md ?? d.md

हाँ, हम master शाखा में हैं, b.md ( M-odified ) फ़ाइल को बदल दिया है और दो फ़ाइलों को बनाया है, पहले को गीता सूचकांक ( A-dded ) में A-dded , और दूसरा इंडेक्स ( ?? ) को छोड़ कर। छोटा और स्पष्ट।

यह इस कमांड के अंतहीन इनपुट को उर्फ " g it tatus with b ranch" द्वारा ऑप्टिमाइज़ करने के लिए बना हुआ है:

छोटी कार्यशील निर्देशिका स्थिति दिखाएं
 $ gsb # git status -sb 

एक कमिट बनाएँ

हम जारी रखते हैं।

बेशक, आप कमिट कर सकते हैं। लेकिन आइए इस सरल कार्य के समाधान को अनुकूलित करने का प्रयास करें। अनुक्रमणिका के सभी परिवर्तनों को उपनाम " g d d a a ll" के साथ जोड़ें :

 $ gaa # git add --all

हम जाँचते हैं कि इंडेक्स को वास्तव में उर्फ " g it if d if ca ched" का उपयोग करने की आवश्यकता है

 $ gdca # git diff --cached diff --git a/b.md b/b.md index 698d533..cf20072 100644 --- a/b.md +++ b/b.md @@ -1,3 +1,3 @@ # Beta -Next step. +Next step really hard. diff --git a/d.md b/d.md new file mode 100644 index 0000000..9e3752e --- /dev/null +++ b/d.md @@ -0,0 +1,3 @@ +# Delta + +Body of article.

हम्म, एक एकल कार्य को हल करने वाले परिवर्तन एक प्रतिबद्ध में गिरना चाहिए। यहां, दोनों फ़ाइलों के परिवर्तन किसी भी तरह से जुड़े नहीं हैं। आइए उपनाम के साथ d.md फ़ाइल को उपनाम " g r r eset u ndo" से बाहर करें :

 $ gru d.md # git reset -- d.md

और उर्फ " जी इट सी ओमिट" के साथ एक कमिट बनाएँ:

 $ gc # git commit

हम कमिट का नाम लिखते हैं और सेव करते हैं। और फिर हम उपनाम के d.md फ़ाइल d.md और परिचित कमांड d.md हैं, d.md उपनाम " g it c ommit m e s sa g e" :

 $ gaa #    $ gcmsg "Add new file" # git commit -m "Add new file"

और हम कर सकते हैं ...

... एक कमांड के साथ इंडेक्स से संशोधित फाइल करें:

 $ gcam "Add changes" # git commit -a -m "Add changes"

... लाइनों के बजाय शब्दों द्वारा परिवर्तन देखें (पाठ के साथ काम करते समय बहुत उपयोगी):

 $ gdw # git diff --word-diff

... फ़ाइलों को भागों में जोड़ें (बहुत उपयोगी है जब आपको फ़ाइल से परिवर्तनों के केवल भाग के लिए प्रतिबद्ध करने की आवश्यकता होती है):

 $ gapa # git add --patch

... केवल गीता की देखरेख में पहले से ही फाइलों में सूचकांक जोड़ें:

 $ gau # git add --update

कुल:

इंडेक्स / क्रिएट कमिट में जोड़ें
 $ ga # git add $ gc # git commit 

ठीक करना

अंतिम प्रतिबद्ध का नाम हमारे द्वारा किए गए परिवर्तनों की व्याख्या नहीं करता है। चलो सुधार करें:

 $ gc! # git commit -v --amend

और खुलने वाले पाठ संपादक में, हम इसे और अधिक स्पष्ट रूप से कहेंगे: "Add Delta article" । मुझे यकीन है कि आप कभी भी -v स्विच का उपयोग नहीं करते हैं, हालांकि कमिट का विवरण संपादित करते समय, यह किए गए सभी परिवर्तनों को दिखाता है, जो बेहतर नेविगेट करने में मदद करता है।

और हम कर सकते हैं ...

... कमिट में फाइल में बदलाव करें, लेकिन विवरण को न छुएं:

 $ gcn! # git commit -v --no-edit --amend

... सभी फ़ाइल परिवर्तन तुरंत कमिट में करें, पहले इंडेक्स में जोड़े बिना:

 $ gca! # git commit -v -a --amend

... दो पिछले आदेशों को संयोजित करें:

 $ gcan! # git commit -v -a --no-edit --amend

खैर, एक बार फिर ध्यान देना जरूरी है कि पूरी तरह से नियमित रूप से इस्तेमाल किए जाने वाले git commit -v --amend , हम तीन बार लिखते हैं:

अंतिम प्रतिबद्ध बदलें
 $ gc! # git commit -v --amend 

एक नई सुविधा पर आरंभ करना

वर्तमान उपनाम से एक नई शाखा बनाएं "इसे ग हेकआउट बी रेंच" :

 $ gcb erlang # git checkout --branch erlang

यद्यपि नहीं, एलिक्सिर उर्फ " जी इट बी रंच विथ द कीव एम " (गीता में नाम परिवर्तन के माध्यम से किया जाता है) के बारे में अधिक आधुनिक भाषा के बारे में एक लेख लिखना बेहतर है:

 $ gb -m elixir # git branch -m elixir

उर्फ gbmv का उपयोग करना तर्कसंगत होगा, लेकिन, दुर्भाग्य से, अभी तक इसका आविष्कार नहीं हुआ है। एक योगदान के लिए एक अच्छा विकल्प।

हम भंडार में परिवर्तन करते हैं और एक प्रतिबद्ध बनाते हैं, जैसा कि हम पहले से ही जानते हैं:

 $ echo "#  —     ." > e.md $ gaa && gcmsg "Add article about Elixir"

और याद रखें:

एक नई शाखा बनाएँ
 $ gcb # git checkout --branch 

मर्ज में बदलाव

अब हम अमृत के बारे में अपने नए लेख को जोड़ते हैं। सबसे पहले, मुख्य शाखा के साथ उपनाम " g it c heckout m aster" :

 $ gcm # git checkout master

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

 $ gm elixir # git merge elixir

उफ़, लेकिन कोई पहले से ही master परिवर्तन करने में कामयाब रहा। और सुंदर रैखिक इतिहास के बजाय जो हमारी परियोजना में अपनाया गया था, मैंने बनाया ~~नफरत~~ मर्ज करना।

शाखाओं को मिलाएं
 $ gm # git merge 

अंतिम प्रतिबद्ध हटाएं

चिंता की कोई बात नहीं! आपको बस अंतिम प्रतिबद्ध को हटाने और परिवर्तनों को फिर से मर्ज करने की कोशिश करनी चाहिए " g r r eset hh ard" :

अंतिम प्रतिबद्ध हटाएं
 $ grhh HEAD~ # git reset --hard HEAD~ 

हम संघर्षों का समाधान करते हैं

मानक checkout – rebase – merge एक रेखीय परिवर्तन इतिहास तैयार करने के लिए checkout – rebase – merge अनुक्रम उपनामों के निम्नलिखित अनुक्रम द्वारा किया जाता है:

 gco elixir # git checkout elixir grbm # git rebase master gcm # git checkout master gm elixir # git merge elixir

उन सभी को अक्सर इस्तेमाल किया जाता है कि वे पहले से ही उंगलियों से दूर उड़ रहे हैं, और इस तरह के ऑपरेशन करते समय, यह सोचने की ज़रूरत नहीं है कि अक्षरों के किस सेट को टाइप करना है। और यह मत भूलो कि Zsh आप Tab कुंजी के साथ शाखाओं के नामों को पूरक कर सकते हैं।

एक रिबेस करें
 $ grb # git rebase 

सर्वर में परिवर्तन सबमिट करना

पहले हम उर्फ " g it r emote a dd" के origin जोड़ते origin :

 $ gra origin git@github.com/... # git remote add origin git@github.com/...

और फिर हम रिपॉजिटरी की वर्तमान शाखा में सीधे परिवर्तन भेजते हैं ( "जीजी" - कमांड की शुरुआत में दोगुना g वर्तमान शाखा में कार्रवाई के निष्पादन को इंगित करता है):

 $ ggpush # git push origin git_current_branch

आप भी कर सकते हैं ...

... सर्वर के परिवर्तनों को upstream इंस्टॉलेशन के साथ " g it p p us s et up stream" उपनाम:

 $ gpsup # git push --set-upstream origin $(git_current_branch)

सर्वर में परिवर्तन सबमिट करें
 $ gp # git push 

हमें सर्वर से परिवर्तन प्राप्त होते हैं

काम जोरों पर है। हम master करने के लिए एक नया लेख f.md जोड़ने में कामयाब रहे, और हमारे सहयोगियों ने लेख a.md बदल दिया और इस परिवर्तन को सर्वर पर भेज दिया। इस स्थिति को भी बहुत सरलता से हल किया जाता है:

 $ gup # git pull --rebase

फिर आप सर्वर में सुरक्षित रूप से परिवर्तन भेज सकते हैं। संघर्ष सुलझा हुआ है।

सर्वर से परिवर्तन प्राप्त करें
 $ gl # git pull 

विलीन शाखाओं को हटा दें

इसलिए, हमने पिछले उदाहरण से elixir शाखा सहित कई शाखाओं को सफलतापूर्वक master में मिला दिया। हमें अब उनकी आवश्यकता नहीं है आप उर्फ " g it b ranch d elete a nother" को हटा सकते हैं:

 $ gbda # git branch --no-color --merged | command grep -vE "^(\*|\s*(master|develop|dev)\s*$)" | command xargs -n 1 git branch -d

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

एक अस्थायी प्रतिबद्ध बनाएँ

हास्केल के बारे में नए h.md लेख पर काम जोरों पर है। आधा लिखित और आपको एक सहयोगी से प्रतिक्रिया प्राप्त करने की आवश्यकता है। दो बार सोचने के बिना, हम उपनाम " g it w ork i n p rogress" टाइप करते हैं :

 $ gwip # git add -A; git rm $(git ls-files --deleted) 2> /dev/null; git commit --no-verify -m "--wip-- [skip ci]"

और फिर एक Work in Progress के नाम से बनाई गई है, Work in Progress को सीआई को छोड़ देना और "अतिरिक्त" फ़ाइलों को हटाना। हम शाखा को सर्वर पर भेजते हैं, इस सहयोगी के बारे में बात करते हैं और समीक्षा की प्रतीक्षा करते हैं।

फिर यह वचन पूर्ववत किया जा सकता है और फाइलें अपने मूल स्थिति में लौट आई हैं:

 $ gunwip # git log -n 1 | grep -q -c "\-\-wip\-\-" && git reset HEAD~1

और यह देखने के लिए कि क्या आपकी शाखा में WIP कमिट हैं, कमांड का उपयोग करें:

 $ work_in_progress

जब आपको पड़ोसी शाखा में जाने की आवश्यकता होती है, तो gwip कमांड gwip का काफी विश्वसनीय एनालॉग होता है। लेकिन Zsh में खुद को stash लिए कई उपनाम हैं।

अस्थायी कमेट / अस्थायी कमेट जोड़ें
 $ gwip $ gunwip 

परिवर्तन छिपा रहा है

इस कमांड से आपको सावधान रहने की जरूरत है। फ़ाइलों को छिपाया जा सकता है, और फिर एक लापरवाह कार्रवाई के साथ पूरी तरह से हटा दिया जाता है, क्योंकि वहाँ एक reflog है जिसमें आप खोए हुए काम को खोजने की कोशिश कर सकते हैं।

चलिए हम उन फाइलों को छिपाते हैं जिन पर हम काम कर रहे हैं, यह एक राख के रूप में है :

 $ gsta # git stash save

और फिर उन्हें उर्फ " g it st ash p op" के साथ वापस लौटाएं:

 $ gstp # git stash pop

या सुरक्षित " जी यह एक एश pply होगा" विधि :

 $ gstaa # git stash apply

आप भी कर सकते हैं ...

... देखते हैं कि वास्तव में हम क्या छिपाते हैं:

 gsts # git stash show --text

... संबंधित आदेशों के लिए संक्षिप्तिकरण का उपयोग करें:

 gstc # git stash clear gstd # git stash drop gstl # git stash list

परिवर्तन / परिवर्तन बदलें
 $ gsta $ gstaa 

बग की तलाश है

git-bisect टूल, जिसने बार-बार मेरी जान बचाई है, के पास अपने स्वयं के उपनाम भी हैं। हम "बाइनरी एरर सर्च" प्रक्रिया को " g it b s ect s tart" उपनाम से शुरू करते हैं :

 $ gbss # git bisect start

हम ध्यान दें कि, शाखा में अंतिम, कमिटमेंट में एक त्रुटि है, जिसमें उपनाम " g it b s ect2 ad" है ।

 $ gbsb # git bisect bad

अब हम उस कमिट को चिन्हित करते हैं जो हमें एप्लिकेशन के संचालन की स्थिति की गारंटी देता है " g it b s ect ect ood"

 $ gbsg HEAD~20 # git bisect good HEAD~20

और अब यह गीता के शब्द gbsb या gbsg के साथ उत्तर देना जारी gbsg , और अपराधी को खोजने के बाद, प्रक्रिया को रीसेट करें:

 $ gbsr # git bisect reset

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

त्रुटि खोज

 $ gbss # git bisect start $ gbsb # git bisect bad $ gbsg # git bisect good $ gbsr # git bisect reset

हम अधर्म के उकसाने वाले की तलाश कर रहे हैं

यहां तक कि परीक्षणों के साथ कोड कवरेज के उच्च प्रतिशत के साथ, कोई भी ऐसी स्थिति से प्रतिरक्षा नहीं करता है जहां एप्लिकेशन क्रैश हो जाता है और कृपया एक त्रुटि के साथ एक विशिष्ट लाइन को इंगित करता है। या, उदाहरण के लिए, हमारे मामले में, हम यह पता लगाना चाहते हैं कि a.md फाइल की दूसरी पंक्ति में a.md गलती की। ऐसा करने के लिए, कमांड चलाएँ:

 $ gbl a.md -L 2 # git blame -b -w a.md -L 2

आप देखते हैं, Oh My Zsh योगदानकर्ताओं ने न केवल git blame टीम के लिए एक उर्फ बनाया, बल्कि इसमें चाबियाँ जोड़ Oh My Zsh जो Oh My Zsh को ढूंढना आसान बनाती हैं।

बोनस

कमिट की सूची देखें

कमिट की सूची देखने के लिए, अतिरिक्त आउटपुट स्वरूपण कुंजी के साथ git log कमांड का उपयोग करें। आमतौर पर यह कमांड, चाबियों के साथ, गीता के कस्टम उपनामों में दर्ज किया जाता है। हम अधिक भाग्यशाली हैं, हमारे पास पहले से ही एक तैयार किए गए उर्फ बॉक्स से बाहर है: glog । और यदि आपने लेख की शुरुआत से सलाह पर tig यूटिलिटी स्थापित की है, तो आप एक पूर्ण चैंपियन हैं।

अब, कंसोल में कमिट्स के इतिहास को बहुत सुविधाजनक तरीके से जानने के लिए, आपको शब्द के विपरीत टाइप करना होगा:

 $ tig

उपयोगिता कुछ उपयोगी जोड़ भी प्रदान करती है जो गीता बॉक्स से बाहर नहीं हैं।

सबसे पहले, एक कहानी की सामग्री के माध्यम से खोज करने के लिए एक कमांड:

 $ tig grep

दूसरे, अपने इतिहास के साथ सभी स्रोतों, शाखाओं, टैगों की सूची देखना:

 $ tig refs

तीसरा, शायद आपको अपने लिए कुछ दिलचस्प मिलेगा:

 $ tig --help

अकस्मात बनाया गया `git reset --hard`

आपने पूरे दिन elixir शाखा में काम किया:

 $ glog * 17cb385 (HEAD -> elixir) Refine Elixir article * c14b4dc Add article about Elixir * db84d54 (master) Initial commit

और अंत में, उन्होंने गलती से सब कुछ हटा दिया:

 $ grhh HEAD~2 HEAD is now at db84d54 Initial commit

घबराने की जरूरत नहीं। सबसे महत्वपूर्ण नियम गीता और साँस छोड़ते में किसी भी आदेश को निष्पादित करना बंद करना है । स्थानीय रिपॉजिटरी के साथ सभी क्रियाएं एक विशेष लॉग - reflog में दर्ज की जाती हैं। इससे, आप वांछित कमिट का हैश प्राप्त कर सकते हैं और इसे काम करने वाले पेड़ पर पुनर्स्थापित कर सकते हैं।

चलो रिफ्लग को देखते हैं, लेकिन सामान्य तरीके से git reflog माध्यम से नहीं, बल्कि एक विस्तृत प्रतिलेख के साथ और अधिक दिलचस्प है:

 $ glg -g

वांछित 17cb385 के हैश का पता लगाएं और इसे पुनर्स्थापित करें:

 #           $ gcb elixir-recover 17cb385 #    $ gbd elixir #     $ gb -m elixir

संयोग से, मैंने एक नई प्रतिबद्धता बनाने के बजाय, पिछले एक में बदलाव किए

यहां हम फिर से बचाव सहायता में आए। हम मूल 17cb385 कमिट का हैश पाते हैं, अगर हम तुरंत ही इस कमिट को रद्द कर देते हैं, तो हैश की तलाश करने के बजाय, हम इसे त्वरित लिंक का उपयोग कर सकते हैं HEAD@{1} । अगला हम एक नरम रीसेट करते हैं, जबकि सूचकांक रीसेट नहीं होता है:

 #      $ grh --soft HEAD@{1} # git reset -soft #   $ gcmsg "Commit description"

शाखा बहुत पुरानी है

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

आइए elixir नामक एक सुविधा शाखा का एक उदाहरण देखें:

 #   master $ gcm # git checkout master #        $ gcb elixir-new # git checkout --branch elixir-new #           $ gcp elixir@{0} # git cherry-pick elixir@{0}

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

रिपॉजिटरी से महत्वपूर्ण डेटा हटाना

रिपॉजिटरी से महत्वपूर्ण डेटा को हटाने के लिए, मैंने निम्नलिखित स्निपेट को सहेजा है:

 $ git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch <path-to-your-file>' --prune-empty --tag-name-filter cat -- --all && git push origin --force --all

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

पिछली शाखा का जिक्र

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

 $ gco - # git checkout - $ gm - # git merge - $ grb - # git rebase -

`.gitignore` रूप में चिह्नित सभी फ़ाइलों को हटाएँ

किसी अन्य अवांछित फ़ाइल या निर्देशिका को .gitignore जोड़ने के लिए एक और सामान्य झटका बहुत देर हो चुकी है। रिपॉजिटरी से उन्हें साफ करने के लिए ( और उन्हें डिस्क से हटा दें ), git clean लिए पहले से तैयार चाबियां हैं।

 $ gclean -X # git clean -Xfd

सावधान!

सही तरीके से आगे पढ़ें।

कई टीमों को `--dry-run` स्विच की आवश्यकता क्यों है?

अनइंस्टॉल और अपडेट करते समय --dry-run एहतियात के तौर पर बस जरूरत होती है। उदाहरण के लिए, पिछले अनुभाग में वर्णित सभी चीजों को हटाने का तरीका बताया गया है। यह बेहतर है कि सावधान रहें और --dry-run स्विच का उपयोग करें, हटाए जाने वाली सभी फ़ाइलों --dry-run सूची देखें, और उसके बाद ही --dry-run बिना कमांड --dry-run ।

निष्कर्ष

लेख प्रोग्रामर के काम को अनुकूलित करने के लिए एक बिंदु दिखाता है। याद रखें 10-20 mnemonic संक्षिप्तीकरण मुश्किल नहीं है, मूल टीम को भूल जाना लगभग असंभव है। उपनामों को मानकीकृत किया जाता है, इसलिए जब आप पूरी टीम को Zsh + Oh My Zsh स्विच करते हैं, तो आप जोड़ी प्रोग्रामिंग के साथ भी समान गति और आराम से काम कर सकते हैं।

आगे कहाँ जाना है?

मैं निम्नलिखित विकल्प प्रदान करता हूं:

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

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

मुझे आशा है कि सामग्री उपयोगी हो गई है, और आप अपने लिए कुछ नया सीख सकते हैं। या शायद वे पहले से ही एक नए दृष्टिकोण को सक्रिय रूप से पेश करना शुरू कर चुके हैं। सौभाग्य है

गीता का उन्नत उपयोग या छह महीने पहले रिटायर कैसे करें?