> Git для повседневной работы: команды и сценарии, которые сэкономят часы

Git - это инструмент, без которого невозможно представить современную разработку. Но многие используют лишь базовые команды вроде add, commit, push, pull, и этого хватает до первого сложного сценария. А потом начинаются часы гугления, паника и попытки откатить изменения через git reset --hard, что часто приводит к потере работы.

В этой статье разберём команды и сценарии, которые реально экономят время каждый день. Вы узнаете, как правильно откатывать изменения, работать с несколькими ветками, разрешать конфликты и поддерживать чистую историю коммитов. Всё - с практическими примерами и пояснениями.

Топ-10 команд Git, которые нужны каждому разработчику

Если вы освоите эти команды, вы закроете 90% повседневных задач.

1. git status - ваш лучший друг

Казалось бы, банальность, но многие недооценивают. git status показывает, что изменилось, какие файлы в индексе, какие не отслеживаются. Привычка вызывать git status перед любыми операциями спасёт от случайных add или commit не тех файлов.

BASH
git status

2. git log --oneline --graph --decorate - визуализация истории

Обычный git log слишком многословен. Используйте сокращённый вариант, чтобы видеть историю веток, коммиты и указатели HEAD.

BASH
git log --oneline --graph --decorate -10

3. git stash - временно спрятать изменения

Вы работаете над фичей, а тут срочный багфикс. Не хочется коммитить незавершённую работу. git stash убирает изменения в сторону, а git stash pop возвращает их обратно.

BASH
git stash
git stash pop

Полезные вариации: git stash list, git stash apply (не удаляет из стека), git stash drop.

4. git rebase -i - интерактивный ребейз

Команда для переписывания истории: объединение коммитов, изменение сообщений, удаление ненужных. Это основа для squash и чистого PR.

BASH
git rebase -i HEAD~3

5. git cherry-pick - перенос коммита в другую ветку

Нужно применить конкретный коммит из другой ветки? cherry-pick делает это без слияния всей ветки.

BASH
git cherry-pick <commit-hash>

6. git revert - безопасный откат

В отличие от reset, revert создаёт новый коммит, который отменяет изменения предыдущего. Это безопасно для публичных веток, так как история не переписывается.

BASH
git revert <commit-hash>

7. git reset - отмена изменений (осторожно!)

git reset перемещает HEAD и индекс. Варианты:

• git reset --soft HEAD~1 - отменить коммит, но оставить изменения в индексе.

• git reset --mixed HEAD~1 (по умолчанию) - отменить коммит и индекс, изменения остаются в рабочей директории.

• git reset --hard HEAD~1 - полностью отменить изменения (опасно, теряете всё).

Используйте --hard только если уверены, что изменения не нужны.

8. git branch -D и git push origin --delete - удаление веток

Локальные и удалённые ветки, которые больше не нужны, засоряют репозиторий. Удаляйте их без сожаления.

BASH
git branch -D feature/old
git push origin --delete feature/old

9. git diff - просмотр изменений

Перед коммитом полезно посмотреть, что именно вы меняете. git diff показывает изменения в рабочей директории, git diff --staged - в индексе.

BASH
git diff
git diff --staged

10. git bisect - поиск проблемного коммита

Когда баг появился неизвестно когда, git bisect поможет найти виновника бинарным поиском. Запускаете, указываете плохой и хороший коммит, и Git шагает по истории, пока вы тестируете.

BASH
git bisect start
git bisect bad
git bisect good <hash>

Работа с конфликтами: пошаговый алгоритм разрешения

Конфликты - неизбежная часть работы в команде. Пугаться их не стоит: при правильном подходе они решаются за пару минут.

Шаг 1. Понять, что произошло

При слиянии или ребейзе Git сообщает о конфликте и помечает файлы. Выполните git status, чтобы увидеть список конфликтных файлов.

Шаг 2. Открыть файл и найти маркеры

В конфликтном файле вы увидите:

<<<<<<< HEAD
ваши изменения
=======
изменения из другой ветки
>>>>>>> branch-name

Шаг 3. Решить, что оставить

