ਤੁਹਾਡੀਆਂ ਆਖਰੀ ਐਨ ਗਿੱਟ ਕਮਿਟਾਂ ਨੂੰ ਕਿਵੇਂ ਜੋੜਿਆ ਜਾਵੇ

ਗਿੱਟ ਵਿੱਚ ਮਾਸਟਰਿੰਗ ਕਮਿਟ ਸਕੁਐਸ਼ਿੰਗ:

ਕਿਸੇ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਡਾ ਵਚਨਬੱਧ ਇਤਿਹਾਸ ਬਹੁਤ ਸਾਰੀਆਂ ਛੋਟੀਆਂ ਕਮਿਟਾਂ ਨਾਲ ਬੇਤਰਤੀਬ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਮਾਮੂਲੀ ਕਮਿਟ ਤਬਦੀਲੀਆਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨਾ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਇਤਿਹਾਸ ਨੂੰ ਸਮਝਣਾ ਮੁਸ਼ਕਲ ਬਣਾ ਸਕਦੇ ਹਨ।

ਗਿੱਟ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਕਲੀਨਰ ਅਤੇ ਵਧੇਰੇ ਪ੍ਰਬੰਧਨਯੋਗ ਇਤਿਹਾਸ ਬਣਾ ਕੇ, ਆਪਣੇ ਆਖਰੀ N ਕਮਿਟਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਕਮਿਟ ਵਿੱਚ ਸਕਵੈਸ਼ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਗਾਈਡ ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕਦਮਾਂ 'ਤੇ ਲੈ ਕੇ ਜਾਵੇਗੀ, ਤੁਹਾਡੇ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲ ਬਣਾਉਂਦਾ ਹੈ।

ਹੁਕਮ	ਵਰਣਨ
git rebase -i HEAD~N	ਆਖਰੀ N ਕਮਿਟਾਂ ਦਾ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਰੀਬੇਸ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।
pick	ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਰੀਬੇਸ ਦੇ ਦੌਰਾਨ ਇੱਕ ਵਚਨਬੱਧਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦਾ ਹੈ।
squash	ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਰੀਬੇਸ ਦੌਰਾਨ ਪਿਛਲੇ ਇੱਕ ਨਾਲ ਇੱਕ ਵਚਨਬੱਧਤਾ ਨੂੰ ਜੋੜਦਾ ਹੈ।
sed -i '1!s/pick/squash/' .git/rebase-merge/git-rebase-todo	ਰੀਬੇਸ ਟੂਡੋ ਸੂਚੀ ਵਿੱਚ ਪਹਿਲੀ ਪ੍ਰਤੀਬੱਧਤਾ ਤੋਂ ਇਲਾਵਾ ਸਭ ਲਈ 'ਪਿਕ' ਨੂੰ 'ਸਕੁਐਸ਼' ਨਾਲ ਆਟੋਮੈਟਿਕਲੀ ਬਦਲਦਾ ਹੈ।
git rebase --continue	ਵਿਵਾਦਾਂ ਨੂੰ ਸੁਲਝਾਉਣ ਤੋਂ ਬਾਅਦ ਰੀਬੇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਜਾਰੀ ਰੱਖਦਾ ਹੈ।
git rebase --abort	ਰੀਬੇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਅਧੂਰਾ ਛੱਡਦਾ ਹੈ ਅਤੇ ਰੀਬੇਸ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਰਾਜ ਵਿੱਚ ਵਾਪਸ ਆਉਂਦਾ ਹੈ।
HEAD~N	ਮੌਜੂਦਾ HEAD ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਤੀਬੱਧ N ਸਥਾਨਾਂ ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ।

ਗਿੱਟ ਕਮਿਟ ਸਕੁਐਸ਼ਿੰਗ ਨੂੰ ਸਮਝਣਾ

