Навигация

Git: ветки, rebase и командный workflow

Git есть в каждом проекте, но на собеседовании быстро становится видно, кто понимает его модель, а кто помнит пять команд. Вопросы «merge или rebase», «как откатить запушенный коммит», «какой у вас был branching workflow» задают почти всегда. В статье разобраны внутреннее устройство Git, слияние и переписывание истории, отмена изменений, стратегии ветвления, соглашения о коммитах и инструменты поиска багов в истории.

Содержание

  1. Как Git хранит данные
  2. Ветки и слияние
  3. Rebase и переписывание истории
  4. Merge vs rebase vs squash
  5. Разрешение конфликтов
  6. Отмена изменений и восстановление
  7. Стратегии ветвления
  8. Коммиты, хуки и версионирование
  9. Pull requests и защита веток
  10. Поиск по истории и отладка
  11. Git в CI и больших репозиториях
  12. Типовые сценарии с собеседований
  13. Ключевые тезисы для интервью
  14. Заключение
  15. Полезные ссылки

Как Git хранит данные

Git — это content-addressable хранилище объектов с набором указателей поверх него. Почти всё поведение команд следует из этой модели.

Объекты

ОбъектЧто хранит
blobСодержимое файла (без имени)
treeСписок имён файлов и папок со ссылками на blob и другие tree
commitСсылку на корневой tree, ссылки на родителей, автора, дату, сообщение
tag (annotated)Ссылку на коммит, автора тега, сообщение, подпись

Каждый объект адресуется хешем своего содержимого (SHA-1, опционально SHA-256). Изменили один байт — изменился хеш файла, его tree, коммита и всех коммитов после него. Поэтому история в Git неизменяема: «переписать» историю значит создать новые коммиты и переставить указатели.

Ссылки

.git/
├── HEAD                  → ref: refs/heads/feature/login
├── refs/
│   ├── heads/main        → a1b2c3d…   (локальная ветка)
│   ├── heads/feature/login → e4f5a6b…
│   ├── remotes/origin/main → a1b2c3d… (remote-tracking ветка)
│   └── tags/v1.2.0
└── objects/              (blob, tree, commit)
  • Ветка — файл с хешем одного коммита. Создание ветки — запись 41 байта, поэтому ветки в Git дешёвые.
  • HEAD — указатель на текущую ветку. Новый коммит получает родителем коммит, на который указывает ветка, и ветка сдвигается вперёд.
  • Detached HEAD — HEAD указывает прямо на коммит (после git checkout <sha> или во время rebase). Коммиты в этом состоянии не принадлежат ни одной ветке и становятся кандидатами на удаление сборщиком мусора.
  • origin/main — локальная копия последнего известного состояния удалённой ветки. Она обновляется только при fetch/pull.

Три области

Working tree  ──git add──▶  Index (staging)  ──git commit──▶  Repository
     ▲                                                              │
     └──────────────── git restore / git switch ────────────────────┘

Индекс — это черновик следующего коммита. Через него можно закоммитить только часть изменений (git add -p) и собрать атомарный коммит из грязной рабочей директории.


Ветки и слияние

Fast-forward

Если main не ушёл вперёд с момента создания ветки, Git просто передвигает указатель:

До:     main
          ↓
    A ─── B ─── C ─── D
                      ↑
                   feature

После git merge feature (fast-forward):
                     main, feature
                      ↓
    A ─── B ─── C ─── D

Нового коммита нет, в истории не видно, что была ветка.

Трёхстороннее слияние

Если ветки разошлись, Git находит merge base (общего предка) и сравнивает три версии: базу, ours и theirs. Результат записывается в merge commit с двумя родителями:

    A ─── B ─── E ─────── M   ← main
           \             /
            C ─── D ────┘     ← feature
git switch main
git merge feature            # fast-forward, если возможно
git merge --no-ff feature    # всегда создать merge commit
git merge --squash feature   # собрать изменения в индекс без коммита и без связи с веткой

--no-ff используют, когда важно видеть в истории границы фичи (например, в GitFlow).

Pull = fetch + merge

