2.1Коммит

Соберёшь commit из выбранных изменений и проверишь содержимое index до записи. Разберёшь атомарное сообщение, Conventional Commits и последствия amend после публикации.

status -sb: две колонки и строка ветки

Пример на всю главу: клиент погоды на Go, где fetch из client.go ходит в сервис через http.Get. Первый коммит ff79116 уже в origin. Аня добавляет клиенту таймаут, по ходу вставляет отладочную печать, собирает бинарь, добавляет client.go в индекс и только потом замечает в тексте ошибки опечатку fecth. Исправляет её и дописывает строку в README.md.

$ git status -sb
## main...origin/main
 M README.md
MM client.go
?? weather

Обычный git status тратит на это семнадцать строк. -s (short) оставляет по строке на файл, -b (branch) добавляет строку ветки. Левая буква сравнивает HEAD с индексом: это добавлено и уйдёт в коммит. Правая сравнивает индекс с диском: это есть в файле, но в коммит не попадёт. Пробел значит, что разницы нет. У client.go заняты обе колонки: в индексе версия с таймаутом, на диске она же с исправленной опечаткой (три версии в трёх снимках, как в главе 1.3). Бинарь weather индексу неизвестен, отсюда два вопроса.

При конфликте буквы значат другое, там встречается UU (глава 3.2). Строка ## main...origin/main называет ветку и её upstream (глава 4.1). Появятся локальные коммиты, и в конце встанет [ahead 2]; разойдутся ветки, будет [ahead 1, behind 1]. Сервер при этом никто не спрашивает, счёт идёт по локальной origin/main после последнего fetch или push. Скриптам нужен --porcelain: те же коды, но формат не меняется между версиями, цвета нет, пути от корня репозитория.

А git add . сейчас забрал бы и бинарь:

$ git add --dry-run .
add 'README.md'
add 'client.go'
add 'weather'
$ du -h weather
7.9M    weather

Восемь мегабайт остались бы в истории навсегда (глава 1.4). Артефакты сборки прячут через .gitignore (глава 2.2), а пока его нет, файлы добавляют по именам.

Перед коммитом: diff --staged и commit -v

MM значит, что коммит возьмёт версию из индекса. Какую именно, показывает git diff --staged (глава 1.3):

$ git diff --staged
diff --git a/client.go b/client.go
index d419f97..65d9d40 100644
--- a/client.go
+++ b/client.go
@@ -3,10 +3,14 @@ package main
 import (
        "fmt"
        "net/http"
+       "time"
 )

+var client = &http.Client{Timeout: 5 * time.Second}
+
 func fetch(url string) (*http.Response, error) {
-       resp, err := http.Get(url)
+       resp, err := client.Get(url)
+       fmt.Println("DEBUG fetch", url)
        if err != nil {
                return nil, fmt.Errorf("fecth %s: %w", url, err)
        }

В индексе отладочная печать, а fecth на месте: опечатку исправили после add. Тот же дифф можно держать перед глазами, пока пишешь сообщение: git commit -v (verbose) кладёт его в редактор под шаблон.

# Untracked files:
#       weather
#
# ------------------------ >8 ------------------------
# Do not modify or remove the line above.
# Everything below it will be ignored.
diff --git a/client.go b/client.go
index d419f97..65d9d40 100644

Всё ниже линии с ножницами в сообщение не попадёт; включить так навсегда можно настройкой commit.verbose. Пустое сообщение отменяет коммит, и Аня так и поступила, решив собрать два коммита: опечатка отдельно, таймаут отдельно, отладка никуда. Сначала она возвращает индекс к HEAD, не трогая диск (restore разобран в главе 2.2):

$ git restore --staged client.go
$ git status -s
 M README.md
 M client.go
?? weather

add -p: коммит из части файла

git add -p (patch) режет дифф индекса и рабочей копии на куски и про каждый спрашивает, добавлять ли его. Правки, между которыми не больше шести неизменённых строк, попадают в один кусок: три строки контекста вокруг каждой смыкаются. У Ани кусок получился один (вывод git 2.54):

$ git add -p client.go
diff --git a/client.go b/client.go
index d419f97..0763f8f 100644
--- a/client.go
+++ b/client.go
@@ -3,12 +3,16 @@ package main
 import (
        "fmt"
        "net/http"
+       "time"
 )

+var client = &http.Client{Timeout: 5 * time.Second}
+
 func fetch(url string) (*http.Response, error) {
-       resp, err := http.Get(url)
+       resp, err := client.Get(url)
+       fmt.Println("DEBUG fetch", url)
        if err != nil {
-               return nil, fmt.Errorf("fecth %s: %w", url, err)
+               return nil, fmt.Errorf("fetch %s: %w", url, err)
        }
        return resp, nil
 }
(1/1) Stage this hunk [y,n,q,a,d,s,e,p,P,?]? s
Split into 4 hunks.
@@ -3,5 +3,6 @@ package main
 import (
        "fmt"
        "net/http"
+       "time"
 )

(1/4) Stage this hunk [y,n,q,a,d,k,K,j,J,g,/,e,p,P,?]? n
@@ -6,3 +7,5 @@
 )

