Безпечні експерименти: робота з гілками

1. Що таке гілки й навіщо вони потрібні?

Робота з branches у Git — це один із ключових аспектів керування версіями, що дає змогу паралельно вести кілька ліній розробки в одному репозиторії. Відгалуження робить Git потужним інструментом для співпраці, експериментів і керування різними версіями проєкту.

            gitGraph
            commit id: "Initial setup"
            commit id: "Add base features"
            branch feature/new-idea
            checkout feature/new-idea
            commit id: "Implement new logic"
            commit id: "Refactor the logic"
            checkout main
            commit id: "Urgent bugfix on main"
            merge feature/new-idea
            commit id: "Prepare for release"
        

Уявіть, що ви хочете суттєво переробити певну частину свого проєкту або провести ризикований експеримент. Як би ви діяли без Git? Найімовірніше, скопіювали б увесь проєкт у нову папку та працювали б у ній. Якщо результат сподобається — перенесли б його в основну папку. Якщо ні — просто видалили б копію.

Гілки в Git працюють за тим самим принципом, але значно елегантніше. Розгляньмо це на прикладі написання книжки:

1. У вас є готовий рукопис (це ваша основна гілка main).
2. Хочете написати альтернативну кінцівку — створюєте нову гілку, наприклад feature/new-idea.
3. Пишете нову кінцівку, не чіпаючи основний текст рукопису (працюєте в новій гілці).
4. Якщо нова кінцівка виявиться кращою, ви заміните нею стару (робите злиття гілок — merge).
5. Старий чернетковий варіант із непотрібною кінцівкою можна видалити (видаляєте гілку).

2. Створення нової гілки й робота в ній

Крок 1. Відкрийте меню керування гілками.

На верхній панелі IDE є віджет, який показує імʼя поточної гілки (за замовчуванням — main). Натисніть на нього та виберіть + New Branch.

Крок 2. Імʼя нової гілки.

Добра практика — називати гілки відповідно до завдання, яке ви розвʼязуєте. Наприклад, feature/add-usage-examples.

Після створення гілки IDE автоматично перемкнеться на неї. Ви побачите нову назву у тому самому віджеті.

Крок 3. Внесіть зміни та зробіть commit.

Тепер ви у своїй «пісочниці». Додамо до файлу README.md новий розділ із прикладами використання. Внесіть зміни та зробіть commit, як ви робили в попередній лекції.

3. Перемикання між гілками

Ваші зміни з прикладами використання тепер надійно збережені в гілці feature/add-usage-examples. Повернімося в основну гілку main і подивімося, що там.

Крок 1. Знову натисніть на віджет із імʼям поточної гілки.

Крок 2. У списку Local або Recent оберіть гілку main, а в підменю натисніть Checkout.

Крок 3. Перевірте результат.

Щойно перемкнетеся, відкрийте файл README.md. Ви побачите, що розділу з прикладами використання в ньому немає — він залишився в іншій гілці. Отже, ви можете працювати над новою функціональністю, не чіпаючи стабільну версію в гілці main.

4. Злиття гілок (Merge)

Команда merge бере всі коміти з гілки feature/add-usage-examples (у нашому випадку — коміт C3) і обʼєднує їх із поточною гілкою main, створюючи новий коміт злиття.

            gitGraph
            commit id: "C1"
            commit id: "C2"
            branch feature/add-usage-examples
            checkout feature/add-usage-examples
            commit id: "C3: Add new section"
            checkout main
            merge feature/add-usage-examples
        

Отже, ви завершили роботу над завданням у гілці feature/add-usage-examples і хочете додати ці зміни в основний проєкт.

Крок 1. Перемкніться на цільову гілка.

Переконайтеся, що ви в тій гілці, КУДИ хочете додати зміни. У нашому випадку це main.

Крок 2. Виконайте злиття.

Знову натисніть на віджет керування гілками. У списку оберіть гілку, ЗВІДКИ ви хочете взяти зміни (feature/add-usage-examples), і в підменю виберіть Merge feature/add-usage-examples в main.