git pull по умолчанию делает fetch и merge удалённой ветки в локальную. Если вы и коллега закоммитили в одну ветку, появляются бессмысленные merge-коммиты «Merge branch ‘main’ of origin». Решение:

git pull --rebase
git config --global pull.rebase true   # сделать поведением по умолчанию

Rebase и переписывание истории

Как работает rebase

git rebase main берёт коммиты текущей ветки, которых нет в main, временно откладывает их, переключается на вершину main и применяет их заново по одному:

До:
    A ─── B ─── E        ← main
           \
            C ─── D      ← feature

После git rebase main (на feature):
    A ─── B ─── E        ← main
                 \
                  C' ─── D'   ← feature

C' и D' — новые коммиты с новыми хешами: у них другой родитель, значит другой хеш. Старые C и D остаются в репозитории, пока их не удалит сборщик мусора, и доступны через reflog.

Золотое правило

Не переписывайте историю, которая уже есть у других.

Если коллега построил работу на C и D, а вы заменили их на C' и D', его ветка будет содержать дубликаты, и при следующем слиянии конфликты появятся снова. Rebase безопасен для своей ветки, в которой никто больше не работает. После него нужен force push:

git push --force-with-lease          # отклонит push, если в remote появились чужие коммиты
git push --force-with-lease --force-if-includes   # дополнительно защищает от фонового fetch в IDE

Простой --force молча затирает чужую работу, на собеседовании его стоит упоминать только как антипример.

Interactive rebase

Interactive rebase — основной инструмент, чтобы привести ветку в порядок перед ревью:

git rebase -i HEAD~4    # или git rebase -i main
pick   a1b2c3d feat(cart): add quantity selector
fixup  e4f5a6b fix typo
reword 7c8d9e0 wip
drop   1f2a3b4 console.log debugging
КомандаДействие
pickОставить коммит
rewordОставить, изменить сообщение
editОстановиться, чтобы изменить содержимое (разбить коммит, дописать файл)
squashСлить с предыдущим, объединить сообщения
fixupСлить с предыдущим, сообщение отбросить
dropУдалить коммит

Связка fixup-коммитов и --autosquash позволяет исправлять конкретный коммит без ручного редактирования списка:

git commit --fixup=a1b2c3d          # создаст "fixup! feat(cart): add quantity selector"
git rebase -i --autosquash main     # fixup-коммит автоматически встанет после a1b2c3d

Полезные варианты rebase

# Перенести ветку с одной базы на другую: коммиты feature, которых нет в old-base, — на main
git rebase --onto main old-base feature

# Stacked branches: при rebase нижней ветки обновить указатели зависимых веток (Git 2.38+)
git rebase --update-refs main

# Исправить последний коммит (сообщение или забытый файл)
git add forgotten-file.ts
git commit --amend --no-edit

Merge vs rebase vs squash

На GitHub и GitLab при вливании PR есть три варианта, и выбор между ними — частый вопрос.

СпособИстория в mainПлюсыМинусы
Merge commitНелинейная, видны веткиТочная топология, легко откатить фичу целиком (revert -m 1)«Рельсы» в графе, шумные WIP-коммиты попадают в main
Squash and mergeЛинейная, 1 коммит = 1 PRЧистый main, удобный revert, сообщение коммита = заголовок PRТеряются атомарные коммиты внутри PR, ветку нельзя продолжать после мержа
Rebase and mergeЛинейная, все коммиты PRСохраняет атомарные коммиты, удобно для bisectТребует дисциплины: каждый коммит должен быть осмысленным и собираться

Практичный ответ на собеседовании:

  • Squash — дефолт для коротких фича-веток в trunk-based: в PR можно коммитить как угодно, в main попадает аккуратный коммит.
  • Rebase-merge — когда команда пишет атомарные коммиты и ценит детальную историю (open source, библиотеки).
  • Merge commit — для долгоживущих веток (release → main, синхронизация форков), где важно сохранить связь.
  • Свою фича-ветку обновляют от main через rebase, а не через merge main, чтобы PR не был замусорен merge-коммитами.

Разрешение конфликтов

Анатомия конфликта

<<<<<<< HEAD
const TIMEOUT = 5000;
||||||| merged common ancestor
const TIMEOUT = 3000;
=======
const TIMEOUT = 10_000;
>>>>>>> feature/slow-network