+var client = &http.Client{Timeout: 5 * time.Second}
+
 func fetch(url string) (*http.Response, error) {
(2/4) Stage this hunk [y,n,q,a,d,k,K,j,J,g,/,e,p,P,?]? n
@@ -8,3 +11,4 @@
 func fetch(url string) (*http.Response, error) {
-       resp, err := http.Get(url)
+       resp, err := client.Get(url)
+       fmt.Println("DEBUG fetch", url)
        if err != nil {
(3/4) Stage this hunk [y,n,q,a,d,k,K,j,J,g,/,e,p,P,?]? n
@@ -10,5 +14,5 @@
        if err != nil {
-               return nil, fmt.Errorf("fecth %s: %w", url, err)
+               return nil, fmt.Errorf("fetch %s: %w", url, err)
        }
        return resp, nil
 }
(4/4) Stage this hunk [y,n,q,a,d,K,J,g,/,e,p,P,?]? y

Ответ s (split) разрезал кусок на четыре. Три Аня пропустила, четвёртый, с опечаткой, добавила, и git записал выбранное в индекс. После разрезания s нет ни у одного куска: каждый из них одна сплошная правка. У четвёртого нет ещё k и j: они ведут к нерешённым кускам, а таких не осталось.

$ git status -s
 M README.md
MM client.go
?? weather
$ git diff --staged --stat
 client.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

Зачем резать, если можно закоммитить всё разом? Атомарным называют коммит с одним логическим изменением, причём законченным: после коммита проект собирается и тесты проходят. Опечатка и таймаут между собой не связаны, значит, коммитов два. Окупается это там, где с историей работают:

• Ревью. Коммит читается как одна мысль, не надо гадать, какая строка к какой задаче.
• Откат. Окажется таймаут мал, его откатят через git revert (глава 5.1), а исправленная опечатка останется.
• Поиск поломки. git bisect (глава 5.3) указывает на коммит целиком, и чем он меньше, тем точнее ответ. Несобирающийся коммит проверить нельзя, его пропускают через git bisect skip, и граница размывается.
• Перенос. Исправление уходит в релизную ветку через cherry-pick (глава 3.3) без недоделанной фичи.

Атомарный не значит маленький. Переименование функции со всеми вызовами остаётся одним коммитом, даже если задело сорок файлов: разрежь его, и промежуточный коммит не соберётся.

Собираться должен код из индекса, а на диске у Ани лежит больше: таймаут и отладка. git stash push --keep-index прячет всё недобавленное и оставляет на диске ровно версию из индекса:

$ git stash push --keep-index -q
$ git status -s
M  client.go
?? weather
$ go build ./... && go vet ./...
$ git stash pop -q
$ git status -s
 M README.md
MM client.go
?? weather
$ git commit -m "Исправить опечатку в тексте ошибки"
[main b7e8b34] Исправить опечатку в тексте ошибки
 1 file changed, 1 insertion(+), 1 deletion(-)

Сборка и go vet промолчали; в проекте с тестами сюда же добавляют go test ./.... Неотслеживаемые файлы stash без -u не прячет, и в сборке они участвуют. Как устроен stash, разобрано в главе 2.2.

Когда s не помогает: правка куска вручную

Второй проход за таймаутом. Импорт и переменную client Аня берёт как есть, а в третьем куске замена http.Get стоит вплотную к отладке, и на него она отвечает e (edit):

$ git add -p client.go     # s, затем y для импорта и y для переменной
@@ -8,5 +11,6 @@
 func fetch(url string) (*http.Response, error) {
-       resp, err := http.Get(url)
+       resp, err := client.Get(url)
+       fmt.Println("DEBUG fetch", url)
        if err != nil {
                return nil, fmt.Errorf("fetch %s: %w", url, err)
        }
(3/3) Stage this hunk [y,n,q,a,d,K,J,g,/,e,p,P,?]? e

Git 2.54 открывает в редакторе файл .git/addp-hunk-edit.diff и дописывает в конец правила:

# Manual hunk edit mode -- see bottom for a quick guide.
@@ -8,5 +11,6 @@
 func fetch(url string) (*http.Response, error) {
-       resp, err := http.Get(url)
+       resp, err := client.Get(url)
+       fmt.Println("DEBUG fetch", url)
        if err != nil {
                return nil, fmt.Errorf("fetch %s: %w", url, err)
        }
# ---
# To remove '-' lines, make them ' ' lines (context).
# To remove '+' lines, delete them.
# Lines starting with # will be removed.
# If the patch applies cleanly, the edited hunk will immediately be marked for staging.
# If it does not apply cleanly, you will be given an opportunity to
# edit again.  If all lines of the hunk are removed, then the edit is
# aborted and the hunk is left unchanged.

Правится не файл, а патч, который git потом наложит на индекс. Лишнюю строку с плюсом удаляют. Удаление, которое не нужно, превращают в контекст: минус меняют на пробел. Контекст не трогают: сотри первую или среднюю его строку, и git ответит patch does not apply и спросит Edit again (saying "no" discards!) [y/n]?. Аня удаляет строку с DEBUG, и в индексе оказывается таймаут без отладки:

$ git diff --staged
diff --git a/client.go b/client.go
index 1dabf4c..14ad1b7 100644
--- a/client.go
+++ b/client.go
@@ -3,10 +3,13 @@ package main
 import (
        "fmt"
        "net/http"
+       "time"
 )

+var client = &http.Client{Timeout: 5 * time.Second}
+
 func fetch(url string) (*http.Response, error) {
-       resp, err := http.Get(url)
+       resp, err := client.Get(url)
        if err != nil {
                return nil, fmt.Errorf("fetch %s: %w", url, err)
        }

На диске сверх индекса остались отладка и строка в README. Строка описывает тот же таймаут и едет в тот же коммит, а отладку снимает git restore client.go, копируя файл из индекса на диск. Сообщение набрано в редакторе, о нём следующий раздел.

$ git add README.md
$ git status -s
M  README.md
MM client.go
?? weather
$ git commit
[main 8021ab2] Добавить таймаут HTTP-клиенту
 2 files changed, 5 insertions(+), 1 deletion(-)
$ git restore client.go
$ git status -sb
## main...origin/main [ahead 2]
?? weather

Сообщение коммита

$ git log -1
commit 8021ab2a9cfda1252ce0c908d1baf537288dc5a7
Author: Аня <anya@example.com>
Date:   Tue Sep 1 12:00:00 2026 +0300

    Добавить таймаут HTTP-клиенту

    http.Get ходит через http.DefaultClient, а у него таймаута нет. Если
    сервис погоды принял соединение и молчит, fetch ждёт ответа сколько
    угодно, и main висит вместе с ним. Отдельный клиент с таймаутом
    в 5 секунд обрывает такой запрос с ошибкой.

От сообщения git требует одного: чтобы оно не было пустым. Остальное соглашения, но на них опираются сами инструменты git. Текст до первой пустой строки считается заголовком: его выводит log --oneline, shortlog перечисляет заголовки под именем автора, не склеивая одинаковые (глава 2.3), а format-patch ставит его в тему письма. Документация git commit советует заголовок до 50 символов. Пустая строка после него нужна, иначе к заголовку приклеится следующая:

$ cat title.txt
Добавить таймаут HTTP-клиенту
и вынести клиент в переменную

Тело.
$ git commit -q -F title.txt
$ git log --oneline -1
57e1ac8 Добавить таймаут HTTP-клиенту и вынести клиент в переменную

В теле пишут то, чего нет в диффе. Что поменялось, дифф покажет и так, а почему, знает автор, и то недолго. SubmittingPatches, правила для авторов патчей в сам git, ставит телу три задачи: объяснить, что не так без правки, почему выбранное решение лучше и какие варианты отвергнуты. Строки переносят около 72 символов, как советует заметка Тима Поупа 2008 года: git log строки не переносит и добавляет отступ в четыре пробела, а из 80 колонок терминала за вычетом четырёх слева и четырёх справа остаётся 72.

Заголовок говорит, что делает коммит, а не что делал автор. По-английски пишут в повелительном наклонении, Add timeout, а не Added: SubmittingPatches просит писать так, будто отдаёшь кодовой базе приказ, и сам git пишет так же: Merge branch …, Revert "…". Для русского у git правил нет. Подойдёт инфинитив, «Добавить таймаут HTTP-клиенту», или настоящее время, «HTTP-клиент обрывает запрос через 5 секунд»; «Добавил таймаут» рассказывает уже об авторе. Форму выбирают одну на весь репозиторий.

У сообщения, набранного в редакторе, есть ловушка. Аня пишет:

Выходить с ошибкой, если сервис ответил 5xx

#412: cron считал запуск успешным,
хотя прогноз не пришёл.

$ git commit      # сообщение набрано в редакторе
[main 38995dc] Выходить с ошибкой, если сервис ответил 5xx
 1 file changed, 1 insertion(+)
$ git log -1 --format=%B
Выходить с ошибкой, если сервис ответил 5xx

хотя прогноз не пришёл.

Conventional Commits

Спецификация Conventional Commits 1.0.0 размечает сообщение так, чтобы его могла разобрать программа:

<type>[(scope)][!]: <description>

[body]

[footers]

Тип обязателен: feat для новой возможности, fix для исправления. Остальные разрешены; например, @commitlint/config-conventional, выросший из соглашения Angular, предлагает docs, refactor, test, ci, chore и ещё несколько. В скобках указывают область кода. ! перед двоеточием или строка BREAKING CHANGE: … в конце отмечают несовместимое изменение. Завершающие строки (footers) похожи на git trailers: Refs: #412. История клиента в этом стиле, новые сверху:

feat(client)!: fetch принимает context
feat(client): таймаут 5 секунд для HTTP-запросов
fix(client): опечатка в тексте ошибки

На этом работают release-please и semantic-release: читают коммиты с прошлого релиза, считают следующую версию и собирают из них CHANGELOG. Последняя строка таблицы верна по спецификации, а оба инструмента по умолчанию дают PATCH и на perf, и на revert. Формат проверяет commitlint, в хуке commit-msg (глава 5.3) или в CI. У Go-модуля MAJOR тянет за собой больше, чем тег: с v2 путь модуля обязан кончаться на /v2, а это правка go.mod и всех импортов (глава 4.3).

commit --amend: новый коммит вместо старого

После коммита Аня написала тест на таймаут и поняла, что место ему в том же коммите:

$ git status -sb
## main...origin/main [ahead 2]
?? client_test.go
?? weather
$ git add client_test.go
$ git commit --amend --no-edit
[main 762c9a8] Добавить таймаут HTTP-клиенту
 Date: Tue Sep 1 12:00:00 2026 +0300
 3 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 client_test.go

Хеш у последнего коммита новый. Исправить объект git не может, его имя вычислено из содержимого (глава 1.1). --amend собирает новый коммит: дерево из индекса, как обычно, а родителей, автора и сообщение берёт у текущего (--no-edit принимает сообщение без редактора), и переставляет на него ветку:

$ git cat-file -p 8021ab2 | head -4
tree 5e41332879c8b7445c9385656104435fcc679d07
parent b7e8b34974857cefc6cc9da2d5435eba18f7c5e8
author Аня <anya@example.com> 1788253200 +0300
committer Аня <anya@example.com> 1788253200 +0300

$ git cat-file -p HEAD | head -4
tree ea21ec7b8fd2d1fc3b8c4432d79f50a2054c92ca
parent b7e8b34974857cefc6cc9da2d5435eba18f7c5e8
author Аня <anya@example.com> 1788253200 +0300
committer Аня <anya@example.com> 1788256800 +0300

Родитель тот же, дерево уже с тестом. Время автора осталось от старого коммита, 12:00, коммитер получил 13:00; строку Date: в сводке git печатает, когда автор взят из другого коммита. --reset-author сделал бы автором текущего коммитера.

$ git reflog -3
762c9a8 HEAD@{0}: commit (amend): Добавить таймаут HTTP-клиенту
8021ab2 HEAD@{1}: commit: Добавить таймаут HTTP-клиенту
b7e8b34 HEAD@{2}: commit: Исправить опечатку в тексте ошибки

Старый коммит цел, просто на него не указывает ветка. Reflog помнит его как HEAD@{1}, и пока запись жива, сборка мусора его не тронет (главы 1.4 и 5.2); git reset --soft HEAD@{1} вернул бы ветку назад, оставив тест в индексе (глава 5.1).

Пока 8021ab2 был только у Ани, подмену никто не видел. Теперь ветка уходит на сервер, а следом ещё один amend: в команде приняты Conventional Commits, и Аня переписывает заголовок.

$ git push
To ../origin.git
   ff79116..762c9a8  main -> main
$ git commit --amend     # в редакторе поменяла заголовок
[main 35de720] feat(client): таймаут 5 секунд для HTTP-запросов
 Date: Tue Sep 1 12:00:00 2026 +0300
 3 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 client_test.go
$ git status -sb
## main...origin/main [ahead 1, behind 1]
?? weather
$ git push
To ../origin.git
 ! [rejected]        main -> main (non-fast-forward)
error: failed to push some refs to '../origin.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. If you want to integrate the remote changes,
hint: use 'git pull' before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

762c9a8 и 35de720 для git не отличить от коммитов двух разных людей с общим родителем. Приняв такой push, сервер потерял бы 762c9a8 (глава 4.1).

--amend дотягивается только до последнего коммита. Для более старого делают git commit --fixup=<коммит>, а rebase с флагом --autosquash вклеивает исправление на место (глава 3.3).

$ git status -s
 M README.md
M  client.go
$ git commit -m "Описать запуск в README" README.md
[main f974042] Описать запуск в README
 1 file changed, 1 insertion(+)
$ git status -s
M  client.go

$ git add -p new.go
No changes.
$ git add -N new.go
$ git add -p new.go     # дифф нового файла пропущен
(1/1) Stage addition [y,n,q,a,d,e,p,P,?]? y

$ git commit --amend --no-edit -q
$ git reflog -2
933e609 HEAD@{0}: commit (amend): Комментарий
933e609 HEAD@{1}: commit: Комментарий

$ git pull --no-rebase
Merge made by the 'ort' strategy.
$ git log --oneline --graph
*   f25e023 Merge branch 'main' of ../origin
|\
| * 762c9a8 Добавить таймаут HTTP-клиенту
* | 35de720 feat(client): таймаут 5 секунд для HTTP-запросов
|/
* b7e8b34 Исправить опечатку в тексте ошибки
* ff79116 Первая версия клиента погоды
$ git diff HEAD^1 HEAD

Что стоит запомнить

• Commit записывает index, а не все файлы рабочего каталога.
• git add -p позволяет выбрать отдельные hunks и разделить коммит по смыслу.
• Amend создаёт новый commit object с новым hash.

Частые ошибки

• Не делай amend опубликованного коммита без согласования переписывания общей истории.
• Успешный commit не доказывает, что в index попали только нужные файлы.

## feature/login...origin/feature/login [ahead 1]
MM internal/auth.go

git commit --amend
git push --force