Вручную отредактируйте файл: удалите маркеры, оставьте нужные строки. Иногда нужно объединить оба варианта.

Шаг 4. Добавить файл в индекс

После редактирования выполните git add <file> для каждого разрешённого файла.

Шаг 5. Завершить операцию

• Если это было слияние: git commit (Git предложит готовое сообщение).

• Если это был ребейз: git rebase --continue.

• Если хотите отменить операцию: git merge --abort или git rebase --abort.

Советы по минимизации конфликтов

• Чаще делайте git pull --rebase, чтобы ваша ветка не отставала от основной.

• Разбивайте изменения на маленькие коммиты, чтобы конфликты были локальными.

• Обсуждайте с командой, кто какие файлы трогает.

Практические сценарии: откат изменений, работа с несколькими ветками, squash коммитов

Теперь применим команды в реальных ситуациях.

Сценарий 1: Откат изменений без потери работы

Вы случайно закоммитили не тот файл или поняли, что коммит содержит ошибку. Нужно откатить, но сохранить изменения для дальнейшей работы.

Ситуация: последний коммит содержит лишний файл.

1. git log --oneline -3 - посмотрите хэш коммита.

2. git reset --soft HEAD~1 - отменяем коммит, изменения остаются в индексе.

3. git reset HEAD <file> - убираем лишний файл из индекса.

4. git commit -m "Правильное сообщение" - создаём новый коммит без лишнего файла.

Если нужно откатить уже запушенный коммит, используйте git revert - это безопасно для команды.

Сценарий 2: Работа с несколькими ветками одновременно

Вы работаете над фичей, но нужно срочно переключиться на другую задачу. Незавершённые изменения мешают переключению.

Решение: используйте git stash.

BASH
git stash push -m "WIP: feature login"
git checkout main
git pull
git checkout -b hotfix/urgent
# делаем фикс, коммитим, пушим
git checkout feature/login
git stash pop

Если изменений много, можно сохранить их в отдельную ветку и переключиться:

BASH
git checkout -b wip/feature-login
git commit -am "WIP"
git checkout main
# ... работаем
git checkout wip/feature-login
git rebase main

Сценарий 3: Squash коммитов перед PR

Вы наработали 15 коммитов с сообщениями типа "fix typo", "wip", "oops". Перед созданием PR хочется объединить их в один аккуратный коммит.

Решение: интерактивный ребейз.

BASH
git rebase -i HEAD~15

Откроется редактор со списком коммитов. Для каждого, кроме первого, замените pick на squash (или s). Сохраните и закройте. Затем Git попросит ввести новое сообщение коммита - напишите осмысленное.

Если вы уже запушили ветку, после ребейза придётся сделать git push --force-with-lease (не --force, чтобы не перезаписать чужие изменения).

Сценарий 4: Перенос одного коммита из другой ветки

Допустим, в ветке feature/experiment есть коммит с исправлением бага, который нужен в main. Но в экспериментальной ветке много другого кода, который пока не готов.

BASH
git checkout main
git cherry-pick <hash-коммита>

Если возникают конфликты, разрешаете их как обычно. После этого коммит появляется в main с новым хэшем.

Сценарий 5: Отмена слияния, которое ещё не запушено

Вы слили ветку, но поняли, что это было преждевременно. Отменить слияние можно через reset.

BASH
git reset --hard ORIG_HEAD

ORIG_HEAD - это указатель на состояние до слияния. Но будьте осторожны: все изменения, которые были в слитой ветке, потеряются, если они не были закоммичены в других местах.

Заключение

Git - это не магия, а набор инструментов. Чем лучше вы знаете команды, тем быстрее решаете задачи и меньше боитесь сломать репозиторий. Начните с топ-10 команд, отработайте алгоритм разрешения конфликтов и постепенно внедряйте сценарии из статьи в повседневную работу.

Помните: всегда проверяйте git status перед опасными операциями, используйте revert вместо reset --hard для публичных веток, и не стесняйтесь обращаться к документации - даже опытные разработчики иногда забывают флаги.

Экономьте часы, а не тратьте их на поиск решений в интернете. Git - ваш друг, если знать, как с ним разговаривать.