✻ Урок 3.1 · Тема 3: Git и GitHub
Git: история изменений на своей машине
Содержание урока
Как работать с кодом и когда идти дальше
Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:
- Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
- Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
- Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.
Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.
Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.
Зачем это нужно
В первый рабочий день в команде интернет-магазина менеджер сказал: «Тесты храним не на рабочем столе, а в репозитории». Сейчас мы заведём твой perf-lab, и ты поймёшь, что это значит.
Сначала типичная путаница. Допустим, в папке лежат три файла:
$ ls ~/tests
test.py test-final.py test-final-new.py
Вечером тест показывает заметно лучший результат, и все рады. Утром выясняется: сценарий переписали, и он стал слать меньше запросов, а сервис работает как раньше. Какой из трёх файлов запускали, никто не помнит: по именам не понять, чем они отличаются и какой свежее. Честно сравнить прогоны нельзя.
От такой путаницы спасает Git: программа, которая сохраняет выбранные версии файлов и историю их изменения. Она отвечает на вопросы «что поменялось, когда и зачем» и возвращает нужный вариант без копий папок. Для нагрузочного тестирования это ещё и честность: нужно знать, какой версией сценария мерили, поэтому тесты лежат в репозитории. В отчёте ты укажешь версию сценария рядом с условиями запуска и паспортом машины (файл machine.md из урока 1.1, где записано, на каком железе мерили), и читатель поймёт, чем меряли.
Шаг проекта: каталог ~/perf-lab, созданный в уроке 1.1, станет репозиторием (repository): так называют проект вместе с его историей Git. Ты сохранишь паспорт машины и памятку о структуре, научишься сравнивать изменения и отменять учебную ошибку. Всё это пока только на твоём компьютере. Следующий урок добавит вторую копию на GitHub (сайт для хранения репозиториев и совместной работы).
Что нужно знать
Из урока 1.1 нужны cd, pwd, ls, cat, создание файлов через > и дописывание через >>. Там же установлен Git и созданы ~/perf-lab/{results,reports,scripts} и machine.md. После тем 1 и 2 в ~/perf-lab лежат ещё папки 01-linux и 02-web с заметками этих уроков, а в results и scripts могут быть файлы. Если каталог или паспорт потерялись, восстанови их по практике 1.1, прежде чем идти дальше.
Из урока 1.2 пригодится чтение длинного вывода: в программе просмотра less выходят клавишей q. Интернет для этого урока не нужен. Учебный «Магазин» запускать не требуется: сегодня ты работаешь с файлами своих заметок. Не меняй ~/learning, где лежат материалы курса и стенд.
Картина целиком
Представь, что ты собираешь посылку. Вещи лежат на столе. Нужные ты кладёшь в коробку и проверяешь. Потом закрываешь коробку и подписываешь. Git работает в три такие же ступени.
Вещи на столе это обычные файлы проекта, которые ты открываешь и правишь. Их называют рабочим деревом (working tree). Вещи в коробке это индекс (index, ещё его зовут staging area): подготовленное содержимое следующего сохранения.
Закрытая и подписанная посылка это коммит (commit): сохранённый снимок файлов с автором и сообщением о причине изменений. Между ступенями две команды. git add копирует текущую версию файла в индекс, это и называют staging, «положить в коробку». git commit записывает индекс в историю.
flowchart TD
W["Файлы на диске"] -->|"git add"| I["Индекс:<br/>подготовленный снимок"]
I -->|"git commit"| C["Коммит:<br/>сохранённый снимок"]
C --> H["История проекта"]
На схеме два перехода. Сохранить файл в редакторе не значит подготовить его, а подготовить не значит записать в историю. От настоящей посылки есть одно отличие: Git копирует содержимое, поэтому после add файл остаётся на диске и его можно править дальше.
Теория
Репозиторий: файлы рядом с памятью о прошлом
Ты перезаписал заметку, а через час понял, что вчерашний вариант был лучше. В обычной папке он пропал навсегда. Как сделать, чтобы прошлое хранилось рядом с настоящим?
Git кладёт историю в скрытый каталог .git внутри проекта, и создаёт его команда git init. Скрытым в Linux называют имя с точкой в начале, как в уроке 1.1. В .git лежат история, подготовленное состояние и настройки репозитория. Твои machine.md и будущие тесты остаются обычными файлами рядом.
Git ищет .git с текущей папки и поднимается вверх. Поэтому команды внутри ~/perf-lab/reports относятся к репозиторию ~/perf-lab. А в соседнем ~/learning живёт другая история, и открытый не в той папке терминал легко сохранит заметки не в тот проект. Поэтому перед действием смотри pwd.
Сразу после git init файл machine.md лежит на диске, но истории у него нет. Git его видит и ждёт, хочешь ли ты его сохранять. После add файл подготовлен, после commit он впервые попадает в историю. Git не хранит пустые каталоги: пока в папке нет файлов, в снимок она не попадёт (сейчас так с reports; у results и scripts могут быть файлы из прошлых уроков, они попадут вместе с ними). Пустая папка появится вместе с первым файлом.
Прикинь сам: ты выполнил
git initи удалил файл, который ни разу не добавлял и не сохранял. Вернёт ли его Git?
Нет. Инициализация только подготовила место для истории, содержимое файла Git ещё не сохранял. Надёжная контрольная точка появляется после add и commit.
Осторожно: Git не делает резервную копию диска. До первого коммита сохранённой версии нет, а история на одном ноутбуке пропадёт вместе с ним. Вторая копия появится в уроке 3.2.
Главное: репозиторий это проект плюс скрытый
.gitс историей, и пока ты ничего не сохранил, истории нет.
Коммит: состояние проекта и объяснение изменения
Через месяц ты откроешь файл и спросишь: «Зачем я это правил?». Старой копии файла для ответа мало, нужна ещё и причина.
Коммит похож на фотографию рабочего стола с подписью «подготовил методику первого прогона»: по подписи понятна причина, по снимку видно состояние. Git хранит не картинку, а содержимое файлов, поэтому умеет сравнивать две версии строка за строкой.
У коммита есть снимок отслеживаемых файлов, то есть тех, что уже попали в подготовку или историю Git. Ещё у него есть автор, время, сообщение и ссылка на предыдущий коммит, родителя (parent). Первый коммит родителя не имеет, второй опирается на первый, третий на второй. Так получается цепочка.
У каждого коммита есть хеш (hash): идентификатор, вычисленный из содержимого коммита (файлов, автора, времени, сообщения и родителя). Его начало, например 8c24a71, находит запись в этой истории, если сокращение однозначно. Это не номер по порядку: второй коммит не получает «2». Твои хеши будут другими.
В короткой истории встретится строка 8c24a71 Описать структуру лаборатории: сначала идентификатор, затем сообщение. По ней понятно, какую задачу решали, а сами правки открывают сравнением. Хорошее сообщение отвечает «что изменилось и зачем». «Добавить паспорт машины» полезнее, чем «update».
Осторожно: коммит не доказывает, что тест работает. Git сохранит и сломанный сценарий, проверять результат надо самому. И коммит ничего не отправляет на сайт: сегодня все операции локальные, то есть идут на этой машине без сети.
Проверь понимание: сообщение «всё работает» гарантирует, что сценарий запускали? Что лучше написать?
Ответ
Нет: сообщение вводит человек, а Git проверку не запускает. Лучше описать конкретное изменение, например «Добавить инструкцию создания рабочих каталогов».
Главное: коммит это снимок файлов с автором, временем, сообщением и ссылкой на родителя, а сообщение объясняет причину.
Индекс: что попадёт в следующий снимок
Ты правишь две заметки, а закончил одну. Если бы Git сохранял всё подряд, в историю ушла бы и недописанная. Как сохранить только готовое?
Для этого и нужен индекс. После коммита он совпадает с последним снимком. Правка файла меняет только диск. Команда git add файл обновляет версию этого файла в индексе, а git commit записывает весь индекс в историю. После коммита файлы с диска не пропадают.
Теперь главная тонкость. add запоминает содержимое на момент вызова. Допустим, в README.md (памятка о проекте для человека, который впервые открыл папку) ты дописал раздел «Каталоги» и выполнил add. Потом дописал раздел «План». Индекс про «План» ничего не знает. Если сделать коммит сейчас, в истории окажутся «Каталоги», а «План» останется только на диске. Повторный git add README.md заменит подготовленную версию свежей.
flowchart TD
D["Диск:<br/>«Каталоги» и «План»"] -->|"add был<br/>до «Плана»"| I["Индекс:<br/>только «Каталоги»"]
I -->|"git commit"| H["Новый коммит:<br/>только «Каталоги»"]
На схеме видно, что два места из трёх отстали от диска.
Прикинь сам: после
addты исправил опечатку и сделалcommit. Какая версия опечатки попадёт в снимок?
Та, что была на момент add, то есть до исправления. Индекс сам не обновляется. Чтобы исправление вошло в снимок, нужен повторный git add.
Осторожно: add не значит «следи за файлом навсегда». Он подготавливает сегодняшнее содержимое. И сохранение в редакторе не заменяет add: редактор и Git решают разные задачи.
Главное: индекс это коробка с версией, которую ты положил в неё последней, и в коммит уходит именно она, а не то, что лежит на диске.
Как увидеть, что где лежит, и не гадать? Для этого у Git есть два вопроса.
Status и diff: состояние и содержимое различий
Ты уже не уверен: что подготовлено, а что нет? Гадать не нужно. git status отвечает, какие файлы изменились, а git diff показывает, что внутри них изменилось. Diff это сравнение двух состояний, обычно с построчным показом добавлений и удалений.
Длинный status делит файлы на три группы. Untracked files это новые файлы, которых нет в индексе. Changes not staged for commit это правки на диске сверх индекса. Changes to be committed это подготовленное сверх последнего коммита. Файл из примера про README попадёт сразу в две последние группы: «Каталоги» подготовлены, «План» нет.
Короткий git status --short пишет перед именем две позиции. Левая сравнивает индекс с последним коммитом, правая диск с индексом. Если позиция пустая, там пробел.
| Вывод | Левая: индекс против коммита | Правая: диск против индекса | Что значит |
|—|—|—|—|
| ?? notes.md | не отслеживается | не отслеживается | новый файл, ещё не добавлен |
| ` M README.md | пробел, различий нет | M, изменён | правка только на диске, не подготовлена |
| M README.md | M, изменён | пробел, различий нет | правка подготовлена, диск совпадает с индексом |
| MM README.md | M, изменён | M`, изменён | подготовлена, а потом файл правили ещё раз |
Здесь M значит modified, «изменён», а A added, «добавлен»: A notes.md это новый файл, который уже подготовлен. Наш README с «Каталогами» в индексе и «Планом» на диске покажет MM.
Два вида diff отвечают на разные вопросы. Запомни их парами «команда: что с чем сравнивает».
git diff: диск с индексом, то есть то, что ещё не подготовлено.git diff --staged: индекс с последним коммитом, то есть будущий снимок.
Поэтому пустой обычный diff после add нормален: между диском и индексом различий нет, но подготовленное ещё не сохранено.
Вот как читать строки. -Нагрузка: только локально значит, что старая строка удалена. +Нагрузка: только свой локальный стенд значит, что добавлена новая. Знаки показывают действие, а не качество текста. Строки без знаков дают окружение, чтобы ты видел место правки.
Осторожно: обычный diff не показывает содержимое нового неотслеживаемого файла. Прочитай его через cat, потом добавь и посмотри diff --staged.
Проверь понимание:
git diffпуст, а status показываетM README.md. Можно ли считать работу уже сохранённой?
Ответ
Нет. Различие находится в индексе, его покажет git diff --staged. В историю оно попадёт после успешного git commit.
Главное: status говорит, какие файлы где лежат, обычный diff показывает не подготовленное,
diff --stagedпоказывает будущий снимок.
Теперь о файлах, которым в истории вообще не место.
.gitignore: что не должно стать частью истории
Через месяц в results лягут гигабайты сырых измерений, а в .env чей-то токен (длинный пароль для программ: по нему сервис узнаёт, что запрос пришёл от тебя). Если добавить их в историю, она станет тяжёлой, а секрет увидят все, кто откроет репозиторий. Как сказать Git «это не трогай»?
Для этого есть файл .gitignore: текст с шаблонами, под которые подходят новые файлы, пропускаемые при обычном добавлении. Одна строка задаёт один шаблон. Шаблон проверяет путь, а не размер. Правило /results/*.csv исключит и маленький, и большой CSV прямо внутри корневого results.
| Знак | Что делает | Пример |
|---|---|---|
* |
заменяет любую последовательность символов, но не / |
*.jtl |
/ в начале |
привязывает правило к корню репозитория (папке с .git) |
/results/*.csv |
# в начале |
комментарий | # Секреты |
Что исключаем мы? CSV (comma-separated values) это текстовая таблица со значениями через запятую. Инструменты нагрузки будут писать в неё много строк измерений. Сырые выгрузки в историю не нужны, а выводы мы сохраним в reports небольшими текстовыми отчётами. Ещё есть .env: файл настроек, где бывают пароли и токены.
Ещё несколько строк в нашем файле пока ни к чему: это служебные папки Python, они понадобятся с темы 4 (урок 4.5 объяснит их), а правила пишем заранее.
Правило /results/*.csv оставит возможность сохранить results/README.md, если позже понадобится инструкция о выгрузках. Инструменты нагрузки пишут не только CSV, поэтому мы исключим ещё /results/*.json и /results/*.jtl (так JMeter называет файл результатов); короткие отчёты живут в reports/. Появятся другие выгрузки, например *.har (запись сетевых запросов, которую сохраняет браузер): допиши для них такие же строки и проверь правило через git check-ignore -v. Сам .gitignore нужно закоммитить: правила понадобятся и на другой машине.
Нагрузочные инструменты часто пишут каждый запуск в свою папку, например results/2026-10-26/run.csv. Такой файл правило /results/*.csv не поймает, потому что звёздочка не заходит во вложенные папки. Тогда проще исключить всё содержимое results целиком, оставив памятку: строка /results/*, а под ней строка !/results/README.md (восклицательный знак возвращает файл из исключений). Мы пока оставляем плоские правила, а ты при такой структуре замени ими три строки про results.
Прикинь сам: исключит ли правило
/results/*.csvфайл04-python/users.csv? Будет ли оно искать только файлы больше 100 МБ?
Нет в обоих случаях. Правило относится к CSV непосредственно в корневом results, и работает по пути, а не по размеру. Учебные данные в другой папке остаются доступными для добавления.
Осторожно: .gitignore не убирает файл, который уже попал в историю, и строка в нём не удаляет старый коммит с секретом. Если токен всё же попал в коммит, сразу отзови его в сервисе и выпусти новый: историю могли успеть скопировать. Поэтому правила создают до первого массового добавления. Как убрать уже отслеживаемый файл, смотри во врезке ниже. Поведение описано в документации gitignore.
Главное:
.gitignoreзащищает от случайного добавления новых файлов, но задним числом ничего не прячет, поэтому пиши его до первогоadd.
Для любопытных: файл уже отслеживается или секрет уже в истории
Чтобы Git перестал следить за файлом, который уже попал в индекс или историю, выполни git rm --cached путь. Файл останется на диске, а следующий коммит уберёт его из снимка. Проверь результат через git ls-files: эта команда перечисляет все отслеживаемые файлы.
Старые коммиты при этом не меняются. Если в них лежал секрет, сначала отзови его в сервисе, как сказано выше. Историю потом чистят отдельной программой git filter-repo, но переписанную историю придётся заново отправлять всем, у кого она есть, поэтому новичку лучше сначала показать вывод наставнику.
Ошибки всё равно случаются. Как отменить их, не потеряв полезное?
Restore: выбрать, какую ошибку отменить
Ты подготовил лишний файл. Или испортил абзац в тексте. Это две разные беды, и лечатся они по-разному. Одна команда на все случаи опасна: она выбросит то, что ты хотел сохранить.
Вернёмся к посылке. Можно вынуть вещь из коробки, оставив её на столе. А можно выбросить вещь со стола. git restore --staged файл делает первое: возвращает версию в индексе к последнему коммиту, а текст на диске не трогает. git restore файл делает второе: перезаписывает рабочий файл версией из индекса, и правка на диске пропадает.
В выводе Git встретится слово HEAD: так называют текущую точку истории, обычно последний коммит ветки. Ветка пока одна, main: имя линии работы. Подробнее в следующем уроке.
flowchart TD
Q["Какую ошибку отменяем?"] --> A{"Лишнее в индексе?"}
A -->|"да"| S["restore --staged файл"]
A -->|"нет, испорчен текст"| D["Сначала прочитай diff"]
D --> R["restore файл"]
S --> K["Правки на диске остались"]
R --> L["На диске версия индекса"]
На схеме у двух путей разные последствия: убрать подготовку сохраняет текст, восстановить рабочий файл заменяет текст. Поэтому перед второй операцией читай различия и убеждайся, что правка лишняя.
Разберём на буквах. В коммите текст «А», после add в индексе «Б», после новой правки на диске «В». Обычный restore вернёт на диск «Б», а не «А». Чтобы дойти до «А», сначала сделай --staged: индекс станет «А», диск останется «В». Потом обычный restore даст на диске «А».
Прикинь сам: ты по ошибке сделал
addполезной правки. Как убрать только подготовку?
git restore --staged имя-файла. После этого проверь status и обычный diff: полезная правка осталась на диске и перешла в неподготовленные.
Осторожно: restore не отменяет уже созданный коммит. Перезаписанный несохранённый текст Git может не вернуть. А у нового неотслеживаемого файла сохранённой версии нет вовсе.
Главное: сначала реши, что отменяешь: подготовку (
--staged, текст остаётся) или текст на диске (обычный restore, правка пропадает).
Поиск и откат: show, blame, revert
Restore работает с тем, что ещё не сохранено. А если плохая правка уже в коммите, а в тесте вдруг поменялась строка, и никто не помнит, кто и зачем? Для этого история и ведётся.
Три команды отвечают на вопрос «что тут менялось». git show хеш печатает сообщение коммита и его diff, без хеша берёт последний коммит. git log --stat добавляет к каждой записи список файлов и число изменённых строк, без содержимого. git log -p файл показывает историю одного файла с diff каждой правки. Выход из них, как из less, клавишей q.
Вопрос «кто добавил эту строку» решает git blame файл. Он печатает файл построчно, и перед каждой строкой стоят хеш коммита, автор и дата. Название «обвинить» условное: цель не искать виноватого, а получить хеш и прочитать через git show, зачем строку написали.
Чтобы убрать плохую правку, уже сохранённую в коммите, используют git revert хеш. Он не стирает коммит, а создаёт новый, который делает обратные изменения. История остаётся честной: плохой коммит и его откат видны оба. Поэтому revert безопасен там, где историю уже скачали другие. Выполнять его нужно с чистым рабочим деревом, а флаг --no-edit оставляет сообщение, которое Git предложил сам.
Прикинь сам: плохой коммит уже отправлен коллегам. Можно ли «стереть» его из истории, чтобы никто не заметил?
Нет: у коллег он уже есть, и стирание сломало бы их копии. Честный путь один: новый коммит с откатом.
Осторожно: blame показывает, кто строку последний раз менял, а не кто придумал идею. И revert не возвращает файл «как было, но без следа»: в логе остаются два коммита.
Для любопытных: reset, amend, stash и reflog
Пока коммит никто не скачал, историю можно править. git reset хеш двигает текущую ветку на другой коммит и по-разному обращается с индексом и диском:
| Вариант | Ветка | Индекс | Файлы на диске |
|---|---|---|---|
reset --soft хеш |
двигается | не трогает | не трогает |
reset хеш (по умолчанию --mixed) |
двигается | возвращает к хешу | не трогает |
reset --hard хеш |
двигается | возвращает к хешу | перезаписывает, правки пропадают |
git commit --amend заменяет последний коммит новым: так правят сообщение или добавляют забытый файл. Хеш при этом меняется, поэтому amend подходит только для коммита, который ты не отправлял.
git stash убирает незакоммиченные правки в «карман» и возвращает чистое дерево, git stash pop достаёт их обратно. Это удобно, когда нужно срочно переключиться, а коммитить ещё рано.
Если после reset --hard пропал нужный коммит, его хеш ещё можно найти: git reflog печатает журнал, куда на этой машине указывал HEAD. Найди строку до ошибки и вернись командой git reset --hard хеш. Журнал хранится ограниченное время и только у тебя.
Главное: чтобы узнать, кто и зачем поменял строку, смотри
blameиshow; чтобы отменить сохранённое и уже опубликованное, делайrevert.
Граница коммита: что класть в один снимок
Допустим, ты исправил в паспорте число ядер и добавил в README строку, где искать паспорт. Это одна задача: читатель должен найти точные условия. Значит, и коммит один, с двумя файлами. А случайная опечатка в чужом отчёте к этой задаче не относится, её лучше сохранить отдельно.
Перед коммитом сверяй сообщение с git diff --staged. Если сообщение обещает правку паспорта, а в снимке только README, добавь паспорт. Если там случайно лежит секрет, убери его через restore --staged: правки на диске останутся.
После коммита обычный git diff пустеет, но правка не пропала. Она переехала из «изменений сверх снимка» в сам снимок. Увидеть её можно в git log (список коммитов, новые сверху) и в сравнении двух соседних коммитов.
Снимок хранит файлы, а не весь компьютер. Запущенные процессы, данные базы стенда и установленные программы в него не входят. Поэтому через месяц, когда ответ сервиса изменится, одного идентификатора коммита мало: нужны ещё паспорт машины и инструкция запуска. Они лежат в том же репозитории: это первое, что стоит проверить, когда сравниваешь два прогона.
Проверь понимание: сообщение обещает исправления двух файлов, а staged diff показывает один. Стоит ли создать коммит, чтобы проверить второй?
Ответ
Нет. Сначала посмотри status и обычный diff второго файла. Если правка там закончена, добавь файл и снова прочитай staged diff. Коммит делают после проверки, а не чтобы найти пропущенный файл.
Главное: один коммит это одна понятная задача вместе со всеми файлами, без которых результат не повторить.
Автор и привычка проверять перед сохранением
Git подписывает каждый коммит именем и почтой из настроек user.name и user.email. Это подпись автора, а не вход на сайт: значения не дают доступ к GitHub и пароль не проверяют. Подойдут любые, например student@example.com. Когда история уйдёт на GitHub, в публичном репозитории почту увидят все посетители, поэтому в уроке 3.2 мы заменим её на скрытый адрес GitHub.
git config --global задаёт настройки для твоего пользователя на этой машине. Без --global, внутри репозитория, настройка действует только здесь и главнее общей. Если общая тебя устраивает, ничего не меняй. Автора можно задать и только для perf-lab: тогда другие проекты не затронуты.
Смотри на проверку между add и commit. Она ловит расхождение между подготовленным и ожидаемым, пока история ещё не записана.
Вернёмся к просьбе менеджера из начала. На вопрос «чем вы мерили?» у тебя есть ответ: сценарий и паспорт машины лежат в одном снимке.
Главное: перед каждым коммитом проверь место, различия и будущий снимок, и только потом сохраняй.
Практика
Выполняй шаги по порядку в Ubuntu (на Mac внутри ВМ: multipass shell lab), от обычного пользователя, без sudo. Вывод ниже по-английски, чтобы ты узнавал сообщения из документации. Если твой Git пишет по-русски, смысл тот же; для одного вызова английский можно получить через LC_ALL=C git status. LC_ALL=C задаёт язык сообщений для этой команды, не меняя систему навсегда.
1. Найди существующую лабораторию и настрой автора
cd возвращает в рабочий каталог из 1.1. pwd показывает его полный путь, ls проверяет паспорт и три папки. git --version сообщает версию программы, --version означает «покажи версию». Выполни:
cd ~/perf-lab
pwd
ls
cat machine.md
git --version
Пример ориентиров, без повторения самого паспорта:
/home/student/perf-lab
01-linux 02-web machine.md reports results scripts
git version 2.43.0
Как читать вывод: путь должен оканчиваться на /perf-lab, паспорт машины должен содержать твои условия, Git должен быть версии 2.43 или новее. Между списком файлов и версией у тебя будет содержимое machine.md. Дополнительные заметки прошлых уроков нормальны, не удаляй их.
Перед настройкой прочитай текущие значения. git config --global --get получает один параметр общей настройки; user.name и user.email это имена параметров:
git config --global --get user.name
git config --global --get user.email
Если вывода нет, значение не задано. Если там уже стоят подходящие имя и почта, оставь их. Иначе задай свои. --global действует для всех репозиториев на этой машине, текст в кавычках передаётся одним значением:
git config --global user.name "Автор лаборатории"
git config --global user.email "student@example.com"
student@example.com это учебный адрес: письма на него не придут, и это нормально, сейчас он нужен только как подпись. Свой настоящий адрес подставлять необязательно, первые коммиты просто будут подписаны учебным. Эти две команды при успехе молчат. Повтори --get, чтобы проверить, что значения записались.
Ещё одна настройка на будущее. Имя первой ветки новых репозиториев по умолчанию может оказаться master, а не main. Попросим Git всегда выбирать main:
git config --global init.defaultBranch main
И ещё одна настройка на будущее. В уроке 3.2 появится git pull: команда, которая получает изменения с сайта и добавляет их в твою ветку. По умолчанию, если истории разошлись, она может молча склеить их, и ты не заметишь. Параметр pull.ff only разрешает только безопасное «передвинуть вперёд» и останавливается во всех остальных случаях:
git config --global pull.ff only
Обе команды молчат при успехе. Ключ -b main в шаге 2 дублирует первую настройку намеренно: это страховка на машине, где она не сработала.
Типичные ошибки: bash: git: command not found: Git не установлен в этой Ubuntu. Вернись к установке из 1.1. cd: /home/student/perf-lab: No such file or directory: каталога нет, восстанови практику 1.1, а не создавай репозиторий в случайном месте.
2. Начни историю в уже существующей папке
git init инициализирует репозиторий, -b main задаёт имя начальной ветки main. Флаг -b требует имя следом. Мы выбираем его явно, чтобы результат не зависел от настроек машины:
git init -b main
git status
Initialized empty Git repository in /home/student/perf-lab/.git/
On branch main
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
01-linux/
02-web/
machine.md
results/
scripts/
nothing added to commit but untracked files present (use "git add" to track)
Как читать вывод: создана .git, выбрана main, коммитов пока нет. machine.md найден, но ещё не включён в историю. Пустая reports не перечислена, а папки с твоей работой из тем 1 и 2 (01-linux, 02-web, scripts, results) показаны: в них уже есть файлы. Если у тебя список короче или длиннее, это нормально.
Если не хочешь менять общие настройки автора, теперь можно задать их только здесь: git config user.name "Автор лаборатории" и git config user.email "student@example.com". Это та же команда без --global. Для проверки эффективных значений используй git config --get user.name и git config --get user.email.
Типичные ошибки: fatal: not in a git directory при локальном config значит, что ты запустил его до init или вышел из проекта. Если вместо Initialized видишь Reinitialized, смотри рамку «Если ты повторяешь урок» в конце практики.
3. Создай правила исключений и README
README это файл с объяснением проекта для человека, который впервые открыл папку. Расширение .md обозначает Markdown, простой текст с разметкой: # задаёт заголовок, - пункт списка, обратные кавычки выделяют команды. GitHub позднее покажет этот файл как оформленную страницу.
Следующие команды создают файлы с нуля, а > перезаписывает существующий файл. Если .gitignore или README.md у тебя уже есть, эти команды не выполняй: сначала прочитай рамку «Если ты повторяешь урок» в конце практики. Для многострочного текста используем cat > файл <<'EOF': всё до отдельной строки EOF попадёт в файл буквально, кавычки вокруг 'EOF' запрещают подстановки.
cat > .gitignore <<'EOF'
# Окружение Python и автоматически создаваемые файлы
/.venv/
__pycache__/
*.pyc
# Сырые выгрузки измерений: CSV, JSON и JTL
/results/*.csv
/results/*.json
/results/*.jtl
# Личные настройки и реквизиты доступа
.env
EOF
Здесь *.pyc исключает служебные файлы Python с таким расширением, а слэш в конце (__pycache__/) значит «это папка». .env без начального / исключает это имя и во вложенных папках. Окружение пока не создаём: оно появится в 4.5 в корне, как ~/perf-lab/.venv, поэтому начальный слэш подходит. Если создать окружение в подпапке, такое правило его не поймает.
Создай первую памятку проекта:
cat > README.md <<'EOF'
# perf-lab
Учебная лаборатория нагрузочного тестирования и мониторинга.
## Каталоги
- `machine.md`: паспорт машины для условий измерений.
- `scripts/`: вспомогательные скрипты.
- `results/`: сырые выгрузки, в Git не включаются.
- `reports/`: отчёты и выводы.
Рабочие каталоги создаёт команда `mkdir -p results reports scripts`.
EOF
Прочитай оба файла, затем попроси Git проверить пути по правилам. git check-ignore -v показывает правило, которое исключает путь; -v означает подробный вывод. Пути здесь могут ещё не существовать, поэтому мы ничего не создаём ради проверки:
cat .gitignore
cat README.md
git check-ignore -v .venv/example results/run.csv .env
.gitignore:2:/.venv/ .venv/example
.gitignore:6:/results/*.csv results/run.csv
.gitignore:10:.env .env
Как читать вывод: слева имя файла правил, номер строки и сработавший шаблон, справа проверяемый путь. Пробелы или табуляция между колонками могут отображаться иначе. Комментарии тоже считаются строками. Для каждой из трёх проверок должен найтись ожидаемый шаблон.
Типичные ошибки: правило results.csv не исключит results/run.csv, потому что имя другое. А строка results/ исключит целиком каталог, включая будущие памятки. Исправь правило до добавления файлов. Если cat ждёт ввода, завершающий EOF набран с пробелами или не на отдельной строке.
4. Подготовь и сохрани первый снимок
Сначала прочитай machine.md: в истории будут выбранные тобой данные машины. Не добавляй личные пароли, токены или ненужные внутренние адреса. Поэтому используем явные пути вместо git add .: точка означала бы «всё в текущей папке», а там могут лежать файлы с токенами из прошлых занятий.
git add получает три пути и подготавливает их содержимое. git diff --staged показывает будущий первый снимок: все строки этих файлов будут добавлениями, потому что прошлого коммита ещё нет:
git add .gitignore README.md machine.md
git status --short
git diff --staged
A .gitignore
A README.md
A machine.md
?? 01-linux/
?? 02-web/
?? results/
?? scripts/
Как читать вывод: A в первой позиции означает подготовленное добавление. Строки ?? это каталоги прошлых уроков: они не потерялись. 01-linux и 02-web добавим отдельным коммитом после проверки, что в них нет токенов и ключей (это необязательный шаг в конце урока 3.2). Вторая позиция пустая: после add файлы больше не менялись. Далее diff показывает содержимое всех трёх файлов. Если открылся просмотрщик, пролистай его и нажми q. Не продолжай, пока не прочитал будущий снимок.
git commit -m создаёт запись из индекса; -m передаёт сообщение сразу, без открытия редактора. Кавычки объединяют сообщение в один аргумент:
git commit -m "Добавить паспорт машины и структуру лаборатории"
Пример начала ответа:
[main (root-commit) 8c24a71] Добавить паспорт машины и структуру лаборатории
Как читать вывод: main имя линии истории, root-commit первый коммит без родителя, 8c24a71 пример сокращённого идентификатора, дальше твоё сообщение. Затем Git напечатает количество файлов, добавленных строк и строки create mode 100644 .... 100644 обозначает обычные файлы без права исполнения. Число строк зависит от паспорта и твоего README.
Повтори git status. Если больше ничего не менялось и нет других файлов, итог будет nothing to commit, working tree clean, «сохранять нечего, рабочее дерево чистое». При каталогах прошлых уроков будет nothing added to commit but untracked files present: отслеживаемые файлы при этом чистые. Чистое состояние означает совпадение отслеживаемых файлов на диске, индекса и последнего коммита. Исключённые файлы могут существовать и в чистом состоянии.
Если status перечисляет файлы из прошлых уроков, смотри рамку «Если ты повторяешь урок» в конце практики.
Типичные ошибки: Author identity unknown означает, что не настроено имя или почта автора. Настрой их через config и повтори commit, индекс заново готовить не требуется. Открылся текстовый редактор: ты забыл -m. В nano выйди через Ctrl+X, в vim нажми Esc, набери :q! и Enter, затем повтори команду с -m. nothing added to commit but untracked files present (в совсем пустой папке короче: nothing to commit) при попытке первого коммита значит, что нет подготовленных файлов: проверь status, путь и add.
5. Сделай осмысленное изменение и прочитай diff
Дополним памятку условием безопасной практики. printf печатает строку, \n в формате означает перевод строки, >> дописывает к файлу. %s подставляет следующий текст как строку без его интерпретации:
printf '\n%s\n' 'Нагрузку даём только на свой локальный стенд.' >> README.md
git status --short
git diff -- README.md
-- отделяет параметры команды от путей файлов. Здесь мы просим сравнить только README, а не весь проект.
M README.md
?? 01-linux/
?? 02-web/
?? results/
?? scripts/
Пример содержимого различий в конце файла:
+
+Нагрузку даём только на свой локальный стенд.
Как читать вывод: M во второй позиции означает изменение только на диске. Строки ?? ниже, если они у тебя есть, это каталоги прошлых уроков: так и должно быть. В diff первая пустая добавленная строка даёт отступ, вторая содержит правило. В полном выводе diff --git называет файл, index показывает идентификаторы содержимого, --- a/README.md старую сторону, +++ b/README.md новую. Строка @@ ... @@ показывает диапазоны строк старого и нового вариантов, затем идут строки окружения и правки.
Убедись, что добавлена нужная фраза. Подготовь её, снова прочитай будущий снимок и сохрани:
git add README.md
git diff --staged -- README.md
git commit -m "Уточнить правило безопасной нагрузки"
git status
Пример начала ответа commit:
[main 41a72b3] Уточнить правило безопасной нагрузки
1 file changed, 2 insertions(+)
Как читать вывод: один изменённый файл, две добавленные строки, включая пустую. После успешного коммита рабочее дерево снова чистое при отсутствии другой работы.
Типичные ошибки: пустой обычный diff после add ожидаем, проверяй --staged. Если написал > вместо >>, README будет заменён одной фразой, а diff покажет много удалений. До add прочитай различия, верни README через git restore README.md и повтори правильное дописывание.
6. Найди оба коммита и сравни снимки
git log показывает историю. --oneline сокращает каждую запись до идентификатора и сообщения, -5 ограничивает вывод пятью последними записями. git diff HEAD~1 HEAD -- README.md сравнивает README между предыдущим коммитом и текущим: HEAD~1 это предыдущий коммит, один шаг назад от текущего.
git log --oneline -5
git diff HEAD~1 HEAD -- README.md
41a72b3 (HEAD -> main) Уточнить правило безопасной нагрузки
8c24a71 Добавить паспорт машины и структуру лаборатории
Как читать вывод: сверху более новая запись. HEAD -> main показывает текущую ветку и её последний коммит. В сравнении снова видны две добавленные строки. Их наличие в diff двух коммитов доказывает, что правка записана в историю, даже когда обычный diff пуст.
Теперь без подсказки ответь: какой командой ты увидишь подготовленный снимок, какой текущие правки и какой два сохранённых состояния? Если ответ путается, вернись к разделу про индекс в теории, а не запоминай команды отдельно от их смысла.
Типичные ошибки: fatal: bad revision 'HEAD~1' означает, что у текущей записи нет предыдущего коммита по этому пути, например ты сделал только один коммит. Проверь log и закончи предыдущий шаг. Не подставляй учебные хеши в свои команды: у тебя другие идентификаторы.
Git выдал ошибку, которой нет в «Типичных ошибках»? Скопируй команду и весь вывод, спроси нейросеть, что значит каждая строка. Перед советом, который меняет историю или файлы, сделай
git statusиgit log --onelineи убедись, что работа не потеряется.
Сломай и почини
Поломка 1. Подготовил не ту версию
Мы испортим только одну учебную строку README и не создадим ошибочный коммит. Сначала убедись через status, что README чист. printf допишет намеренно неверное утверждение, add подготовит его. Затем ещё одна строка останется только на диске:
printf '\n%s\n' 'Git commit сразу публикует файлы в интернете.' >> README.md
git add README.md
printf '%s\n' 'Эта строка появилась после add.' >> README.md
git status --short
git diff -- README.md
git diff --staged -- README.md
MM README.md
?? 01-linux/
?? 02-web/
?? results/
?? scripts/
Как читать вывод: первая M это неверное утверждение в индексе, вторая новая строка сверх индекса на диске. Обычный diff показывает вторую строку; staged diff ошибочную фразу и пустую строку перед ней. Ты получил две версии правок одного файла. Строки ?? каталогов прошлых уроков ниже нормальны.
Задача: сначала убери подготовку, сохранив текст для осмотра, затем выброси только эти учебные изменения и верни README к последнему коммиту. Не трогай другие файлы.
Разбор и исправление
Убираем подготовку, как в теории, затем проверяем обычное различие:
git restore --staged README.md
git status --short
git diff -- README.md
Теперь status показывает ` M README.md`: обе строки остались на диске, в индексе сохранённый вариант. Прочитай diff: должны быть только две учебные фразы и пустая строка. Затем восстанови рабочий файл из индекса:
git restore README.md
git status
git diff -- README.md
Как читать вывод: status снова чистый, diff пуст. Полезное правило «Нагрузку даём только на свой локальный стенд» осталось, ошибочная фраза и строка после add исчезли. Коммиты в log не изменились.
Раздельные действия помогли увидеть, что первая команда сохраняет рабочий текст, а вторая перезаписывает его.
Типичные ошибки: если начать с обычного restore, пропадёт только строка после add, а ложное утверждение вернётся из индекса на диск. Это не неисправность Git: ты выбрал другой источник. Проверь staged diff и убери подготовку перед окончательным восстановлением.
Поломка 2. Кажется, что каталог не сохранился
Посмотри git status: папки reports в списке нет, хотя ls -ld reports её находит. Кажется, что Git потерял папку, но на диске она по-прежнему существует. Здесь -l даёт подробности, -d показывает сам каталог, а не его содержимое.
Задача: объясни, почему это нормально и как коллега позже узнает, что эта папка нужна.
Разбор
Git сохраняет файлы и их пути, а пустой каталог не имеет содержимого для снимка. В README уже есть mkdir -p results reports scripts, поэтому человек может восстановить рабочие папки. scripts/ и results/ в status есть, потому что в них лежат файлы, а пустой reports/ Git не видит. Когда появится первый отчёт, добавишь его явным путём и каталог будет восстановлен вместе с ним. Если папка нужна в репозитории сразу, кладут в неё пустой файл .gitkeep (имя условное, Git к нему равнодушен) и коммитят его. Без такой необходимости создавать пустые файлы ради видимости не нужно.
Поломка 3. Плохая правка уже в коммите
Сделаем намеренно неудачный коммит и откатим его честным способом. Сначала убедись через git status, что README чист. Дальше дописываем вредный совет и сохраняем его:
printf '\n%s\n' 'Тест нужно запускать на боевом сайте.' >> README.md
git add README.md
git commit -m "Добавить совет про запуск теста"
git log --oneline -3
Задача: найди, каким коммитом появилась строка про боевой сайт, и откати этот коммит так, чтобы история осталась честной. Не используй reset --hard.
Разбор и исправление
Спроси у Git, кто добавил строки README, и прочитай коммит по хешу из левой колонки (подставь свой):
git blame README.md
git show ХЕШ --stat
^8c24a71 (Автор лаборатории 2026-10-26 12:01:10 +0300 1) # perf-lab
41a72b3a (Автор лаборатории 2026-10-26 12:07:44 +0300 14) Нагрузку даём только на свой локальный стенд.
c3f09d2e (Автор лаборатории 2026-10-26 12:15:02 +0300 16) Тест нужно запускать на боевом сайте.
Как читать вывод: в колонках хеш, автор, время и номер строки. Знак ^ у первого коммита значит, что он самый первый в истории. Хеш c3f09d2e у нужной строки: её добавил наш плохой коммит. Откатываем его:
git revert --no-edit ХЕШ
git log --oneline -4
cat README.md
Git создал ещё один коммит с сообщением Revert "Добавить совет про запуск теста", а строка про боевой сайт из README исчезла. Плохой коммит остался в истории, рядом с ним его откат: так видно, что случилось. В 3.2 в графе истории поэтому будет на два коммита больше, чем в примерах, это нормально.
Типичные ошибки: error: Your local changes would be overwritten by revert значит, что в рабочем дереве есть несохранённые правки. Сохрани их коммитом или убери, затем повтори revert. Если открылся редактор, ты забыл --no-edit: сохрани сообщение и выйди.
Если ты повторяешь урок или в папке уже что-то лежит
Reinitialized existing Git repositoryв шаге 2:.gitуже была. Историю не удаляй, посмотриgit statusиgit log --oneline. ВместоNo commits yetты увидишь свои старые коммиты..gitignoreилиREADME.mdуже существуют (проверь черезls -a): прочитай ихcatи допиши недостающие строки вnano, а не перезаписывай командойcat >.- Status в шаге 4 показывает файлы прошлых уроков: полезные заметки без токенов добавь явными путями отдельным коммитом, а файлы с токенами и ключами внеси по точным путям в
.gitignoreи закоммить это правило. Ничего не удаляй и не добавляй «всё подряд». После такой уборки коммитов станет больше двух, это нормально. - Перед уроком 3.2 в
git statusне должно быть изменений в отслеживаемых файлах (строки??прошлых уроков допустимы).
Самостоятельная проверка
Не меняя файлов, сформулируй порядок действий для трёх ситуаций: новая законченная заметка, полезная правка ошибочно подготовлена, случайная правка рабочего файла. Для каждой назови сначала проверку, потом действие и ожидаемый status. Если можешь объяснить результат до запуска команды, урок усвоен. Итог этой практики: два полезных коммита (и учебная пара «плохой коммит и его откат», если делал поломку 3), чистый README, целый паспорт и действующий .gitignore.
ИИ в помощь
Нейросеть хорошо объясняет вывод Git и формулирует сообщения коммитов, но историю твоего репозитория не видит. Общие правила на странице ИИ-помощник.
Задача: разобрать вывод git status и git diff.
Я учу Git. Вывод git status и git diff в моём репозитории perf-lab:
<вставь вывод>
Объясни каждую строку: что подготовлено, что изменено, что не отслеживается. Какие команды я выполню дальше и что каждая сделает?
Проверь ответ: запускай сначала команды, которые ничего не меняют: status, diff, log. Типичная ошибка: совет git reset --hard или git clean -fd, которые безвозвратно удаляют твою работу: первая команда возвращает индекс и файлы к коммиту, вторая удаляет неотслеживаемые файлы и папки.
Задача: написать понятное сообщение коммита.
Вот мой git diff --staged:
<вставь diff>
Предложи три варианта сообщения коммита: короткая строка до 60 символов, при необходимости пояснение. Объясни, чем хорошее сообщение отличается от плохого.
Проверь ответ: сверь сообщение с git diff --staged: оно должно описывать именно твои изменения. Типичная ошибка: нейросеть добавляет то, чего ты не делал (тесты, документацию).
Словарик урока
| Термин | Простыми словами |
|---|---|
| Git | Программа для сохранения выбранных версий файлов и истории |
| Репозиторий (repository) | Проект вместе с его историей Git |
| Рабочее дерево (working tree) | Обычные файлы, которые редактируешь на диске |
| Индекс (index, staging area) | Подготовленное содержимое следующего снимка |
| Staging | Подготовка выбранного содержимого через add |
| Коммит (commit) | Сохранённый снимок с автором, временем и сообщением |
| Родитель (parent) | Предыдущий коммит, на который ссылается новый |
| Хеш (hash) | Идентификатор, вычисленный из содержимого коммита |
| HEAD | Текущая точка истории, обычно последний коммит выбранной ветки |
| Diff | Построчное сравнение двух состояний |
| Blame | Построчный список: какой коммит и кто последним менял каждую строку |
| Revert | Новый коммит, который отменяет правки выбранного коммита, не стирая историю |
| Неотслеживаемый файл (untracked) | Новый файл, ещё не включённый в индекс |
| .gitignore | Правила исключения новых файлов по именам и путям |
| CSV | Текстовая таблица со значениями, разделёнными запятыми |
| Виртуальное окружение | Отдельная папка с библиотеками Python для проекта |
| README, Markdown | Памятка о проекте и простая текстовая разметка для неё |
| Чистое состояние | Рабочие отслеживаемые файлы совпадают с индексом и коммитом |
Вопросы с собеседований
Раздел для повторения: ответь вслух, потом открой ответ. Вопросы с пометкой [на скорость] отвечай за 30 секунд, остальные объясняй с примером.
1. [junior] [часто] Для чего тестировщику Git?
Ответ
Чтобы хранить проверенные состояния сценариев и отчётов, сравнивать изменения и понимать, какой версией запускали тест. Например, если поменяли число запросов в сценарии, история поможет отделить эффект этой правки от изменения сервиса. Одних копий final-2 для этого недостаточно: в них легко потерять причину и связь файлов.
Что хотят услышать: история, воспроизводимость, конкретная польза для тестов.
Красный флаг: «Git нужен только программистам».
2. [junior] [часто] Чем add отличается от commit?
Ответ
Add подготавливает текущую версию выбранного файла в индексе. Commit сохраняет подготовленное состояние в историю с сообщением. Изменения после add автоматически в индекс не попадут, понадобится повторный add. Ни одна из этих команд сама не отправляет проект в интернет.
Что хотят услышать: два разных шага и фиксация содержимого на момент add.
Красный флаг: «add сохраняет коммит, commit загружает его на сайт».
3. [junior] [часто] Что такое коммит?
Ответ
Это снимок отслеживаемых файлов проекта с автором, временем, сообщением и ссылкой на предыдущее состояние. Коммит имеет идентификатор и позволяет точно указать, с какой версией работали. Первый коммит не имеет родителя. Работоспособность файлов Git сам не проверяет.
Что хотят услышать: снимок проекта и место в истории, а не только сообщение.
Красный флаг: «коммит это название изменённого файла».
4. [junior] [на скорость] Какая команда показывает текущее состояние?
Ответ
git status, кратко git status --short. Она показывает, что подготовлено, что изменено только на диске и какие новые файлы ещё не отслеживаются. Содержимое конкретной правки нужно смотреть отдельно.
Что хотят услышать: команда и различие между списком файлов и содержимым правок.
Красный флаг: отвечает log и показывает только старые коммиты.
5. [junior] [на скорость] Как посмотреть подготовленные изменения?
Ответ
git diff --staged. Обычный git diff сравнивает диск с индексом, поэтому после add может быть пустым, хотя следующий коммит ещё не создан.
Что хотят услышать: точный флаг и две пары сравнения.
Красный флаг: «если diff пустой, всё уже сохранено».
6. [junior] [на скорость] Где хранится история локального репозитория?
Ответ
В служебном каталоге .git внутри проекта. Его создаёт init. Удалять .git нельзя: пропадёт вся история, останутся только обычные файлы. Настройки лучше менять через git config, а не править служебные файлы вслепую.
Что хотят услышать: .git и отличие истории от рабочих файлов.
Красный флаг: «история лежит только на GitHub».
7. [junior] [на скорость] Что делает restore –staged?
Ответ
Возвращает выбранный файл в индексе к последнему коммиту, оставляя рабочий текст на диске. Это отмена подготовки, а не удаление полезной правки.
Что хотят услышать: меняется индекс, рабочее дерево сохраняется.
Красный флаг: путает с обычным restore, который перезаписывает файл.
8. [junior] Почему .gitignore не скрыл уже сохранённый файл?
Ответ
Правила игнорирования действуют на новые неотслеживаемые файлы. Уже включённый в историю файл продолжает отслеживаться. Кроме того, шаблоны проверяют путь, а не размер. Секреты нужно исключать до добавления: правило не стирает прежние коммиты.
Что хотят услышать: различие новых и отслеживаемых файлов, ограничение правил.
Красный флаг: «после добавления в ignore секрет исчезает из всей истории».
9. [middle] После add файл снова изменили. Что сохранит commit и как это проверить?
Ответ
Сохранит подготовленную версию на момент add. Status может показать MM, обычный diff покажет более свежую правку, staged diff подготовленную. Если свежая правка должна попасть в снимок, повторно добавлю файл и проверю staged diff перед коммитом.
Что хотят услышать: объяснение через три состояния и осознанное обновление индекса.
Красный флаг: «commit всегда берёт последний текст с диска».
10. [middle] Нужно выбросить учебную правку. Почему сначала читаешь diff?
Ответ
Restore может перезаписать незакоммиченный текст. Сначала убеждаюсь, что выбран правильный файл и в различии только ненужная работа. Затем выбираю уровень: убрать подготовку или восстановить сам файл. Явный путь не заденет чужие несохранённые правки в других файлах. Если нужно сразу вернуть и индекс, и диск к последнему коммиту, есть короткая форма git restore --source=HEAD --staged --worktree файл: --source=HEAD выбирает коммит, --staged индекс, --worktree файл на диске. Она выбросит всё незакоммиченное по этому файлу, поэтому diff читаю заранее.
Что хотят услышать: проверка содержимого, выбор источника и области восстановления.
Красный флаг: запускает удаление всех правок, не выяснив, какие из них нужны.
11. [middle] Токен случайно ушёл в коммит. Что делать?
Ответ
Считаю токен скомпрометированным: сначала отзываю его в сервисе и выпускаю новый, потому что историю могли успеть скачать. Только потом убираю секрет из истории (например, отдельной программой git filter-repo; переписанную историю придётся заново отправлять всем, у кого она есть) и добавляю файл в .gitignore. Одно правило в .gitignore старый коммит не исправит.
Что хотят услышать: приоритет отзыва токена над чисткой истории и понимание, что .gitignore действует на новые файлы.
Красный флаг: «добавлю в .gitignore, и всё».
12. [middle] Как отменить уже опубликованный коммит: revert или reset?
Ответ
Для опубликованного коммита использую git revert: он создаёт новый коммит с обратными правками, и история остаётся честной для всех, кто её скачал. git reset --hard возвращает индекс и файлы к выбранному коммиту, стирает несохранённое и меняет историю, поэтому для общей ветки он опасен.
Что хотят услышать: revert добавляет запись, reset переписывает историю и может потерять работу.
Красный флаг: git push --force в общий main после reset --hard.
Проверено на версиях
Примеры рассчитаны на Ubuntu 24.04/26.04, Bash 5.2+ и Git 2.43+. Вывод дан для английского языка сообщений, идентификаторы и количества строк зависят от твоих файлов. Команды и семантика restore сверены с документацией Git; сетевые действия в этом уроке отсутствуют. Октябрь 2026.
Итог урока: ты умеешь
- Инициализировать Git в существующем
~/perf-lab, сохранив файлы прошлых уроков. - Настроить имя и почту автора и объяснить, почему это не вход на GitHub.
- Различать рабочее дерево, индекс и коммит.
- Исключить окружение, служебные файлы и сырые CSV через
.gitignore. - Выбрать файлы через add и проверить содержимое через diff –staged.
- Сохранить два осмысленных коммита, прочитать status и log.
- Сравнить соседние коммиты и отменить только учебные правки README.
- Найти через
blameиshow, кто менял строку, и откатить сохранённый коммит черезrevert.
Дальше: урок 3.2. Ты отправишь сохранённую историю на GitHub и научишься вносить изменения через отдельную ветку.
Проверь себя
Короткий тест по уроку: 5 вопросов из банка в 35. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.
Тест работает с включённым JavaScript.