ਪਹਿਲੀ ਸਕਰਿਪਟ ਵਰਤਦਾ ਹੈ ਆਖਰੀ N ਕਮਿਟਾਂ ਦੀ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਰੀਬੇਸ ਸ਼ੁਰੂ ਕਰਨ ਲਈ। ਇੰਟਰਐਕਟਿਵ ਸਕ੍ਰੀਨ ਵਿੱਚ, ਤੁਸੀਂ ਉਹਨਾਂ ਕਮਿਟਾਂ ਲਈ 'ਪਿਕ' ਨੂੰ 'ਸਕੁਐਸ਼' ਨਾਲ ਬਦਲਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਇਹ ਪ੍ਰਕਿਰਿਆ ਬਹੁਤ ਸਾਰੀਆਂ ਛੋਟੀਆਂ ਕਮਿਟਾਂ ਨੂੰ ਇੱਕ ਵਿੱਚ ਜੋੜਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ, ਤੁਹਾਡੇ ਵਚਨਬੱਧ ਇਤਿਹਾਸ ਨੂੰ ਸਾਫ਼ ਅਤੇ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ। ਸੰਪਾਦਨ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਸੰਪਾਦਕ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ ਅਤੇ ਬੰਦ ਕਰੋ। ਜੇ ਕੋਈ ਵਿਵਾਦ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਹੱਲ ਕਰੋ ਅਤੇ ਜਾਰੀ ਰੱਖੋ .

ਦੂਜੀ ਸਕ੍ਰਿਪਟ ਇੱਕ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਸਕੁਐਸ਼ਿੰਗ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਦੀ ਹੈ। ਇਹ ਜਾਂਚ ਕਰਕੇ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਕਿ ਕੀ ਕਈ ਕਮਿਟ (N) ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ। ਫਿਰ, ਇਹ ਚੱਲਦਾ ਹੈ ਅਤੇ ਵਰਤਦਾ ਹੈ ਰੀਬੇਸ ਟੂਡੋ ਸੂਚੀ ਵਿੱਚ ਪਹਿਲੀ ਕਮਿਟ ਨੂੰ ਛੱਡ ਕੇ ਸਾਰਿਆਂ ਲਈ 'ਪਿਕ' ਨੂੰ 'ਸਕੁਐਸ਼' ਨਾਲ ਬਦਲਣਾ। ਇਹ ਫਾਈਲ ਨੂੰ ਦਸਤੀ ਸੰਪਾਦਿਤ ਕੀਤੇ ਬਿਨਾਂ ਮਲਟੀਪਲ ਕਮਿਟਾਂ ਨੂੰ ਸਕਵੈਸ਼ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਸ ਨਾਲ ਰੀਬੇਸ ਪ੍ਰਕਿਰਿਆ ਜਾਰੀ ਰਹਿੰਦੀ ਹੈ , ਕਿਸੇ ਵੀ ਜ਼ਰੂਰੀ ਵਿਵਾਦ ਦੇ ਹੱਲ ਨੂੰ ਆਪਣੇ ਆਪ ਹੀ ਸੰਭਾਲਣਾ।

git rebase -i HEAD~N
# Replace N with the number of commits you want to squash
# In the interactive rebase screen that appears, change 'pick' to 'squash' (or 's') for the commits you want to squash
# Save and close the editor
# Edit the commit message if needed, then save and close the editor again
# If there are conflicts, resolve them and then run
git rebase --continue
# Your last N commits are now squashed into one commit

#!/bin/bash
if [ -z "$1" ]
then
  echo "Usage: ./squash_commits.sh <N>"
  exit 1
fi
git rebase -i HEAD~$1
# Automatically replace 'pick' with 'squash' for all but the first commit
sed -i '1!s/pick/squash/' .git/rebase-merge/git-rebase-todo
git rebase --continue

ਐਡਵਾਂਸਡ ਗਿੱਟ ਸਕੁਐਸ਼ਿੰਗ ਤਕਨੀਕਾਂ

