Đoạn xem trước bài giảng

கிளைகள்: உங்கள் குறியீட்டின் இணை யதார்த்தம்

கிளைகள் Git-ன் இதயம் ஆகும், மேலும் இங்குதான் பெரும்பாலான புதியவர்கள் பயப்பட ஆரம்பிக்கிறார்கள். நாம் கிளைகளைப் புரியவைப்போம்: ஒரு கிளை என்பது ஒரு சுட்டி (pointer) மட்டுமே, கோப்புகளின் நகல் அல்ல என்பதைக் காண்பிப்போம். கிளைகளை எவ்வாறு உருவாக்குவது, அவற்றுக்கிடையே மாறுவது மற்றும் மாற்றங்களை இணைப்பது எப்படி என்பதைப் பகுப்பாய்வு செய்வோம், மேலும் fast-forward மற்றும் மூன்று-வழி இணைப்பு (three-way merge) ஆகியவற்றுக்கு இடையேயான வேறுபாட்டை நேரடி உதாரணங்களுடன் காண்போம்.

கிளை HEAD இணைப்பு (merge)
Bạn sẽ học gì trong bài giảng này
  • கிளை என்பது இலகுவான சுட்டி என்பதை நீங்கள் புரிந்துகொள்வீர்கள், மேலும் எந்தக் காரணத்திற்காகவும் அவற்றை உருவாக்க பயப்படுவதை நிறுத்துவீர்கள்.
  • கிளைகளை உருவாக்கவும், அவற்றுக்கிடையே மாறவும், merge கட்டளையைப் பயன்படுத்தி மாற்றங்களை இணைக்கவும் உங்களால் முடியும்.
  • fast-forward மற்றும் மூன்று-வழி இணைப்பு ஆகியவற்றை நீங்கள் வேறுபடுத்தி அறிய முடியும், மேலும் எந்த சூழ்நிலையில் எந்த முறை பயன்படுத்தப்படுகிறது என்பதைப் புரிந்துகொள்வீர்கள்.

Phần đầu bài giảng

கிளைகளில் கோப்புகளை நகலெடுக்கும் கட்டுக்கதை

  • கிளை என்பது கோப்புகளின் நகல் அல்ல, மாறாக ஒரு இலகுரக சுட்டி
  • கிளையை உருவாக்குவதற்கு நொடியின் ஒரு பகுதியே ஆகும்
  • சேமிப்பில் பூஜ்ஜிய மேல்நிலைச் செலவு
  • அனைத்து கிளைகளும் ஒரே கோப்புகளுடன் வேலை செய்கின்றன

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

கிளையின் உள் அமைப்பு

  • கிளை = commit-ன் hash உடன் ஒரு உரை கோப்பு
  • .git/refs/heads/ இல் சேமிக்கப்படுகிறது
  • அளவு: சரியாக 40 எழுத்துகள்
  • புதிய கிளை = hash உடன் புதிய கோப்பு

Git-ன் உள்ளே பார்ப்போம். ஒவ்வொரு கிளையும் என்பது மறைக்கப்பட்ட '.git' கோப்புறையில் ஒரு உரை கோப்பு மட்டுமே. இந்த கோப்பில் நாற்பது எழுத்துகள் மட்டுமே சேமிக்கப்பட்டுள்ளன - கிளையில் உள்ள கடைசி commit-ன் hash. நீங்கள் ஒரு புதிய கிளையை உருவாக்கும்போது, Git தற்போதைய commit-ன் hash-ஐ ஒரு புதிய கோப்பில் எழுதுகிறது. திட்டத்தில் ஆயிரக்கணக்கான கோப்புகள் இருந்தாலும், முழு செயல்முறையும் நொடியின் ஒரு பகுதியில் நடக்கிறது. இப்போது கிளைகளுக்கு இடையில் மாறுவது ஏன் உடனடியாக நடக்கிறது என்பதை நீங்கள் புரிந்துகொள்கிறீர்களா?

புத்தகத்தின் நகலுக்குப் பதிலாக பக்க அடையாளம்

  • கிளை என்பது புத்தகத்தில் உள்ள பக்க அடையாளம் போன்றது
  • உள்ளடக்கத்தை நகலெடுக்காது
  • உடனடி மாறுதல்
  • எவ்வளவு வேண்டுமானாலும் உருவாக்கலாம்

புத்தகம் படிப்பதைப் போன்ற ஒப்புமை எடுத்துக் கொள்வோம். நீங்கள் ஒரு பக்கத்தில் பக்க அடையாளத்தை வைக்கும்போது, முழு புத்தகத்தையும் நகலெடுக்கிறீர்களா? இல்லை, நீங்கள் இடத்தை மட்டுமே குறிக்கிறீர்கள், பின்னர் திரும்பி வர. Git-ல் கிளையும் இதேபோல் செயல்படுகிறது - இது ஒரு இலகுரக முத்திரை, உங்கள் குறியீட்டின் ஒரு குறிப்பிட்ட நிலையை சுட்டிக்காட்டுகிறது. நீங்கள் இதுபோன்ற டசன் முத்திரைகளை உருவாக்கலாம், அது வட்டில் கூடுதல் இடத்தை எடுக்காது. இது ஒரே நேரத்தில் திட்டத்தின் வெவ்வேறு பதிப்புகளுடன் எவ்வாறு வேலை செய்யலாம் என்பது பற்றிய பார்வையை முற்றிலும் மாற்றுகிறது.