Средний блок (общий предок) показывается при git config --global merge.conflictstyle zdiff3. С ним видно, что изменил каждый: здесь обе стороны поменяли 3000, значит надо договориться о значении, а не выбирать одну сторону вслепую.

ours и theirs при rebase

Операцияourstheirs
git merge feature (на main)main (текущая ветка)feature
git rebase main (на feature)main (новая база)ваши коммиты из feature

При rebase Git сначала переключается на новую базу и применяет поверх неё ваши коммиты, поэтому роли меняются местами. git checkout --theirs file.ts во время rebase берёт вашу версию.

Lock-файлы

package-lock.json и pnpm-lock.yaml не мёржат руками:

git checkout --theirs package-lock.json   # взять любую сторону
npm install                               # перегенерировать по объединённому package.json
git add package-lock.json

Повторяющиеся конфликты

При длинном rebase одни и те же конфликты могут возникать снова. rerere (reuse recorded resolution) запоминает разрешение и применяет его автоматически:

git config --global rerere.enabled true

Как снижать число конфликтов

  • Короткоживущие ветки и частый rebase от main.
  • Автоформатирование (Prettier) в pre-commit: конфликты из-за пробелов и кавычек исчезают.
  • Массовые рефакторинги (переименования, переформатирование) — отдельными PR, согласованными с командой.

Отмена изменений и восстановление

Карта команд

ЗадачаКомандаПереписывает историю?
Отменить правки файла в рабочей директорииgit restore file.tsНет
Убрать файл из индексаgit restore --staged file.tsНет
Отменить последний коммит, оставив изменения в индексеgit reset --soft HEAD~1Да
Отменить коммит, оставив изменения в файлахgit reset HEAD~1 (--mixed)Да
Полностью выбросить коммит и измененияgit reset --hard HEAD~1Да
Отменить запушенный коммитgit revert <sha>Нет, создаёт новый коммит
Отменить merge commitgit revert -m 1 <merge-sha>Нет

reset

reset двигает указатель текущей ветки на указанный коммит и в зависимости от режима синхронизирует индекс и рабочую директорию:

              HEAD/ветка   Index    Working tree
--soft           ✔           —          —
--mixed          ✔           ✔          —
--hard           ✔           ✔          ✔

--hard — единственная команда из списка, которая может безвозвратно удалить незакоммиченные изменения: их нет в reflog.

revert

revert создаёт коммит с обратным диффом. История не переписывается, поэтому это единственный безопасный способ отменить то, что уже в общей ветке.

Нюанс с merge commit: у него два родителя, и -m 1 говорит «считать основной линией первого родителя (main)». После такого revert повторный merge той же ветки не вернёт изменения: Git считает, что они уже влиты. Чтобы вернуть фичу, нужно сделать revert самого revert-коммита.

reflog

Reflog — локальный журнал всех перемещений HEAD и веток. Именно он спасает после неудачного reset или rebase:

git reflog
# e4f5a6b HEAD@{0}: reset: moving to HEAD~3
# 9a8b7c6 HEAD@{1}: commit: feat: add checkout form
# ...

git reset --hard HEAD@{1}           # вернуть ветку в состояние до reset
git branch rescue 9a8b7c6           # или создать ветку на потерянном коммите

Записи reflog живут 90 дней для достижимых коммитов и 30 дней для недостижимых (настройки gc.reflogExpire и gc.reflogExpireUnreachable). Reflog локальный: на сервер он не пушится, и после клонирования его нет.

stash и worktree

git stash push -u -m "wip: filters"   # -u — включить неотслеживаемые файлы
git stash list
git stash pop                         # применить и удалить из стека
git stash apply stash@{1}             # применить, оставив в стеке

Если нужно срочно сделать hotfix, не трогая текущую работу, удобнее worktree: вторая рабочая директория того же репозитория на другой ветке.

git worktree add ../hotfix main
cd ../hotfix && git switch -c hotfix/payment-crash

Стратегии ветвления

GitFlow

main      ─●─────────────────●─────────●──   (только релизы, теги)
            \               / \       /