ਗਿੱਟ ਵਿੱਚ ਸਕੁਐਸ਼ਿੰਗ ਕਮਿਟ ਦਾ ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਅਭੇਦ ਵਿਵਾਦਾਂ ਨੂੰ ਸੰਭਾਲ ਰਿਹਾ ਹੈ ਜੋ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਪੈਦਾ ਹੋ ਸਕਦੇ ਹਨ। ਮਲਟੀਪਲ ਕਮਿਟਾਂ ਨੂੰ ਜੋੜਦੇ ਸਮੇਂ, ਵੱਖ-ਵੱਖ ਕਮਿਟਾਂ ਤੋਂ ਬਦਲਾਵ ਇੱਕ ਦੂਜੇ ਨਾਲ ਟਕਰਾ ਸਕਦੇ ਹਨ। ਇਹਨਾਂ ਵਿਵਾਦਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, Git ਕਮਾਂਡਾਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇਹ ਵੇਖਣ ਲਈ ਕਿ ਕਿਹੜੀਆਂ ਫਾਈਲਾਂ ਵਿਵਾਦ ਵਿੱਚ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਹੱਲ ਕੀਤੇ ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕਰਨ ਲਈ। ਵਿਵਾਦਾਂ ਨੂੰ ਸੁਲਝਾਉਣ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਇਸ ਨਾਲ ਰੀਬੇਸ ਜਾਰੀ ਰੱਖਦੇ ਹੋ .

ਇਹ ਜਾਣਨਾ ਵੀ ਲਾਭਦਾਇਕ ਹੈ ਕਿ ਜੇਕਰ ਚੀਜ਼ਾਂ ਗਲਤ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਤਾਂ ਰੀਬੇਸ ਨੂੰ ਕਿਵੇਂ ਅਧੂਰਾ ਛੱਡਣਾ ਹੈ। ਹੁਕਮ ਰੀਬੇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੋਕਦਾ ਹੈ ਅਤੇ ਰੀਬੇਸ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਤੁਹਾਡੀ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਇਸਦੀ ਪਿਛਲੀ ਸਥਿਤੀ ਵਿੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਰੀਬੇਸ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਕੀਤੇ ਗਏ ਕਿਸੇ ਵੀ ਬਦਲਾਅ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਵਾਪਸ ਕਰ ਸਕਦੇ ਹੋ। ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਨੂੰ ਸਮਝਣ ਨਾਲ ਗੁੰਝਲਦਾਰ ਗਿੱਟ ਇਤਿਹਾਸਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਦੀ ਤੁਹਾਡੀ ਯੋਗਤਾ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਸੁਧਾਰ ਹੋ ਸਕਦਾ ਹੈ।

