ਇਹ ਪੋਸਟ ਗਿੱਟ ਚੀਟ ਸ਼ੀਟ ਹੈ ਜੋ ਕਿ ਆਮ ਤੌਰ ਤੇ ਆਮ ਤੌਰ ਤੇ ਗਿੱਟ ਕਮਾਂਡਾਂ ਦੇ ਨਾਲ ਹੈ ਜੋ ਤੁਸੀਂ ਰੋਜ਼ਾਨਾ ਦੇ ਅਧਾਰ ਤੇ ਵਰਤੋਗੇ.
ਜੇ ਤੁਸੀਂ ਡਿਵੈਲਪਰਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਵਾਲੇ ਤਕਨੀਕੀ ਟੈਸਟਰ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਬੁਨਿਆਦੀ ਗੀਟ ਕਮਾਂਡਾਂ ਤੋਂ ਜਾਣੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ.
ਇਸ ਅਹੁਦੇ 'ਤੇ ਤੁਹਾਨੂੰ ਇਕ ਕਯੂਏ ਦੇ ਤੌਰ' ਤੇ ਦਿਨ-ਬ-ਦਿਨ ਜਾਣ ਦੀ ਪ੍ਰੇਰਣਾ ਲਈ ਕਾਫ਼ੀ ਗਿੱਟ ਗਿਆਨ ਹੈ.
ਜੇ ਤੁਸੀਂ ਆਪਣੀ ਮਸ਼ੀਨ ਤੇ ਗਿੱਟ ਸਥਾਪਤ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਅੰਦਰ ਪਗਾਂ ਦੀ ਪਾਲਣਾ ਕਰ ਸਕਦੇ ਹੋ ਮੈਕ ਉੱਤੇ ਗਿੱਟ ਕਿਵੇਂ ਸਥਾਪਿਤ ਕਰਨਾ ਹੈ ਅਤੇ ਐਸਐਸਐਚ ਕੁੰਜੀਆਂ ਕਿਵੇਂ ਤਿਆਰ ਕਰਨਾ ਹੈ .
ਇੱਕ ਖਾਲੀ ਗਿੱਟ ਰੈਪੋ ਬਣਾਓ ਜਾਂ ਮੌਜੂਦਾ ਨੂੰ ਦੁਬਾਰਾ ਅਰੰਭ ਕਰੋ
$ git init
Foo ਰੇਪੋ ਨੂੰ ਇੱਕ ਨਵੀਂ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਕਲੋਨ ਕਰੋ ਜਿਸ ਨੂੰ foo ਕਹਿੰਦੇ ਹਨ:
$ git clone https://github.com//foo.git foo
ਜਦੋਂ ਤੁਸੀਂ ਇਕ ਨਵੀਂ ਵਿਸ਼ੇਸ਼ਤਾ 'ਤੇ ਕੰਮ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਆਮ ਤੌਰ' ਤੇ ਗੀਟ ਵਿਚ ਇਕ ਨਵੀਂ ਸ਼ਾਖਾ ਬਣਾਉਂਦੇ ਹੋ. ਜਿਵੇਂ ਕਿ, ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਮਾਸਟਰ ਬ੍ਰਾਂਚ ਤੋਂ ਬਾਹਰ ਰਹਿਣਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਆਪਣੀ ਖੁਦ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਾਲੀਆਂ ਬ੍ਰਾਂਚਾਂ' ਤੇ ਕੰਮ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਜੋ ਮਾਸਟਰ ਹਮੇਸ਼ਾਂ ਸਾਫ ਹੋਵੇ ਅਤੇ ਤੁਸੀਂ ਇਸ ਤੋਂ ਨਵੀਂ ਸ਼ਾਖਾਵਾਂ ਬਣਾ ਸਕੋ.
ਇੱਕ ਨਵੀਂ ਬ੍ਰਾਂਚ ਬਣਾਉਣ ਲਈ:
$ git checkout -b
ਜੇ ਤੁਸੀਂ ਇਹ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਤੁਹਾਡੀ ਕਾਰਜਕਾਰੀ ਡਾਇਰੈਕਟਰੀ ਵਿਚ ਕਿਹੜੀਆਂ ਸ਼ਾਖਾਵਾਂ ਉਪਲਬਧ ਹਨ, ਤਾਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ:
$ git branch
ਉਦਾਹਰਨ ਆਉਟਪੁੱਟ:
develop my_feature master
ਜਦੋਂ ਤੁਸੀਂ ਨਵੀਂ ਸ਼ਾਖਾ ਬਣਾਉਂਦੇ ਹੋ ਤਾਂ ਗੀਟ ਆਪਣੇ ਆਪ ਨਵੀਂ ਸ਼ਾਖਾ ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ.
ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਬਹੁਤ ਸਾਰੀਆਂ ਸ਼ਾਖਾਵਾਂ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਗਿੱਟ ਚੈਕਆਉਟ ਵਾਲੀਆਂ ਸ਼ਾਖਾਵਾਂ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹੋ:
$ git checkout master $ git checkout develop $ git checkout my_feature
ਸਥਾਨਕ ਸ਼ਾਖਾ ਨੂੰ ਮਿਟਾਉਣ ਲਈ:
$ git branch -d
| _ _ _ _ | ਵਰਤੋ ਇਸ ਨੂੰ ਦਬਾਉਣ ਲਈ ਚੋਣ ਫਲੈਗ.
ਮੂਲ ਤੇ ਇੱਕ ਰਿਮੋਟ ਸ਼ਾਖਾ ਨੂੰ ਮਿਟਾਉਣ ਲਈ:
-D
ਸੰਬੰਧਿਤ:
ਨੂੰ ਸਟੇਜ ਇੱਕ ਫਾਈਲ ਸਿਰਫ ਇਸ ਨੂੰ ਇਕ ਵਚਨਬੱਧਤਾ ਲਈ ਤਿਆਰ ਕਰਨ ਲਈ ਹੈ. ਜਦੋਂ ਤੁਸੀਂ ਕੁਝ ਫਾਈਲਾਂ ਨੂੰ ਜੋੜਦੇ ਜਾਂ ਸੰਸ਼ੋਧਿਤ ਕਰਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ 'ਸਟੇਜਿੰਗ ਏਰੀਆ' ਵਿੱਚ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ. ਇੱਕ ਬਕਸੇ ਦੇ ਰੂਪ ਵਿੱਚ ਮੰਚਨ ਬਾਰੇ ਸੋਚੋ ਜਿੱਥੇ ਤੁਸੀਂ ਚੀਜ਼ਾਂ ਨੂੰ ਆਪਣੇ ਬਿਸਤਰੇ ਦੇ ਹੇਠਾਂ ਹਿੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਪਾਉਂਦੇ ਹੋ, ਜਿੱਥੇ ਤੁਹਾਡਾ ਪਲੰਘ ਉਸ ਬਕਸੇ ਦਾ ਭੰਡਾਰ ਹੈ ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਪਹਿਲਾਂ ਬੰਦ ਕਰ ਦਿੱਤਾ ਹੈ.
ਫਾਈਲਾਂ ਨੂੰ ਸਟੇਜ ਜਾਂ ਬਸ ਸ਼ਾਮਲ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ git ਐਡ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਤੁਸੀਂ ਵਿਅਕਤੀਗਤ ਫਾਈਲਾਂ ਨੂੰ ਸਟੇਜ ਕਰ ਸਕਦੇ ਹੋ:
$ git push origin :
ਜਾਂ ਇਕੋ ਸਮੇਂ ਸਾਰੀਆਂ ਫਾਈਲਾਂ:
$ git add foo.js
ਜੇ ਤੁਸੀਂ ਸਟੇਜ ਤੋਂ ਕੋਈ ਖਾਸ ਫਾਈਲ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ:
$ git add .
ਜਾਂ ਸਾਰੀਆਂ ਸਟੇਜਡ ਫਾਈਲਾਂ ਨੂੰ ਹਟਾਓ:
$ git reset HEAD foo.js
ਤੁਸੀਂ ਕਮਾਂਡ ਲਈ ਉਪ-ਨਾਮ ਵੀ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਫਿਰ ਇਸਨੂੰ Git ਨਾਲ ਵਰਤ ਸਕਦੇ ਹੋ:
$ git reset HEAD .
ਜੇ ਤੁਸੀਂ ਇਹ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕਿਹੜੀਆਂ ਫਾਈਲਾਂ ਬਣਾਈਆਂ ਗਈਆਂ ਹਨ, ਸੋਧੀਆਂ ਗਈਆਂ ਹਨ ਜਾਂ ਮਿਟਾ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ, ਤਾਂ ਗੀਟ ਸਥਿਤੀ ਤੁਹਾਨੂੰ ਇੱਕ ਰਿਪੋਰਟ ਦਿਖਾਏਗੀ.
$ git config --global alias.unstage 'reset HEAD' $ git unstage .
ਅਕਸਰ ਵਚਨਬੱਧ ਹੋਣਾ ਇਕ ਚੰਗਾ ਅਭਿਆਸ ਹੈ. ਤੁਸੀਂ ਹਮੇਸ਼ਾਂ ਧੱਕਣ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣੀਆਂ ਕਮੀਆਂ ਨੂੰ ਘਟਾ ਸਕਦੇ ਹੋ. ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਉਨ੍ਹਾਂ ਨੂੰ ਸਟੇਜ ਲਗਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ.
ਕਮਾਂਡ ਕਮਾਂਡ ਨੂੰ ਇੱਕ -m ਵਿਕਲਪ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੋ ਪ੍ਰਤੀਬੱਧਤਾ ਸੰਦੇਸ਼ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ.
ਤੁਸੀਂ ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ:
$ git status
ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਤੁਹਾਡੀ ਸਭ ਤੋਂ ਤਾਜ਼ੀ ਪ੍ਰਤੀਬੱਧਤਾ ਨੂੰ ਵਾਪਸ ਲਵੇਗੀ ਅਤੇ ਉਹਨਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਵਾਪਸ ਸਟੇਜਿੰਗ ਵਿੱਚ ਪਾ ਦੇਵੇਗੀ, ਇਸਲਈ ਤੁਸੀਂ ਕੋਈ ਵੀ ਕੰਮ ਨਹੀਂ ਗੁਆਓਗੇ:
$ git commit -m 'Updated README'
ਪ੍ਰਤੀਬੱਧਤਾ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਮਿਟਾਉਣ ਅਤੇ ਕਿਸੇ ਤਬਦੀਲੀਆਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਸੁੱਟਣ ਲਈ:
$ git reset --soft HEAD~1
ਦੱਸ ਦੇਈਏ ਕਿ ਤੁਹਾਡੇ ਕੋਲ 4 ਕਮਿਟ ਹਨ, ਪਰ ਤੁਸੀਂ ਅਜੇ ਤੱਕ ਕੁਝ ਨਹੀਂ ਧੱਕਿਆ ਅਤੇ ਤੁਸੀਂ ਸਭ ਕੁਝ ਇਕ ਵਚਨਬੱਧਤਾ ਵਿੱਚ ਪਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹੋ:
$ git reset --hard HEAD~1
| $ git rebase -i HEAD~4
ਆਖਰੀ ਚਾਰ ਕਮੀਆਂ ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ.
| HEAD~4
ਵਿਕਲਪ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਟੈਕਸਟ ਫਾਈਲ ਖੋਲ੍ਹਦਾ ਹੈ.
ਤੁਸੀਂ ਹਰ ਇਕ ਵਚਨਬੱਧਤਾ ਦੇ ਖੱਬੇ ਪਾਸੇ ਸ਼ਬਦ 'ਚੁਣੋ' ਵੇਖੋਗੇ. ਇਕੱਲੇ ਨੂੰ ਸਿਖਰ ਤੇ ਛੱਡੋ ਅਤੇ ਹੋਰਨਾਂ ਨੂੰ ਸਕੁਐਸ਼ ਲਈ “s” ਨਾਲ ਤਬਦੀਲ ਕਰੋ, ਫਾਈਲ ਨੂੰ ਸੇਵ ਅਤੇ ਬੰਦ ਕਰੋ.
ਫਿਰ ਇਕ ਹੋਰ ਇੰਟਰੈਕਟਿਵ ਵਿੰਡੋ ਖੁੱਲ੍ਹਦੀ ਹੈ ਜਿਥੇ ਤੁਸੀਂ ਆਪਣੇ ਪ੍ਰਤੀਬੱਧ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਇਕ ਨਵੇਂ ਪ੍ਰਤੀਬੱਧ ਸੰਦੇਸ਼ ਵਿਚ ਅਪਡੇਟ ਕਰ ਸਕਦੇ ਹੋ.
ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਗਲਾ ਰਿਮੋਟ ਰਿਪੋਜ਼ਟਰੀ ਵੱਲ ਧੱਕਣਾ ਹੈ.
ਸਥਾਨਕ ਸ਼ਾਖਾ ਨੂੰ ਪਹਿਲੀ ਵਾਰ ਧੱਕੋ:
-i
ਉਸ ਤੋਂ ਬਾਅਦ, ਫਿਰ ਤੁਸੀਂ ਬਸ ਵਰਤ ਸਕਦੇ ਹੋ
$ git push --set-upstream origin
ਸਥਾਨਕ ਸ਼ਾਖਾ ਨੂੰ ਵੱਖਰੀ ਰਿਮੋਟ ਸ਼ਾਖਾ ਵੱਲ ਧੱਕਣ ਲਈ, ਤੁਸੀਂ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹੋ:
$ git push
ਜੇ ਤੁਹਾਨੂੰ ਆਪਣਾ ਆਖਰੀ ਧੱਕਾ ਵਾਪਸ ਕਰਨਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:
$ git push origin :
ਜਦੋਂ ਤੁਸੀਂ | _ _ _ _ | ਵਰਤਦੇ ਹੋ, ਤਾਂ Git ਉਹਨਾਂ ਨੂੰ ਆਪਣੀ ਮੌਜੂਦਾ ਬ੍ਰਾਂਚ ਨਾਲ ਹੋਰ ਨਹੀਂ ਜੋੜਦਾ. ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਫਾਇਦੇਮੰਦ ਹੈ ਜੇ ਤੁਹਾਨੂੰ ਆਪਣੀ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਅਪ ਟੂ ਡੇਟ ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਪਰ ਕੁਝ ਅਜਿਹਾ ਕਰ ਰਹੇ ਹੋ ਜੋ ਤੋੜ ਸਕਦੀ ਹੈ ਜੇ ਤੁਸੀਂ ਆਪਣੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਅਪਡੇਟ ਕਰਦੇ ਹੋ.
ਕਮਿਟ ਨੂੰ ਆਪਣੀ ਮਾਸਟਰ ਬ੍ਰਾਂਚ ਵਿੱਚ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਲਈ, ਤੁਸੀਂ | _ _ _ _ | ਵਰਤੋ.
$ git reset --hard HEAD~1 && git push -f origin master
ਖਿੱਚਣਾ ਅਜੇ ਵੀ ਇੱਕ ਅਭਿਆਸ ਕਰ ਰਿਹਾ ਹੈ ਜਿਸ ਦੇ ਬਾਅਦ ਅਭੇਦ ਹੋਣਾ ਹੈ. ਜਦੋਂ ਤੁਸੀਂ | _ _ _ _ | ਵਰਤਦੇ ਹੋ, ਤਾਂ ਗਿੱਟ ਆਪਣੇ ਆਪ ਦੂਸਰੇ ਕਮਿੱਟਾਂ ਨੂੰ ਮਿਲਾ ਦਿੰਦਾ ਹੈ ਬਿਨਾਂ ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਉਹਨਾਂ ਦੀ ਸਮੀਖਿਆ ਕੀਤੇ. ਜੇ ਤੁਸੀਂ ਆਪਣੀਆਂ ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਨੇੜਿਓਂ ਪ੍ਰਬੰਧਿਤ ਨਹੀਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਅਕਸਰ ਵਿਵਾਦਾਂ ਵਿੱਚ ਪੈ ਸਕਦੇ ਹੋ.
ਜੇ ਤੁਹਾਡੀ ਬ੍ਰਾਂਚ ਹੈ | _ _ _ _ | ਅਤੇ ਤੁਸੀਂ ਉਸ ਸ਼ਾਖਾ ਨੂੰ ਖਿੱਚਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹੋ:
git fetch
ਜਾਂ, ਜੇ ਤੁਸੀਂ ਸਭ ਕੁਝ ਅਤੇ ਹੋਰ ਸਾਰੀਆਂ ਸ਼ਾਖਾਵਾਂ ਨੂੰ ਖਿੱਚਣਾ ਚਾਹੁੰਦੇ ਹੋ
merge
ਜਦੋਂ ਤੁਸੀਂ ਚਲਾਉਂਦੇ ਹੋ | _ _ _ _ |, ਤੁਹਾਡੀ ਹੈਡ ਸ਼ਾਖਾ ਇੱਕ ਤਿਆਰ ਕਰੇਗੀ ਨਵੀਂ ਵਚਨਬੱਧਤਾ , ਹਰੇਕ ਪ੍ਰਤੀਬੱਧ ਇਤਿਹਾਸ ਦੇ ਵੰਸ਼ਜ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ.
The ਓਵਰਸ਼ੂਟ ਇੱਕ ਸ਼ਾਖਾ ਦੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਦੂਜੀ ਤੇ ਲਿਖਦਾ ਹੈ ਬਿਨਾ ਇੱਕ ਨਵੀਂ ਵਚਨਬੱਧਤਾ ਪੈਦਾ ਕਰਨਾ.
$ git fetch upstream
ਜਾਂ ਰੀਬੇਸ ਵਿਕਲਪ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ:
git pull
my_feature
ਕਈ ਵਾਰ ਤੁਸੀਂ ਸ਼ਾਖਾ 'ਤੇ ਬਦਲਾਅ ਕਰਦੇ ਹੋ, ਅਤੇ ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ ਬ੍ਰਾਂਚ ਵਿੱਚ ਜਾਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਪਰ ਤੁਸੀਂ ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਨਹੀਂ ਗੁਆਉਣਾ ਚਾਹੁੰਦੇ.
ਤੁਸੀਂ ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਛੁਪਾ ਸਕਦੇ ਹੋ. ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਗੀਟ ਵਿਚ ਕਿਵੇਂ ਰੁਕਦੇ ਹੋ:
$ git pull origin/my_feature
ਹੁਣ, ਜੇ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਤਿਆਗਣਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਵਾਪਸ ਆਪਣੀ ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ:
$ git pull