Bài giảng đầy đủ dành cho thuê bao

Còn 21 slide nữa trong phiên bản đầy đủ.

Video, toàn bộ slide, ghi chú, bài kiểm tra, gia sư AI và phỏng vấn sẽ mở sau khi đăng nhập và đăng ký thuê bao.

Đăng nhập hoặc đăng ký Đăng ký thuê bao

Nội dung bài giảng

  1. கிளைகளில் கோப்புகளை நகலெடுக்கும் கட்டுக்கதை
  2. கிளையின் உள் அமைப்பு
  3. புத்தகத்தின் நகலுக்குப் பதிலாக பக்க அடையாளம்
  4. நடைமுறையில் ஒரு கிளையை உருவாக்குதல்
  5. Git-ல் கிளைகள் எவ்வாறு உருவாக்கப்பட்டுள்ளன
  6. ஒரு புதிய கிளையை உருவாக்குதல்
  7. விரைவான உருவாக்கம் மற்றும் மாறுதல்
  8. கிளைகளை மாற்றும்போது என்ன நடக்கிறது
  9. கிளைகளை இணைப்பது எப்போது மோதல்கள் இல்லாமல் நிகழ்கிறது
  10. ஃபாஸ்ட்-ஃபார்வர்ட் இணைப்பு எவ்வாறு செயல்படுகிறது
  11. நடைமுறை உதாரணம்: feature ஐ main உடன் இணைத்தல்
  12. கிளைகளை தானாக இணைக்க முடியாதபோது
  13. இணைப்பு மோதல் எப்படி இருக்கும்
  14. மோதலைத் தீர்ப்பதற்கான படிகள்
  15. ஏன் எளிய இணைப்பு எப்போதும் வேலை செய்யாது?
  16. மூவழி இணைப்பு எப்படி வேலை செய்கிறது
  17. நடைமுறையில் இணைப்பு உறுதிப்பாட்டை உருவாக்குதல்
  18. நீண்ட காத்திருப்பு இணைப்பை எப்படி சிக்கலாக்குகிறது
  19. முரண்பாடுகளைத் தீர்ப்பதற்கான சரியான வழி
  20. முரண்பாடுகளைத் தீர்ப்பதற்கான சரியான வழி
  21. புதிய பணிக்கு feature கிளையை உருவாக்குதல்
  22. பல கிளைகளில் இணையாக வேலை செய்தல்
  23. முக்கிய கிளையுடன் மாற்றங்களை இணைத்தல்
  24. சுருக்கம்: கிளைகள் மற்றும் இணைப்புகள்

Bài viết liên quan đến bài học này

Tất cả bài giảng của khóa học

  1. அறிமுகம்: Git-ஐ பூஜ்ஜியத்திலிருந்து நம்பிக்கையான டெவலப்பர் வரை
  2. Git எதற்கு தேவை - மற்றும் ஏன் அது இல்லாமல் வேலைக்கு சேர்க்க மாட்டார்கள்
  3. நிறுவல் மற்றும் அமைப்புகள்: Git-ஐ முதல் முறையாகப் பயன்படுத்தத் தயார்படுத்துதல்
  4. முதல் களஞ்சியம்: init, add, commit மற்றும் குறியீட்டின் மந்திரம்
  5. வரலாற்றை வாசித்தல்: log, diff, show மற்றும் கடந்த காலத்தில் செல்லுதல்
  6. கிளைகள்: உங்கள் குறியீட்டின் இணை யதார்த்தம்
  7. பிழைகளைச் சரிசெய்தல்: restore, reset, revert — சரியான மற்றும் ஆபத்தான முறைகள்
  8. GitHub மற்றும் தொலை களஞ்சியங்கள்: உங்கள் குறியீடு கிளவுட் (Cloud) இல்
  9. குழு பணிகள்: ஃபோர்குகள், ஃபீச்சர் பிரான்சுகள் மற்றும் புல் ரெக்வெஸ்ட்கள்
  10. இணைப்பு முரண்பாடுகள்: பீதி அடைய வேண்டாம் – புரிந்துகொண்டு தீர்க்கவும்
  11. உண்மையான குழுக்களில் Git செயல்முறைகள்: எந்த workflow-ஐ தேர்வு செய்வது
  12. மேம்பட்ட கருவிகள்: rebase, stash, cherry-pick மற்றும் குறிச்சொற்கள்
  13. இறுதித் திட்டம்: உண்மையான குழு மேம்பாட்டு பணியை உருவகப்படுத்துதல்