release      \         ●───●   \     /
              \       /         \   /
develop   ─────●──●──●───●───────●─●──
                \   /     \     /
feature          ●─●       ●───●
hotfix                              (от main, вливается в main и develop)
  • Ветки: main, develop, feature/*, release/*, hotfix/*.
  • Подходит для продуктов с редкими версионированными релизами: мобильные приложения, коробочное ПО, библиотеки с поддержкой нескольких мажорных версий.
  • Минусы: долгоживущие ветки, большие конфликты, медленная доставка. Сам автор GitFlow рекомендует для веб-приложений с непрерывной доставкой более простые схемы.

GitHub Flow

  • Одна долгоживущая ветка main, всегда готовая к деплою.
  • Фича-ветка → PR → ревью и CI → merge → деплой.
  • Подходит большинству веб-команд.

Trunk-based development

  • Все интегрируются в main (trunk) минимум раз в день; ветки живут часы, максимум пару дней.
  • Незаконченные фичи попадают в production выключенными за feature flags: деплой отделён от релиза (подробнее — в статье про стратегии деплоя).
  • Требует сильного CI: быстрые тесты на каждый PR, обязательные проверки перед merge, часто merge queue.
  • Релизные ветки допустимы как «срез» для стабилизации, но фиксы делаются в main и переносятся через cherry-pick.

Как выбрать

СитуацияСтратегия
Веб-приложение с continuous deploymentTrunk-based или GitHub Flow
Мобильное приложение с релизами через сторGitHub Flow + release-ветки или GitFlow
Библиотека с поддержкой v2 и v3main + ветки поддержки v2.x
Монорепо с десятками командTrunk-based + merge queue + CODEOWNERS

Именование веток

Распространённое соглашение: type/ticket-short-description, например feat/UI-142-date-picker, fix/UI-201-modal-focus-trap. Префикс помогает автоматике (лейблы, правила CI), номер задачи — связи с трекером.


Коммиты, хуки и версионирование

Атомарные коммиты

Хороший коммит делает одну логическую вещь, собирается и проходит тесты. Тогда его можно отдельно откатить, перенести через cherry-pick и использовать в bisect. Переименование и изменение логики лучше разносить в разные коммиты: ревьюеру проще читать дифф.

Conventional Commits

feat(date-picker): add range selection
fix(modal): restore focus to trigger on close
refactor(button)!: rename `kind` prop to `variant`

BREAKING CHANGE: `kind` prop removed, use `variant`.
ТипВлияние на semver
fixpatch (1.4.2 → 1.4.3)
featminor (1.4.2 → 1.5.0)
! или BREAKING CHANGE: в футереmajor (1.4.2 → 2.0.0)
docs, chore, refactor, test, ci, style, perfбез релиза (настраивается)

На основе этих коммитов semantic-release вычисляет версию, генерирует changelog и публикует пакет. Changesets работает иначе: разработчик в PR добавляет файл с описанием изменения и типом bump. Этот подход популярнее в монорепо и библиотеках компонентов.

Git hooks через husky и lint-staged

npm i -D husky lint-staged @commitlint/cli @commitlint/config-conventional
npx husky init
# .husky/pre-commit
npx lint-staged

# .husky/commit-msg
npx --no -- commitlint --edit "$1"
// package.json
{
  "lint-staged": {
    "*.{ts,tsx,vue}": ["eslint --fix", "prettier --write"],
    "*.{css,scss}": ["stylelint --fix", "prettier --write"]
  }
}
// commitlint.config.js
export default { extends: ['@commitlint/config-conventional'] };

Хуки локальные и обходятся через --no-verify, поэтому те же проверки обязательно дублируются в CI. Хуки дают быструю обратную связь, CI — гарантию.


Pull requests и защита веток

Git-workflow в команде живёт в основном в PR, поэтому вопросы о нём часто переходят в вопросы о ревью.

Хороший PR

  • Маленький: до ~400 строк изменений. Большие PR ревьюят поверхностно.
  • Одна цель; рефакторинг и фича — отдельными PR.
  • Описание: что и зачем, как проверить, скриншоты или видео для UI-изменений, ссылка на задачу.
  • Draft PR для раннего фидбэка по подходу.
  • Для больших фич — stacked PRs: цепочка зависимых маленьких PR (git rebase --update-refs упрощает поддержку стека).

Защита main

  • Branch protection / rulesets: запрет прямого push, обязательный PR, минимум N аппрувов, обязательные статус-чеки (lint, typecheck, unit, e2e, visual regression), требование актуальности ветки.
  • CODEOWNERS — автоматически назначает ревьюеров по путям:
# .github/CODEOWNERS
/packages/ui/          @acme/design-system
/packages/ui/tokens/   @acme/design-system @acme/design
*.css                  @acme/frontend-platform
  • Merge queue — PR вливаются по очереди, каждый проверяется поверх актуального main вместе с PR перед ним. Это убирает ситуацию «каждый PR зелёный, а main после двух мержей красный».
  • Подписанные коммиты (GPG/SSH) — требование в регулируемых средах.

Поиск по истории и отладка

git bisect

Бинарный поиск коммита, который внёс регрессию. Для 1000 коммитов нужно около 10 проверок.

git bisect start
git bisect bad                 # текущий коммит сломан
git bisect good v2.3.0         # в этом релизе всё работало
# Git переключает на середину — проверяете и отвечаете:
git bisect good   # или git bisect bad
# ...через ~log2(n) шагов Git называет виновный коммит
git bisect reset

Автоматический режим со скриптом или тестом:

git bisect start HEAD v2.3.0
git bisect run npx vitest run src/components/DatePicker.test.ts

Коды выхода: 0 — good, 1–127 (кроме 125) — bad, 125 — пропустить коммит (например, не собирается). Поэтому атомарные, собираемые коммиты делают bisect полезным.

blame и поиск по содержимому

git blame -w -C src/Button.tsx         # -w игнорирует пробелы, -C ищет перенос строк из других файлов
git log -S "useLegacyTheme" --oneline  # pickaxe: коммиты, где строка появилась или исчезла
git log -G "z-index:\s*9+" -p          # коммиты, где изменились строки, совпадающие с regex
git log --follow -p -- src/Modal.tsx   # история файла с учётом переименований
git log --graph --oneline --all        # граф веток в терминале

Массовое переформатирование ломает blame: каждая строка указывает на коммит «prettier everything». Решение — файл .git-blame-ignore-revs со списком таких коммитов:

git config blame.ignoreRevsFile .git-blame-ignore-revs

GitHub учитывает этот файл автоматически.

cherry-pick

git cherry-pick -x a1b2c3d     # -x добавит в сообщение "(cherry picked from commit a1b2c3d)"
git cherry-pick A^..B          # диапазон коммитов от A до B включительно

Типичное применение — перенести фикс из main в release-ветку. Cherry-pick создаёт новый коммит с тем же диффом, поэтому при последующем merge веток Git может показать конфликт или дубль.


Git в CI и больших репозиториях

Глубина клонирования в CI

actions/checkout по умолчанию делает shallow clone с fetch-depth: 1 (только последний коммит). Этого достаточно для сборки, но ломаются инструменты, которым нужна история:

- uses: actions/checkout@v4
  with:
    fetch-depth: 0   # полная история: нужна changesets, semantic-release, nx affected, turbo --filter=[origin/main]

Большие репозитории и монорепо

ИнструментЧто делает
git clone --depth 50Shallow clone, ограниченная история
git clone --filter=blob:nonePartial clone: история полная, содержимое файлов докачивается по требованию
git sparse-checkout set apps/web packages/uiВ рабочей директории только нужные папки
Git LFSБольшие бинарники (видео, дизайн-исходники) хранятся вне репозитория, в Git — только указатели
SubmodulesВложенный репозиторий, закреплённый на конкретном коммите; неудобны в повседневной работе, в монорепо их обычно заменяют workspaces

Подробнее про организацию кода — в статье про монорепозитории.

Что не должно попадать в Git

  • .env с секретами, ключи, токены. Если секрет закоммичен, удалить его из истории недостаточно: ключ нужно немедленно отозвать и перевыпустить, потому что он уже мог попасть в форки и клоны.
  • node_modules, dist, кэши сборки, артефакты тестов — через .gitignore.
  • Lock-файл, наоборот, коммитят всегда: он гарантирует воспроизводимую установку в CI.

Типовые сценарии с собеседований

«Закоммитил в main вместо фича-ветки (ещё не запушил)»

git branch feat/my-work        # ветка на текущем коммите сохраняет работу
git reset --hard origin/main   # вернуть main к состоянию remote
git switch feat/my-work

«Нужно отменить коммит, который уже в main и задеплоен»

git revert <sha> → PR → merge. Никакого reset и force push в общую ветку.

«Сделал reset --hard и потерял коммиты»

git reflog → найти хеш до reset → git reset --hard <sha> или git branch rescue <sha>.

«Ветка отстала от main на 40 коммитов, PR в конфликтах»

git fetch origin
git rebase origin/main          # разрешить конфликты, git rebase --continue
git push --force-with-lease

Если rebase пошёл не так — git rebase --abort возвращает всё как было.

«Фикс из main нужен в релизной ветке»

git switch release/2.4
git cherry-pick -x <sha-фикса>

«В PR 15 коммитов вида “fix”, “wip”, “fix again”»

git rebase -i main → fixup/squash → осмысленные атомарные коммиты. Или squash merge при вливании, если так принято в команде.

«Регрессия появилась где-то за последний месяц»

git bisect start HEAD <тег месячной давности> + git bisect run <тест>.

«Случайно закоммитил API-ключ»

Сначала отозвать ключ. Затем удалить файл из истории (git filter-repo или BFG), сделать force push и попросить команду переклонировать репозиторий. Порядок важен: очистка истории не отменяет утечку.


Ключевые тезисы для интервью

  • Коммит — неизменяемый снимок дерева со ссылкой на родителей; ветка — подвижный указатель на коммит, HEAD — указатель на текущую ветку.
  • Fast-forward сдвигает указатель без нового коммита; при расхождении веток выполняется трёхстороннее слияние через merge base и создаётся merge commit.
  • Rebase пересоздаёт коммиты с новыми хешами поверх новой базы; публичную историю не переписывают, свою ветку пушат через --force-with-lease.
  • Squash merge — дефолт для коротких веток, rebase-merge — для атомарной истории, merge commit — для долгоживущих веток.
  • reset переписывает историю и подходит только для локальных коммитов; для запушенных используют revert, для merge commit — revert -m 1.
  • Reflog хранит перемещения HEAD и спасает после неудачного reset или rebase; незакоммиченные изменения после reset --hard не восстанавливаются.
  • При rebase ours — новая база, theirs — ваши коммиты; lock-файлы не мёржат руками, а перегенерируют.
  • Trunk-based с короткими ветками и feature flags — стандарт для веб-команд с continuous deployment; GitFlow — для редких версионированных релизов.
  • Conventional Commits делают историю машиночитаемой и позволяют автоматизировать semver и changelog через semantic-release или changesets.
  • Хуки (husky, lint-staged, commitlint) дают быструю обратную связь, но обходятся через --no-verify, поэтому CI с обязательными проверками и branch protection — основная гарантия.
  • git bisect run находит регрессию за log₂(n) шагов, если коммиты атомарные и собираются.
  • Закоммиченный секрет сначала отзывают и только потом вычищают из истории.

Заключение

Git на собеседовании проверяют через сценарии: что вы сделаете, если история сломана, ветка отстала или в main попал баг. Чтобы уверенно отвечать, достаточно держать в голове три вещи:

  1. Коммиты неизменяемы, ветки — указатели, а «переписывание истории» создаёт новые коммиты.
  2. Публичную историю отменяют через revert, свою локальную приводят в порядок через rebase -i и reset, а reflog страхует от ошибок.
  3. Командный процесс держится на коротких ветках, маленьких PR, Conventional Commits и обязательных проверках CI, а не на дисциплине отдельных людей.

Потренируйтесь в песочнице: создайте две расходящиеся ветки, сделайте merge, rebase и squash, намеренно потеряйте коммит через reset --hard, восстановите его через reflog и найдите «баг» через git bisect run.

Полезные ссылки