Крок 3. Перевірте результат.

Тепер у файлі README.md у гілці main зʼявився ваш новий розділ із прикладами. Ви успішно обʼєднали свою роботу з основною версією проєкту!

5. Конфлікти під час злиття: не лякайтеся, це нормально!

Іноді під час злиття гілок виникають конфлікти. Це стається, коли в обох гілках були змінені одні й ті самі рядки в одному й тому самому файлі. Git не може самостійно визначити, яка версія правильна, і просить вашої допомоги.

            gitGraph
            commit id: "C1: Спільна база"
            branch feature/new-title
            checkout main
            commit id: "C2: Зміна в main"
            checkout feature/new-title
            commit id: "C3: Зміна у feature"
        

Змоделюємо конфлікт:

1. Переконайтеся, що ви в гілці main і у вас немає незбережених змін.
2. Створіть нову гілку feature/new-title, але не перемикайтеся на неї поки що. Переконайтеся, що прапорець Checkout branch знято.
3. Тепер, перебуваючи в гілці main, змініть перший рядок у README.md на «My Awesome Project» і зробіть commit.
4. Перемкніться на гілку feature/new-title. Ви побачите, що перший рядок у README.md тут залишився старим: це стан файлу на момент створення гілки. Змініть той самий рядок на «My Super Project» і зробіть commit.
5. Поверніться в гілку main і виконайте злиття з feature/new-title.

Тепер Git побачить, що обидві гілки мають нові, розбіжні історії від їхнього спільного предка. В обох історіях змінено один і той самий рядок, тож Git не зможе обрати, яка версія правильна, і покаже вам вікно для розвʼязання конфлікту.

Merge Revision

Що ви тут бачите:

• Ліворуч (Your changes): версія файлу з вашої поточної гілки (main).
• Праворуч (Changes from branch...): версія файлу з гілки, яку ви зливаєте.
• У центрі (Result): підсумкова версія файлу, яку ви маєте зібрати.

Ви можете натискати на стрілочки >> або <<, щоб прийняти один із варіантів повністю.

Коли результат у центральній панелі вас задовольнить, натисніть Apply. IDE сама створить коміт злиття, і конфлікт буде розвʼязано.

Чому конфлікт не виник?

Може статися, що ви виконали всі кроки, а конфлікт не зʼявився. Найчастіше це трапляється, оскільки Git виконав fast-forward merge, адже історія однієї гілки просто продовжила історію іншої. Щоб конфлікт гарантовано виник, історії гілок мають розійтися в різні боки від спільного предка.

Приклад:

1. У вас є певний коміт у main (припустімо, C1).
2. Ви робите новий коміт у main з текстом «My Awesome Project». Гілка main тепер вказує на коміт C2 (main -> C1 -> C2).
3. Ви створюєте гілку feature/new-title з поточної позиції гілки main. Це означає, що нова гілка теж починається з коміту C2.
4. Ви робите коміт у feature/new-title з текстом «My Super Project». Ця гілка «йде вперед» і тепер вказує на коміт C3 (feature/new-title -> C1 -> C2 -> C3).
5. Ви повертаєтеся в main (яка досі на коміті C2) і даєте команду злити feature/new-title.

Git «думає»: «Тут просто треба перемотати main уперед до коміту C3. Жодних суперечностей немає». І він просто переміщує вказівник main на коміт C3.

            gitGraph
            commit id: "C1"
            commit id: "C2"
            branch feature/new-title
            checkout feature/new-title
            commit id: "C3"
            checkout main
            merge feature/new-title
        

6. Перегляд історії змін

Щоб краще розуміти, що відбувається у вашому проєкті, корисно переглядати його історію.

Відкрийте вкладку Git у нижній частині IDE та оберіть Log. Ви побачите графічне представлення всіх ваших гілок і комітів. Це допоможе наочно відстежити, яка гілка від якої відділилася і де вони були злиті.

Тут ви можете натиснути на будь-який коміт, щоб побачити, які зміни до нього увійшли, хто і коли його зробив. Це справжня машина часу для коду.