Git கிளைகள்: git branch — உருவாக்குதல், மாற்றுதல், நீக்குதல்

Git-இல் கிளை என்றால் என்ன

Git-இல் கிளை என்பது திட்டத்தின் நகல் அல்ல, ஒரு commit-இன் hash கொண்ட சிறிய கோப்பு. கிளை உருவாக்குவது சில நொடிகளில் நடக்கும், இடமும் கிட்டத்தட்ட எடுக்காது: Git எதையும் நகலெடுப்பதில்லை — எல்லாக் கிளைகளும் களஞ்சியத்தின் ஒரே பொருட்களை சுட்டுகின்றன. நீங்கள் commit செய்யும்போது நடப்புக் கிளையின் சுட்டி புதிய commit-க்கு நகர்கிறது.

இது கிளைகளைப் பற்றிய அணுகுமுறையை மாற்றுகிறது. அவற்றுக்கு பயப்படவோ சிக்கனப்படுத்தவோ தேவையில்லை: ஒவ்வொரு பணி, திருத்தம் அல்லது சோதனைக்கும் தனிக் கிளை வைத்திருப்பது இயல்பான நடைமுறை. சோதனை தோல்வியடைந்தால் கிளையை நீக்கிவிடலாம்; முதன்மை வரலாறு சுத்தமாக இருக்கும்.

கிளை ஒரு கோப்பு என்பதை நீங்களே பார்க்கலாம்:

$ cat .git/refs/heads/main
8b7d4e2a9f1c0d3e5b6a7c8d9e0f1a2b3c4d5e6f

(பெரிய களஞ்சியங்களில் சில குறிப்புகள் .git/packed-refs-இல் தொகுக்கப்பட்டிருக்கும், அதனால் கோப்பு இல்லாமல் போகலாம் — அடிப்படை கருத்து மாறாது.)

Git-இல் HEAD: நீங்கள் இப்போது எங்கே

HEAD என்பது வேலை அடைவில் இப்போது "சோதிக்கப்பட்டிருப்பதை" சுட்டும் குறிப்பு. பொதுவாக HEAD commit-ஐ அல்ல, ஒரு கிளையைச் சுட்டும்:

$ cat .git/HEAD
ref: refs/heads/main

சங்கிலி இப்படி: HEAD → main → commit. புதிய commit-இன் பெற்றோர் HEAD சுட்டும் commit ஆகும்; பின்னர் HEAD சுட்டும் கிளையை Git நகர்த்தும். அதனால்தான் commit-கள் நடப்புக் கிளையில் சேர்கின்றன.

நேரடியாக ஒரு commit அல்லது tag-க்கு மாறினால் (git switch --detach v1.0 அல்லது git checkout 3f2a1c9), HEAD நேரடியாக அந்த commit-ஐ சுட்டும். இந்த நிலை detached HEAD எனப்படும். அதில் குறியீட்டைப் பார்ப்பது பாதுகாப்பானது, ஆனால் புதிய commit-கள் எந்தக் கிளையுடனும் இணைக்கப்படுவதில்லை, மாறியதும் எளிதாகத் தொலையலாம். அங்கே மாற்றங்களைத் தொடங்கியிருந்தால், அதே இடத்தில் கிளை உருவாக்குங்கள்: git switch -c fix-from-old-version.

வெளிப்பாடுகளில் HEAD-ஐ ஒரு தொடக்கப் புள்ளியாகப் பயன்படுத்தலாம்: HEAD~1 — முந்தைய commit, HEAD~3 — மூன்று commit பின்னால், HEAD^2 — இணைப்பு commit-இன் இரண்டாவது பெற்றோர்.

கிளைகளைப் பார்ப்பது: git branch

git branch            # локальные ветки, текущая отмечена *
git branch -v         # плюс последний коммит в каждой
git branch -vv        # плюс upstream и отставание/опережение
git branch -r         # удалённые ветки (origin/...)
git branch -a         # все ветки
git branch --show-current   # только имя текущей ветки

git branch -vv வெளியீட்டு எடுத்துக்காட்டு:

  feature/login 4c1e2d7 [origin/feature/login: ahead 2] Форма входа