1. ਸਕੁਐਸ਼ਿੰਗ ਕਮਿਟ ਦਾ ਕੀ ਮਤਲਬ ਹੈ?
2. ਸਕੁਐਸ਼ਿੰਗ ਕਮਿਟਸ ਦਾ ਮਤਲਬ ਹੈ ਵਚਨਬੱਧ ਇਤਿਹਾਸ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ ਕਈ ਕਮਿਟਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਕਮਿਟ ਵਿੱਚ ਜੋੜਨਾ।
3. ਮੈਨੂੰ ਸਕੁਐਸ਼ ਕਮਿਟ ਕਿਉਂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?
4. ਸਕੁਐਸ਼ਿੰਗ ਕਮਿਟ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਇਤਿਹਾਸ ਨੂੰ ਸਾਫ਼-ਸੁਥਰਾ ਅਤੇ ਪੜ੍ਹਨ ਵਿੱਚ ਆਸਾਨ ਬਣਾ ਸਕਦੇ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਬਹੁਤ ਸਾਰੀਆਂ ਛੋਟੀਆਂ ਕਮਿਟਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
5. ਮੈਂ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਰੀਬੇਸ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕਰਾਂ?
6. ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰੋ , N ਨੂੰ ਉਹਨਾਂ ਕਮਿਟਾਂ ਦੀ ਸੰਖਿਆ ਨਾਲ ਬਦਲਣਾ ਜੋ ਤੁਸੀਂ ਸਕੁਐਸ਼ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ।
7. ਇੰਟਰਐਕਟਿਵ ਰੀਬੇਸ ਵਿੱਚ 'ਪਿਕ' ਅਤੇ 'ਸਕੁਐਸ਼' ਦਾ ਕੀ ਅਰਥ ਹੈ?
8. 'ਚੁਣੋ' ਇੱਕ ਵਚਨਬੱਧਤਾ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਰੱਖਦਾ ਹੈ, ਜਦੋਂ ਕਿ 'ਸਕੁਐਸ਼' ਇਸਨੂੰ ਪਿਛਲੀ ਪ੍ਰਤੀਬੱਧਤਾ ਨਾਲ ਜੋੜਦਾ ਹੈ।
9. ਮੈਂ ਇੱਕ ਰੀਬੇਸ ਦੌਰਾਨ ਵਿਵਾਦਾਂ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕਰਾਂ?
10. ਵਰਤੋ ਵਿਵਾਦਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ, ਉਹਨਾਂ ਨੂੰ ਹੱਥੀਂ ਹੱਲ ਕਰੋ, ਫਿਰ ਵਰਤੋਂ ਅਤੇ .
11. ਜੇਕਰ ਕੁਝ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕੀ ਮੈਂ ਰੀਬੇਸ ਨੂੰ ਅਧੂਰਾ ਛੱਡ ਸਕਦਾ ਹਾਂ?
12. ਹਾਂ, ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ ਰੀਬੇਸ ਨੂੰ ਰੋਕਣ ਅਤੇ ਪਿਛਲੀ ਸਥਿਤੀ 'ਤੇ ਵਾਪਸ ਜਾਣ ਲਈ।
13. ਸਕੁਐਸ਼ਿੰਗ ਕਮਿਟ ਲਈ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਕੀ ਫਾਇਦਾ ਹੈ?
14. ਇੱਕ Bash ਸਕ੍ਰਿਪਟ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਦੀ ਹੈ, ਸਮਾਂ ਬਚਾਉਂਦੀ ਹੈ ਅਤੇ ਦਸਤੀ ਗਲਤੀਆਂ ਦੇ ਜੋਖਮ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ।
15. ਕੀ ਰੀਬੇਸ ਵਿੱਚ ਆਟੋਮੈਟਿਕਲੀ ਸਕੁਐਸ਼ ਕਰਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਹੈ?
16. ਹਾਂ, ਰੀਬੇਸ ਟੂਡੋ ਸੂਚੀ ਨੂੰ ਸੋਧਣ ਲਈ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ , ਤੁਸੀਂ ਆਪਣੇ ਆਪ 'ਚੁਣੋ' ਨੂੰ 'ਸਕੁਐਸ਼' ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ।

ਗਿੱਟ ਕਮਿਟ ਸਕੁਐਸ਼ਿੰਗ ਨੂੰ ਸਮੇਟਣਾ

Git ਵਿੱਚ ਸਕੁਐਸ਼ਿੰਗ ਕਮਿਟ ਇੱਕ ਸਾਫ਼ ਅਤੇ ਪੜ੍ਹਨਯੋਗ ਪ੍ਰੋਜੈਕਟ ਇਤਿਹਾਸ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਤਕਨੀਕ ਹੈ। ਭਾਵੇਂ ਇੰਟਰਐਕਟਿਵ ਰੀਬੇਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੋਵੇ ਜਾਂ Bash ਸਕ੍ਰਿਪਟ ਨਾਲ ਆਟੋਮੈਟਿਕ, ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ ਵਿੱਚ ਕਈ ਕਮਿਟਾਂ ਨੂੰ ਜੋੜ ਸਕਦੇ ਹੋ, ਜਿਸ ਨਾਲ ਲੌਗ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਆਸਾਨ ਹੋ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਮਝਣਾ ਕਿ ਵਿਵਾਦਾਂ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕਰਨਾ ਹੈ ਅਤੇ ਇੱਕ ਰੀਬੇਸ ਨੂੰ ਕਿਵੇਂ ਛੱਡਣਾ ਹੈ, ਤੁਹਾਡੀ ਗਿੱਟ ਮੁਹਾਰਤ ਵਿੱਚ ਵਾਧਾ ਕਰਦਾ ਹੈ, ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋਏ ਕਿ ਤੁਸੀਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਮੁੱਦੇ ਨੂੰ ਸੰਭਾਲ ਸਕਦੇ ਹੋ। ਇਹਨਾਂ ਕਮਾਂਡਾਂ ਅਤੇ ਵਿਧੀਆਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਨਾਲ ਤੁਹਾਡੇ ਸੰਸਕਰਣ ਨਿਯੰਤਰਣ ਅਭਿਆਸਾਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਸੁਧਾਰ ਹੋਵੇਗਾ।