Git: ветки, rebase и командный workflow
Git есть в каждом проекте, но на собеседовании быстро становится видно, кто понимает его модель, а кто помнит пять команд. Вопросы «merge или rebase», «как откатить запушенный коммит», «какой у вас был branching workflow» задают почти всегда. В статье разобраны внутреннее устройство Git, слияние и переписывание истории, отмена изменений, стратегии ветвления, соглашения о коммитах и инструменты поиска багов в истории.
Содержание
- Как Git хранит данные
- Ветки и слияние
- Rebase и переписывание истории
- Merge vs rebase vs squash
- Разрешение конфликтов
- Отмена изменений и восстановление
- Стратегии ветвления
- Коммиты, хуки и версионирование
- Pull requests и защита веток
- Поиск по истории и отладка
- Git в CI и больших репозиториях
- Типовые сценарии с собеседований
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Как 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
| Операция | ours | theirs |
|---|---|---|
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 commit | git 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 deployment | Trunk-based или GitHub Flow |
| Мобильное приложение с релизами через стор | GitHub Flow + release-ветки или GitFlow |
| Библиотека с поддержкой v2 и v3 | main + ветки поддержки 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 |
|---|---|
fix | patch (1.4.2 → 1.4.3) |
feat | minor (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 50 | Shallow clone, ограниченная история |
git clone --filter=blob:none | Partial 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 попал баг. Чтобы уверенно отвечать, достаточно держать в голове три вещи:
- Коммиты неизменяемы, ветки — указатели, а «переписывание истории» создаёт новые коммиты.
- Публичную историю отменяют через
revert, свою локальную приводят в порядок черезrebase -iиreset, а reflog страхует от ошибок. - Командный процесс держится на коротких ветках, маленьких PR, Conventional Commits и обязательных проверках CI, а не на дисциплине отдельных людей.
Потренируйтесь в песочнице: создайте две расходящиеся ветки, сделайте merge, rebase и squash, намеренно потеряйте коммит через reset --hard, восстановите его через reflog и найдите «баг» через git bisect run.