* main          8b7d4e2 [origin/main] Обновить README
  old-spike     1a9b3c0 Эксперимент с кэшем

இங்கே feature/login-இல் அனுப்பப்படாத இரண்டு commit-கள் உள்ளன, main சேவையகத்துடன் ஒத்துப்போகிறது, old-spike-க்கு சேவையகத்தில் இணை கிளையே இல்லை.

கிளைகளை வடிகட்ட git branch --merged (ஏற்கனவே நடப்புக் கிளையுடன் இணைக்கப்பட்டவை — நீக்கத்திற்கான வேட்பாளர்கள்), git branch --no-merged (இன்னும் இணைக்கப்படாதவை) மற்றும் git branch --list 'feature/*' (வடிவத்தின்படி) உதவும்.

கிளை உருவாக்குவது எப்படி

இரண்டு வழிகள் உள்ளன. git branch கிளையை உருவாக்கும், ஆனால் நீங்கள் நடப்புக் கிளையிலேயே இருப்பீர்கள்:

git branch feature/login            # от текущего коммита
git branch hotfix v1.2.0            # от тега
git branch review 3f2a1c9           # от конкретного коммита

பெரும்பாலும் கிளையை உருவாக்கி உடனே அதற்குச் செல்ல வேண்டும். அதற்கு git switch -c (Git 2.23-இல் அறிமுகம்) அல்லது பழைய சமமான git checkout -b:

git switch -c feature/login
git switch -c hotfix origin/main    # новая ветка от свежего состояния сервера

பணிக்காகக் கிளை உருவாக்கும் முன் அடிப்படையைப் புதுப்பிப்பது நல்ல பழக்கம்: git fetch, பின்னர் git switch -c feature/x origin/main. இதனால் கிளை நீண்ட நாட்களாகப் புதுப்பிக்கப்படாத உங்கள் உள்ளூர் main-இலிருந்தல்ல, தற்போதைய குறியீட்டிலிருந்து தொடங்கும்.

கிளைகளுக்குப் பெயரிடுவது

