git add மற்றும் git commit: மாற்றங்களை சரியாகச் சேமிப்பது எப்படி

Git-இல் "சேமி" பொத்தான் இல்லை. மாற்றங்கள் இரண்டு படிகளில் பதிவாகின்றன: முதலில் git add அடுத்த நிலைப்படத்தில் எந்தத் திருத்தங்கள் சேரும் என்பதைத் தேர்ந்தெடுக்கிறது, பின்னர் git commit அந்த நிலைப்படத்தை வரலாற்றில் பதிவு செய்கிறது. இவற்றுக்கு இடையிலான இடைநிலை மண்டலம் index, அல்லது staging area என்று அழைக்கப்படுகிறது. பலர் பல ஆண்டுகளாக இதைப் புரிந்துகொள்வதில்லை — ஆனால் commit-களை அர்த்தமுள்ளதாக்குவது இதுவே.

கோப்பின் மூன்று நிலைகள்: வேலை அடைவு, index, வரலாறு

எந்த மாற்றமும் மூன்று பகுதிகள் வழியாகச் செல்கிறது:

1. வேலை அடைவு (working directory) — எடிட்டரில் கோப்பைத் திருத்துகிறீர்கள்.
2. Index (stage) — git add கோப்பின் நடப்புப் பதிப்பை அடுத்த commit-இன் வரைவில் வைக்கிறது.
3. வரலாறு — git commit index-இன் உள்ளடக்கத்தை ஆசிரியர், தேதி, செய்தியுடன் ஒரு commit ஆக மாற்றுகிறது.

இதற்கு ஒரு எளிய உவமை — பார்சல். வேலை அடைவு பொருட்கள் உள்ள அறை, index என்பது நீங்கள் அனுப்ப விரும்புவதை வைக்கும் திறந்த பெட்டி, commit என்பது மூடி கையொப்பமிட்ட பார்சல். பெட்டியில் எதை வைப்பது என்பதை நீங்களே தீர்மானிக்கிறீர்கள்; எல்லாவற்றையும் ஒரே நேரத்தில் அனுப்ப வேண்டிய அவசியம் இல்லை.

Index ஏன் தேவை

கற்பனை செய்யுங்கள்: ஒரு மணி நேரத்தில் அங்கீகாரத்தில் உள்ள பிழையைச் சரிசெய்தீர்கள், README-இல் ஒரு எழுத்துப் பிழையையும் திருத்தினீர்கள், பிறகு புதிய அம்சத்தைத் தொடங்கினீர்கள். Index இல்லாவிட்டால் இவை அனைத்தும் "பலவற்றில்" என்ற ஒரே commit-இல் சேரும். Index இருந்தால் மூன்று தனித்தனி commit-கள் உருவாக்குகிறீர்கள்; ஒவ்வொன்றையும் புரிந்துகொள்ளவும், மதிப்பாய்வு செய்யவும், தேவைப்பட்டால் மற்றவற்றைப் பாதிக்காமல் திரும்பப் பெறவும் எளிதாக இருக்கும்.

git status: எது மாறியது, எது தயாராக உள்ளது

ஒவ்வொரு add மற்றும் commit-க்கு முன் git status பார்ப்பது பயனுள்ளது. இது Git-இன் மிகப் பாதுகாப்பான கட்டளை — எதையும் மாற்றாது.

$ git status
On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   src/auth.js

Changes not staged for commit:
  (use "git add <file>..." to include in what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        src/profile.js

• Changes to be committed — ஏற்கனவே index-இல் உள்ளது, commit-இல் சேரும்;
• Changes not staged — மாற்றப்பட்டுள்ளது, ஆனால் சேர்க்கப்படவில்லை;
• Untracked files — Git இன்னும் அறியாத புதிய கோப்புகள்.

கோப்புகள் அதிகமாக இருக்கும்போது குறுகிய வடிவம் வசதியானது:

$ git status -s
M  src/auth.js
 M README.md
?? src/profile.js

முதல் நிரை index-இல் உள்ள நிலை, இரண்டாவது வேலை அடைவில் உள்ள நிலை. இடதுபுறம் M என்றால் "மாற்றப்பட்டு சேர்க்கப்பட்டது", வலதுபுறம் M என்றால் "மாற்றப்பட்டது, சேர்க்கப்படவில்லை", ?? — கண்காணிக்கப்படாதது.

git add: index-இல் மாற்றங்களைச் சேர்ப்பது

git add-இன் ஒத்த சொல் git stage: அது அதே கட்டளை, அதனால்தான் "stage", "stage செய்வது" என்ற சொற்கள் வழங்குகின்றன.

git add -p: கோப்பின் ஒரு பகுதியைச் சேர்ப்பது

அதிகம் கவனிக்கப்படாத வழி. ஒரே கோப்பில் இரண்டு வெவ்வேறு திருத்தங்கள் கலந்திருந்தால், git add -p ஒவ்வொரு பகுதியையும் காட்டி சேர்க்கலாமா என்று கேட்கும்:

$ git add -p src/auth.js
@@ -12,7 +12,7 @@ function login(user) {
-  if (user.password = input) {
+  if (user.password === input) {
(1/2) Stage this hunk [y,n,q,a,d,s,e,?]?

y — சேர், n — தவிர், s — பகுதியை இன்னும் சிறியதாகப் பிரி, q — வெளியேறு. இதனால் ஒரே கோப்பிலிருந்து இரண்டு நேர்த்தியான commit-கள் கிடைக்கும்.

commit-இல் என்ன போகும் என்று சரிபார்ப்பது

git diff            # index-இல் இன்னும் சேர்க்கப்படாத மாற்றங்கள்
git diff --staged   # ஏற்கனவே index-இல் உள்ளவை, commit-இல் சேரும்

அடிக்கடி ஏற்படும் குழப்பம்: git add-க்குப் பிறகு சாதாரண git diff எதுவும் காட்டாது. அதற்கு அர்த்தம் மாற்றங்கள் மறைந்துவிட்டன என்பதல்ல — அவை index-இல் உள்ளன; git diff --staged (அதே பொருள் தரும் --cached) பாருங்கள்.

கோப்பை index-இலிருந்து நீக்குவது

git restore --staged file.js

இதனால் கோப்பின் திருத்தங்கள் அப்படியே இருக்கும்; அது commit-க்குத் தயாரான நிலையிலிருந்து மட்டும் விலகும். பழைய Git பதிப்புகளில் இதற்கு git reset HEAD file.js பயன்படுத்தப்பட்டது — இன்றும் வேலை செய்கிறது.

git commit: மாற்றங்களைப் பதிவு செய்வது

git commit -m "Исправить проверку пароля при входе"

[main 3f2a9c1] Исправить проверку пароля при входе
 1 file changed, 1 insertion(+), 1 deletion(-)

பதிலில் கிளை, புதிய commit-இன் குறுகிய hash மற்றும் புள்ளிவிவரம் காட்டப்படும். Commit-இல் index-இன் உள்ளடக்கம் மட்டுமே செல்லும். git add-க்குப் பிறகு கோப்பை மீண்டும் திருத்தினால், நீங்கள் மீண்டும் சேர்க்கும் வரை புதிய திருத்தங்கள் commit-இல் சேராது.

git commit-இன் பயனுள்ள விருப்பங்கள்

இயல்பு எடிட்டர் Vim ஆக இருந்து அதில் சிக்கிவிட்டால்: செய்தியை எழுதி, Esc அழுத்தி, :wq தட்டச்சு செய்து Enter. எடிட்டரை மாற்ற: git config --global core.editor "code --wait" அல்லது nano.

நல்ல commit செய்தியை எழுதுவது எப்படி

ஆறு மாதங்களுக்குப் பிறகு பிழை எங்கிருந்து வந்தது என்று தேடும்போது அந்தச் செய்தியைத்தான் படிப்பீர்கள். அது "இன்று நான் என்ன செய்தேன்" என்பதற்குப் பதில் அல்ல, "என்ன, ஏன்" என்பதற்குப் பதில் சொல்ல வேண்டும்.

• முதல் வரி — 50–72 எழுத்துகள் வரை, மாற்றத்தின் சாராம்சம்;
• கட்டளை வடிவில் அல்லது நடுநிலையாக: "Добавить валидацию email", "Fix login redirect";
• தேவைப்பட்டால் — ஒரு வெற்று வரி, பிறகு விவரங்கள்: ஏன் இப்படி, என்ன வரம்புகள் உள்ளன;
• ஒரு commit — ஒரு தர்க்கரீதியான மாற்றம்.

மோசமானவை: fix, правки, wip, asdf. நல்லது: Исправить падение корзины при пустом списке товаров. பல குழுக்கள் Conventional Commits வடிவத்தைப் பயன்படுத்துகின்றன: feat: ..., fix: ..., docs: ....

git commit --amend: கடைசி commit-ஐ சரிசெய்வது

செய்தியில் எழுத்துப் பிழை, அல்லது ஒரு கோப்பை சேர்க்க மறந்துவிட்டீர்களா — "கோப்பை மறந்துவிட்டேன்" என்ற புதிய commit தேவையில்லை. அதற்காகவே amend.

செய்தியைத் திருத்துவது

git commit --amend -m "Исправить проверку пароля при входе"

மறந்த கோப்பைச் சேர்ப்பது

git add forgotten.js
git commit --amend --no-edit

--no-edit பழைய செய்தியை அப்படியே வைக்கும்.

amend பற்றிய முக்கியமான விஷயம்

--amend commit-ஐ "திருத்துவதில்லை": அது வேறு hash உடன் புதிய commit ஒன்றை உருவாக்கி பழையதற்குப் பதிலாக வைக்கிறது. Commit இன்னும் உங்களிடம் மட்டுமே இருந்தால் இது பாதுகாப்பானது. ஏற்கனவே git push செய்திருந்தால், amend-க்குப் பிறகு சாதாரண push நிராகரிக்கப்படும், git push --force-with-lease தேவைப்படும். மற்றவர்களும் வேலை செய்யும் பகிரப்பட்ட கிளையில் இதைச் செய்யக் கூடாது: அவர்கள் ஏற்கனவே அடிப்படையாகக் கொண்ட வரலாற்றை மாற்றுவீர்கள்.

amend தவறுதலாகச் செய்யப்பட்டால், பழைய commit-ஐ git reflog-இல் கண்டுபிடித்து git reset --soft HEAD@{1} மூலம் திரும்பலாம்.

அடிக்கடி ஏற்படும் பிழைகள்

«nothing to commit, working tree clean»

மாற்றங்கள் இல்லை — எல்லாம் ஏற்கனவே commit செய்யப்பட்டுவிட்டது, அல்லது வேறு கோப்புறையில் திருத்துகிறீர்கள். git status மற்றும் திட்டத்தின் பாதையைச் சரிபாருங்கள்.

«no changes added to commit»

கோப்புகள் மாற்றப்பட்டுள்ளன, ஆனால் index-இல் சேர்க்கப்படவில்லை. git add செய்யுங்கள், அல்லது ஏற்கனவே கண்காணிக்கப்படும் கோப்புகளுக்கு git commit -am பயன்படுத்துங்கள்.

«Please tell me who you are»

பெயரும் மின்னஞ்சலும் அமைக்கப்படவில்லை. ஒரு முறை இயக்குங்கள்: git config --global user.name "பெயர்" மற்றும் git config --global user.email "மின்னஞ்சல்".

தேவையற்றதை commit செய்துவிட்டீர்கள்

Commit இன்னும் அனுப்பப்படவில்லை என்றால், மாற்றங்களை index-இல் வைத்துக்கொண்டு அதை ரத்து செய்யுங்கள்: git reset --soft HEAD~1. பிறகு git restore --staged மூலம் தேவையற்றதை நீக்கி மீண்டும் commit செய்யுங்கள். Commit-இல் ரகசியம் (secret) சேர்ந்திருந்தால், அது வெளிப்பட்டதாகக் கருதி அதை மீண்டும் உருவாக்குங்கள்.

git add . தேவையற்றதைச் சேர்த்துவிட்டது

.gitignore-ஐ முன்கூட்டியே அமையுங்கள், commit-க்கு முன் git status பாருங்கள். ஏற்கனவே கண்காணிக்கப்படும் கோப்பு git rm --cached файл செய்த பின்னரே கண்காணிப்பை நிறுத்தும்.

Commit உண்மையில் என்ன

Commit முந்தைய பதிப்புடனான வேறுபாட்டை அல்ல, முழு திட்டத்தின் நிலைப்படத்தை சேமிக்கிறது: கோப்பு மரத்திற்கான இணைப்பு, பெற்றோர் commit-க்கான இணைப்பு, ஆசிரியர், தேதி மற்றும் செய்தி. மாறாத கோப்புகள் நகலெடுக்கப்படுவதில்லை — Git ஏற்கனவே சேமிக்கப்பட்ட பொருட்களைச் சுட்டுகிறது, அதனால் வரலாறு குறைந்த இடத்தையே எடுக்கும்.

Commit hash (உதாரணமாக 3f2a9c1) இந்த உள்ளடக்கம் அனைத்திலிருந்தும் கணக்கிடப்படுகிறது. செய்தியில் ஒரே ஒரு எழுத்தை மாற்றினாலும் வேறு hash கிடைக்கும். அதனால்தான் --amend மற்றும் rebase பழையவற்றைத் திருத்தாமல் புதிய commit-களை உருவாக்குகின்றன; அதனால்தான் மீண்டும் எழுதப்பட்ட வரலாறு சக ஊழியர்களின் நகல்களுடன் முரண்படுகிறது.

வரலாற்றைச் சுருக்கமாகப் பார்க்க:

git log --oneline --graph -10

ஒவ்வொரு வரியும் ஒரு commit; diff-ஐத் திறக்காமலேயே உங்கள் வரலாற்றின் செய்திகள் புரிந்தால், நீங்கள் சரியாகச் செய்கிறீர்கள்.

தினசரி வேலைச் சுழற்சி

git status                 # என்ன மாறியது
git diff                   # திருத்தங்களைப் பார்
git add -p                 # தேவையானதைத் தேர்ந்தெடு
git diff --staged          # commit-இல் என்ன போகும் என்று சரிபார்
git commit -m "Понятное описание"
git log --oneline -5       # commit சரியாக உள்ளதா என்று உறுதிசெய்
git push                   # சேவையகத்திற்கு அனுப்பு

Commit மாற்றங்களை உள்ளூரில் மட்டுமே சேமிக்கிறது. அவை GitHub அல்லது வேறு சேவையகத்தில் தோன்ற git push தேவை.

சுருக்கம்

git add அடுத்த நிலைப்படத்தை index-இல் சேகரிக்கிறது, git status மற்றும் git diff --staged அதில் என்ன சேரும் என்பதைக் காட்டுகின்றன, git commit நிலைப்படத்தை வரலாற்றில் பதிவு செய்கிறது. சிறிய, தர்க்கரீதியான commit-கள் தெளிவான செய்திகளுடன் செய்யுங்கள்; கடைசி commit-இன் சிறு திருத்தங்களுக்கு git commit --amend பயன்படுத்துங்கள் — push செய்வதற்கு முன் மட்டும். Index மற்றும் add → commit என்ற இரண்டு படி முறை Git பாடநெறியில் நடைமுறையில் விளக்கப்பட்டுள்ளது.