குழுக்களில் நிலையான மரபுகள்: வேலையின் வகையைக் குறிக்கும் முன்னொட்டு மற்றும் ஹைஃபனுடன் சுருக்கமான விளக்கம் — feature/user-avatar, fix/login-timeout, chore/update-deps, சில நேரம் பணி எண்ணுடன்: feature/SHOP-142-cart. இடைவெளிகள், ~ ^ : ? * [, அடுத்தடுத்த இரண்டு புள்ளிகள் மற்றும் .lock என்ற முடிவு பயன்படுத்தக் கூடாது.

கிளைக்கு மாறுவது: git switch

git switch main             # перейти на существующую ветку
git switch -                # вернуться на предыдущую ветку
git switch feature/login    # если локальной нет, но есть origin/feature/login,
                            # Git создаст локальную и свяжет её с удалённой

மாறும்போது Git வேலை அடைவின் கோப்புகளை இலக்குக் கிளையின் பதிப்பால் மாற்றுகிறது. commit செய்யப்படாத மாற்றங்கள் இலக்குக் கிளையுடன் முரண்படாதவரை உங்களுடன் வரும். முரண்பட்டால் Git மறுக்கும்:

error: Your local changes to the following files would be overwritten by checkout:
        app.js
Please commit your changes or stash them before you switch branches.

தீர்வுகள்: commit செய்யுங்கள், அல்லது git stash மூலம் ஒதுக்குங்கள் (பின்னர் git stash pop), அல்லது இணைப்பு முயற்சியுடன் வேண்டுமென்றே மாற்றங்களை எடுத்துச் செல்லுங்கள்: git switch -m main. --discard-changes கொடி மாற்றங்களை நிராகரிக்கும் — அவை நிச்சயம் தேவையில்லை என்றால் மட்டுமே பயன்படுத்துங்கள்.

ஏன் checkout அல்ல git switch? Checkout கிளைகளை மாற்றவும், கோப்புகளை மேலெழுதவும் செய்யும்; அதனால் தவறு செய்வது எளிது. Switch ஒன்றை மட்டுமே செய்கிறது — கிளைகளுடன் வேலை செய்கிறது, அதனால் பாதுகாப்பானது. checkout, switch மற்றும் restore பற்றிய விரிவான ஒப்பீடு தனிக் கட்டுரையில் உள்ளது.

கிளையின் பெயரை மாற்றுவது

git branch -m new-name              # переименовать текущую
git branch -m old-name new-name     # переименовать любую
git branch -M main                  # то же с перезаписью существующей ветки

கிளை ஏற்கனவே சேவையகத்தில் இருந்தால், பெயர் மாற்றம் உள்ளூரில் மட்டுமே. புதியதை அனுப்பி பழையதை நீக்குங்கள்:

git push -u origin new-name
git push origin --delete old-name

கிளையை நீக்குவது

git branch -d feature/login     # удалит, только если ветка влита
git branch -D old-spike         # удалит принудительно
git push origin --delete feature/login   # удалить на сервере

-d வேலை இழப்பிலிருந்து பாதுகாக்கிறது: கிளையில் நடப்புக் கிளையில் (அல்லது அதன் upstream-இல்) இல்லாத commit-கள் இருந்தால், Git "The branch 'x' is not fully merged" என்ற செய்தியுடன் மறுக்கும். -D கேள்வி கேட்காமல் நீக்கும். நடப்புக் கிளையை நீக்க முடியாது — முதலில் வேறொன்றுக்கு மாறுங்கள்.

தவறுதலாக நீக்கிவிட்டீர்களா? Commit-கள் உடனே மறைவதில்லை. git reflog-இல் கிளையின் கடைசி commit hash-ஐக் கண்டுபிடித்து மீட்டெடுக்கலாம்: git branch old-spike 1a9b3c0.

சேவையகத்தில் இனி இல்லாத தொலைநிலைக் கிளைகளின் பழைய குறிப்புகளை git fetch --prune சுத்தம் செய்யும்.

உள்ளூர் கிளையை தொலைநிலைக் கிளையுடன் இணைப்பது

உள்ளூர் கிளைக்கு upstream இருக்கலாம் — அதனுடன் ஒப்பிடப்பட்டு ஒத்திசைக்கப்படும் தொலைநிலைக் கிளை. இது git push மற்றும் git pull வாதங்கள் இல்லாமலும் வேலை செய்யவும், git status "ahead/behind" காட்டவும் தேவை.

git push -u origin feature/login                 # при первой отправке
git branch --set-upstream-to=origin/main main    # для существующей ветки
git branch --unset-upstream                      # убрать связь

கிளைகளை இணைப்பது: சுருக்கமாக

கிளைகள் பின்னர் இணைப்பதற்காக உருவாக்கப்படுகின்றன. வேலை முடிந்ததும் இலக்குக் கிளைக்கு மாறி அதில் உங்கள் கிளையை இணையுங்கள்:

git switch main
git merge feature/login

கிளை உருவாக்கியதிலிருந்து main முன்னேறவில்லையென்றால், Git fast-forward செய்யும்: இணைப்பு commit இல்லாமல், main சுட்டியை கிளையின் கடைசி commit-க்கு நகர்த்தும். இரண்டு கிளைகளிலும் புதிய commit-கள் இருந்தால் மூன்று-பக்க இணைப்பு நடக்கும்: Git பொதுவான மூதாதையரைக் கண்டறிந்து, இரு பக்கங்களையும் ஒப்பிட்டு, இரண்டு பெற்றோர்களைக் கொண்ட இணைப்பு commit-ஐ உருவாக்கும். குழுக்களில் இணைப்பு பொதுவாக சேவையகத்தில் pull request மூலம் நடக்கும்; உள்ளூரில் புதிய main-ஐ மட்டும் இழுத்துக்கொள்வார்கள்.

கிளைகளுக்கான சுருக்க அட்டவணை

தொடக்கநிலையாளர்களின் பொதுவான தவறுகள்

• main-இலேயே வேலை செய்வது. Commit-கள் ஏற்கனவே செய்யப்பட்டு ஆனால் அனுப்பப்படவில்லையென்றால், தற்போதைய இடத்திலேயே கிளை உருவாக்குங்கள் (git branch feature/x), பின்னர் main-ஐ சேவையகத்திற்குத் திருப்புங்கள்: git reset --hard origin/main (எல்லாம் commit செய்யப்பட்டுள்ளதா என்று உறுதிசெய்த பின்).
• பழைய main-இலிருந்து கிளை. முதலில் git fetch, கிளையை origin/main-இலிருந்து உருவாக்குங்கள்.
• detached HEAD-இல் commit-கள். மாறுவதற்கு முன் கிளை உருவாக்குங்கள்; ஏற்கனவே மாறியிருந்தால் git reflog-இல் commit-களைத் தேடுங்கள்.
• நீண்ட நாட்கள் வாழும் கிளைகள். கிளை தனியாக எவ்வளவு காலம் இருக்கிறதோ, இணைப்பு அவ்வளவு கடினமாகும். அடிக்கடி main-ஐ இழுத்து, வேலையை சிறு பகுதிகளாக இணையுங்கள்.

குழு வேலையில் கிளைகள்

குழுக்களில் செயல்முறைகள் வேறுபடுகின்றன, ஆனால் கிட்டத்தட்ட எல்லா இடங்களிலும் இரண்டு திட்டங்களில் ஒன்று உண்டு. GitHub Flow-இல் வெளியிடத் தயாராக எப்போதும் இருக்கும் ஒரு நீண்ட கால main கிளையும், மதிப்பாய்வு மற்றும் CI சோதனைகளுக்குப் பின் pull request மூலம் இணையும் குறுகிய feature கிளைகளும் இருக்கும். Git Flow-இல் develop, வெளியீட்டுக் கிளைகள் மற்றும் hotfix கிளைகள் சேர்கின்றன; இது கனமானது, அரிதாக பதிப்பிடப்பட்ட வெளியீடுகள் உள்ள தயாரிப்புகளுக்கு ஏற்றது.

திட்டம் எதுவானாலும் பொது விதிகள் பொருந்தும்: ஒரு கிளை — ஒரு பணி, கிளை மாதங்களல்ல, நாட்கள் வாழ வேண்டும், pull request-க்கு முன் கிளை புதிய main-ஆல் புதுப்பிக்கப்பட வேண்டும், இணைப்புக்குப் பின் கிளையை உள்ளூரிலும் சேவையகத்திலும் நீக்க வேண்டும். முதன்மைக் கிளையை களஞ்சிய அமைப்புகளால் பாதுகாக்கிறார்கள்: அதில் நேரடி push மற்றும் force push தடை, இணைப்பு மதிப்பாய்வின் மூலம் மட்டுமே.

கிளைகளின் வரலாற்றைப் பார்ப்பது

கிளைகள் ஒன்றுக்கொன்று எப்படித் தொடர்புடையவை என்பதை வரைபடம் மூலம் பார்ப்பது எளிது: git log --oneline --graph --all எல்லாக் கிளைகளையும், அவை பிரியும் புள்ளிகளையும் டெர்மினலிலேயே வரைகிறது. கிளையில் இருந்து main-இல் இன்னும் சேராத commit-களைப் பார்க்க git log main..feature/login; கோப்புகளின் வேறுபாட்டுக்கு git diff main...feature/login (மூன்று புள்ளிகள் பொதுவான மூதாதையருடன் ஒப்பிடும், அதாவது கிளையின் சொந்த மாற்றங்களை மட்டும் காட்டும்).

சுருக்கம்

Git-இல் கிளை என்பது மலிவான commit சுட்டி; HEAD என்பது நடப்புக் கிளையின் சுட்டி. git branch கிளைகளை நிர்வகிக்கிறது (பட்டியல், உருவாக்கம், பெயர் மாற்றம், நீக்கம்), git switch அவற்றுக்கிடையே மாறுகிறது, git switch -c இரண்டையும் ஒரே நேரத்தில் செய்கிறது. கிளைகள், HEAD, fast-forward மற்றும் மூன்று-பக்க இணைப்பு ஆகியவை Git பாடநெறியில் உயிருள்ள எடுத்துக்காட்டுகளுடன் விளக்கப்பட்டுள்ளன.