- Что такое GitHub?

GitHub - облачная платформа для хостинга IT-проектов, основанная на системе контроля версий
Git - система контроля версий, позволяет:

• отслеживание изменений в файле
• создать и развивать ветви проекта
• откат до предыдущей(-их) версии(-й)
• привет~клонирование проекта~

По-английски
VCS - (Version Control System) - это и есть Git

[!example] Типы VCS[[#- Типы VCS#Local VCS|Локальный]][[#- Типы VCS#Centalized VCS|Централизованный]][[GitHub#Distributed VCS|Распределённые]]

- Типы VCS

Local VCS

![[Local VCS.png]]

Centalized VCS

![[Centralized VCS.png]]

Distributed VCS

![[Distributed VCS.png]]

[!example] Примеры
Самыми распространёнными примерами распределенной системы контроля версий можно отнести:GitMercurial

[!success] Кстати
Систему Git разработал Линус Торвальдс - создатель Linux в 2005 году

- Первоначальная настройка

Для начала необходимо проверить, установлен ли Git на Ваш компьютер:

# Схож с выполнением команды git --help
git

# Результат:
git [-v | --version] [-h | --help] [-C <path>] [-c <name>=<value>]
           [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
           [-p | --paginate | -P | --no-pager] [--no-replace-objects] [--no-lazy-fetch]
           [--no-optional-locks] [--no-advice] [--bare] [--git-dir=<path>]
           [--work-tree=<path>] [--namespace=<name>] [--config-env=<name>=<envvar>]
           <command> [<args>]

Стандартные команды Git используемые в различных ситуациях:

создание рабочей области (смотрите также: git help tutorial)
   clone      Клонирование репозитория в новый каталог
   init       Создание пустого репозитория Git или переинициализация существующего

работа с текущими изменениями (смотрите также: git help everyday)

   add        Добавление содержимого файла в индекс
   mv         Перемещение или переименование файла, каталога или символьной ссылки
   restore    Восстановление файлов в рабочем каталоге
   rm         Удаление файлов из рабочего каталога и индекса

просмотр истории и текущего состояния (смотрите также: git help revisions)
   bisect     Выполнение двоичного поиска коммита, который вносит ошибку
   diff       Вывод разницы между коммитами, коммитом и рабочим каталогом и т.д.
   grep       Вывод строк, соответствующих шаблонуgit version 2.53.0
   log        Вывод истории коммитов
   show       Вывод различных типов объектов
   status     Вывод состояния рабочего каталога

выращивание, маркировка и правка вашей общей истории
   backfill   Download missing objects in a partial clone
   branch     Вывод списка, создание или удаление веток
   commit     Запись изменений в репозиторий
   merge      Объединение одной или нескольких историй разработки вместе
   rebase     Повторное применение коммитов над верхушкой другой ветки
   reset      Set `HEAD` or the index to a known state
   switch     Переключение веток
   tag        Create, list, delete or verify tags

совместная работа (смотрите также: git help workflows)
   fetch      Загрузка объектов и ссылок из другого репозитория
   pull       Извлечение изменений и объединение с другим репозиторием или локальной веткой
   push       Обновление внешних ссылок и связанных объектов

«git help -a» и «git help -g» выводит список доступных подкоманд
и небольшую справку по понятиям. Смотрите «git help <понятие>»
или «git help <термин>» чтобы узнать больше о конкретной подкоманде
или понятии.
Смотрите «git help git» для получения общего обзора системы.

---------------------------------------------------------------------------------

# Просмотр версии Git
git --version

# Результат:
git version 2.53.0

Стоит начать с того чтобы указать имя и электронную почту пользователя для последующей работы с версиями

# Пользовательская эл. почта
git config --global user.email "email.com"

# Пользовательское имя (псевдоним)
git config --global user.name "username"

- Опционально

Можно задать *красивый (цветной)* вывод информации в Консоль с помощью команды:

git config --global color.ui "true"

Можно задать имя ветви для использования по-умолчанию с помощью команды:

git config --global init.defaultbranch "name"

Для просмотра всего конфигурационного файла можно воспользоватся данной командой:

git config list

# Результат:
user.email=second-name@gmail.com
user.name=AdMiN
init.defaultbranch=main

Для просмотра конкретного параметра из конфигурации Git можно с помощью команды:

# git config парметр
git config --global user.name

# Результат
username

[!warning] Важно
Если вы пропиши указанные выше команды без параметра --global то данные настройки буду применены ТОЛЬКО для конкретного репозитория (папки), а не всей системы Git

Расположение конфигурационных файлов Git

(Пример для Windows)

1. Системные настройки Git (для всех пользователей)

• C:\Program Files\Git\etc\gitconfig

1. Глобальные настройки (для текущего пользователя)

• %USERPROFILE%.gitconfig

1. Локальные настройки (для конкретного репозитория)

• <Путь-к-репозиторию>.git\config

- Создание репозитория

[!tip] Кстати...
В Windows Вы будете пользоваться Git Bash - он же MINGW64 поэтому здесь необходимо использовать команды из ОС Linux
Вот что Вам может понадобиться:ls - просмотр содержимого папки (list)ls -l - Вывести список содержимого папки в формате спискаls -la - Вывести список содержимого папки в формате списка + скрытые файлыcd - Перейти в другую папку (change directory)cd .. - Поднятся в корневой раздел ("Назад")cd <directory> - Перейти в директорию <directory ("Вперед в <directory>" )cd ~ - Перейти в домашнюю пользовательскую директориюmkdir <directory> - Создать директорию <directory> (make directory)cat <filename> - Вывести на экран содержимое файла <filename> (concatenate - соединять)
*Её основной функционал НЕ ТОЛЬКО ВЫВОД НА ЭКРАН*pwd - Просмотр, где вы находитесь (посмотреть путь в данную директорию) (print working directory) *Я её называю ПОВОДЫРЬ*

Опционально:
Если Вы хотите создать файл, то на этот случай существует 2 решенияtouch <filename> - Создать файл <filename>echo "" > <filename> - Записать в файл (полная перезапись содержимого файла) <filename> "(ничего)" и тк файл не существует, он будет создан
3*.echo "text" >> <filename> - Дописать в конец файла <filename> текст text

Если же используете любой дистрибутив Linux, то git будет доступен в терминале
р
Создадим новый Git-repository (Git-репозиторий) в выбранной папке с помощью

git init
# Результат:
> "Инициализирован пустой репозиторий Git в <directory>"

# Посмотри что хранится в папке <directory>
ls -laR

Результат:

└── .git
├──config
├── description
├── HEAD
├── hooks
│   ├── applypatch-msg.sample
│   ├── commit-msg.sample
│   ├── fsmonitor-watchman.sample
│   ├── post-update.sample
│   ├── pre-applypatch.sample
│   ├── pre-commit.sample
│   ├── pre-merge-commit.sample
│   ├── prepare-commit-msg.sample
│   ├── pre-push.sample
│   ├── pre-rebase.sample
│   ├── pre-receive.sample
│   ├── push-to-checkout.sample
│   ├── sendemail-validate.sample
│   └── update.sample
├── info
│   └── exclude
├── objects
│   ├── info
│   └── pack
└── refs
├── heads
└── tags

Далее ознакомимся с содержимым файла config

cat .git/config

# Результат:
[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true

Это актуальные настройки данного Git-репозитория!

Полный код создания репозитория Git:

# создать каталог для проекта с именем 'first_project'
mkdir first_project

# вывести содержимое текущего каталога
ls

# перейти в созданный каталог
cd first_project/

# вывести путь к текущей локации
pwd

# вывести содержимое каталога в подробном (табличном виде), включая скрытые файлы и папки
ls -la

# (основная команда урока!) создать Git-репозиторий в текущей папке
git init

# перейти в папку '.git'
cd .git/

# вывести содержимое файла config
cat config

# задать локально (для текущего репозитория) имя пользователя Git
git config user.name "user22"

# вывести глобальное значение имени пользователя Git
git config --global user.name

# вывести локальное значение имени пользователя Git
git config user.name

# вывести список всех настроек Git
git config --list

# вывести список глобальных настроек Git
git config list --global

# вывести список локальных настроек Git
git config list --local

# переместиться в предыдущую локацию
cd -

# переместиться в домашний каталог пользователя
cd c:/Users/Pragmatic_Programmer

# вывести содержимое файла '.gitconfig'
cat .gitconfig

# вывети список ВСЕХ текущих настроек Git вместе с информацией о том, из какого файла конфигурации каждая настройка взята.
git config --show-origin --list

Если Вы хотите узнать основные команды Linux и познакомится с работой командной строки то Вам сюда: Ссылка

- Создание коммита

[!cite] Commit (фиксировать) -
Это снимок (snapshot) состояния проекта в определенный момент. Он фиксирует изменения, внесенный в файлы репозитория, сохраняет их в истории проекта.

[!success] Основные команды для отслеживая snapshotgit status - Вывод информации о состоянии каждого файла Git-репозиторияgit log - Вывод информации о каждом существующем commit

Пример работы программы git status:

git status

> Текущая ветка: main
Еще нет коммитов
нечего коммитить (создайте/скопируйте файлы, затем запустите
«git add», чтобы отслеживать их)

touch file.txt
echo "Hello W0rld" >> file.txt
git status

> Текущая ветка: main
Еще нет коммитов
Неотслеживаемые файлы:
  (используйте «git add <файл>...», чтобы добавить в то, что будет включено в коммит)
 --> file.txt
индекс пуст, но есть неотслеживаемые файлы
(используйте «git add», чтобы проиндексировать их)

git add file.txt # Добавили отслеживание файла в Git-репозиторий
git status

> Текущая ветка: main
Еще нет коммитов
Изменения, которые будут включены в коммит:
(используйте «git rm --cached <файл>...», чтобы убрать из индекса)
новый файл:    file.txt

Все файлы созданы, подготовлены и отслеживаются, теперь можно зафиксировать (за-commit-ить) состоянии репозитория
Здесь существует несколько способов:

1. git commit
   # Затем откроется редактор в терминале и можно будет вписать текст *комментарий* для данной фиксации *коммита*

2. git commit -m "Comment"
   # Вписать коментарий самостоятельно: -m (message - "сообщение")

[!tip] Кстати...
Для новичков редактор Vim может быть немного сложен в использовании, поэтому рекомендую использовать редактор Nano

[!warning] Осторожно, Vim!
Если на этом моменте Вас Vim застал врасплох то следуйте командам:Нажмите клавишу I - сопровождается появлением надписи ~INSERT~Вписывает Ваш коментарийВыходите из режима редактирования - нажатие клавиши Esc (Escape)Сохраняем изменения (Ваш комментарий НЕ ДОЛЖЕН начинаться с # - если же это не так, удалите символ #) - введите :wq (: write quit)Результат:

[main (корневой коммит) 8852dd5] add file file.txt
1 file changed, 1 insertion(+)
create mode 100644 file.txt

Опционально

Проверим что получилось:

git log

> commit 8852dd5a764406e020e5da768c0381aa6f5e189d (HEAD -> main)
Author: AdMin <second-name@mail.com>
Date:  ~~~~~~ ~~~~~ ~~~~ ~~~~~~
    add file file.txt

git status

> Текущая ветка: main
нечего коммитить, нет изменений в рабочем каталоге

Команда позволяет посмотреть историю коммитов в компактном виде:

git log --oneline

Также если Вы хотите сменить редактор, воспользуйтесь данной командой:

git config --global core.editor "nano" (или "notepad", "vim")

[!example] Состояния файлов в Git
Состояния файлов делятся на 2 типа:Changed - изменённыеUntracked - не отслеживаемыеДля первого случаю необходимо сделать коммин (commit)

Для второго случая необходимо сначала начать отслеживать файл, а затем уже делать коммит (add & commit)

- Что такое индекс (Stage)?

![[Structure of Stage.png]]

1. Рабочая директория - файловая система
2. Stage - изменения в файлах
3. Репозиторий - Список все версий

[!success] Структура взаимосвязи команд в Git
Working Directory -> git add -> Stage
Stage -> git commit -> Repository

[!success] Переходные состояния файлов вGit
Untracked -> git add -> Staged
Staged -> git commit -> Unmodified
Unmodified -> edit -> Modified
Modified -> git add -> Staged
Unmodified -> remove -> Untracked

![[File State.png]]

[!warning] Важно о коммитах
Если Вы вносите изменения после выполнения команды git add то они не будут добавлены в Ваш репозиторий, нужно будет ввести команду в терминале ещё раз!

Для закрепления понимания данной специфической особенности системы контроля версий проведем небольшую практику:

1. Создадим файл и внесем в него изменения
2. Проиндексируем его
3. Еще раз внесем изменения и НЕ БУДЕМ ИХ ИНДЕКСИРОВАТЬ!
4. Сделаем коммит
5. Удалим файл
6. Сделаем откат на предыдущий коммит
7. Посмотрим содержимое файла
   Опционально:
8. Если Вы хотите видеть состояния, то можно пользоваться командой git status
   Приступим:

mkdir git-example
cd git-example/

touch file.txt
echo "Hell0 W0rld" >> file.txt

git add file.txt

echo "Hi, AdMiN" >> file.txt

git commit -m "edited file.txt"

git log --oneline

rm file.txt

# Отменить все изменения после последнего коммита
# (подробнее будет рассмотрена далее)
git reset --hard

cat file.txt

> "Hell0 W0rld"
# Вывод - второй строки нет!

- Ленивый коммит

Если вы хотите сократить выполнение 2 команд, а именно git add . + git commit в 1 используйте данную команду

# -a означает все файлы (--all)
git commit -a

# Подробный просмотр  последнего успешного коммита
git show

# или же просмотр ЛЮБОГО коммита путем указания его ID
# Пример:
git log --oneline
90edf00 (HEAD -> main) edited file.txt
ae213a9 remove file.txt
8852dd5 add file file.txt

git show 90edf00

commit 90edf009d468bad74528d0a638d4a3f0cb0a3446 (HEAD -> main)

    edited file.txt

diff --git a/file.txt b/file.txt
new file mode 100644
index 0000000..557db03
--- /dev/null
+++ b/file.txt
@@ -0,0 +1 @@
+Hello World

# Узнать только имена файлов
git show --name-only <ID>

[!warning] Важное уточнение для git commit -a
Команда git commit -a считывает предыдущие коммиты и файлы, которые были в них, поэтому при создании файла, которого ранее не было, стоит использовать классическую связку git add . + git commit

Кстати можно делать еще более ленивые сочетания:
git commit -am "comment"

Если вы уже столкнулись с данной проблемой (см. ранее) то смотрите код ниже:

Для того чтобы добавить файл в предыдущий коммит необходимо воспользоватся командой:

git add .
git commit --amend
# --amend - внести поп равки в предыдущий коммит
# amend - (amendment) - поправка, изменения*
 

[!success] Уточнение для git commit
При использовании команды git commit появляется терминальный текстовый редактор и там можно сделать много строчный коммит который будет по-разному отображаться
Например:

При использовании git log мы увидим комментарий полностью, но с дополнительным параметром --oneline мы увидим только edited file.txt

[!example] Правила хорошего коммита:Пустая строка между темой и теломТема сообщения не более 50 символов(Часто) Тема в верхнем регистре (CapsLock)Точка НЕ СТАВИТСЯ в коне темыТело не более 80 символовТело объясняет что измененоТема отвечает на вопрос: Что делает коммит?"

- Сброс индекса

Существует несколько сценариев использования команды git reset , а именно:

1. Сброс команды git add - например Вы добавили лишний файл и не хотите его присоединять к коммиту (git reset) *также это можно сделать через данную команду - git reset <filename>*
2. Возврат к предыдущему коммиту - например Ваш новый коммит сломал проект и Вы хотите сделать откат к предыдущей версии git reset --hard НО такое использование удаляет изменения без какой-либо регистрации
3. Возврат к определённому коммиту без удаления текущего - git reset HEAD~X, где Х - это число шагов назад.
   Важно! Если вы хотите вернутся на первоначальный коммит Вам необходимо прописать команду, в которой будет указан UID коммита: git reset 0a2b3c4d
   Помните! Когда вы используете команду git reset HEAD~X первоначальный коммит перестает отображаться в git log поэтому сохраните UID заранее!
   Если Вы вызывали команду git reset HEAD~X или git reset^ - аналогично git reset HEAD~1 не более 1 раза, то еще не всё потеряно, тк Git сохраняет ранее использованный UID:
   Для получения UID воспользуйтесь командой: cat .git/ORIG_HEAD или же git reset ORIG_HEADПодробнее о ключе --hard: он не сохраняет изменения в директории!

[!succes] Как работают параметры для git reset--hard--soft--mixed
![[git reset --param.png]]

Подробнее:
--soft - затрагивает только изменения в репозитории но не из коммита и рабочей папки
--mixed - затрагивает изменения в коммите и репозитории но не в рабочей папке (по-умолчанию)
--hard - затрагивает все изменения
Если хотите больше понимать принцип работы --soft то это можно интерпретировать как:
git reset --soft HEAD~1 = git commit --amend

Проще говоря

- Аналог Git reset (git revert)

# история коммитов в кратком виде
git log --oneline 

# краткая справка по команде
revert git revert

# подробная справка по команде 
revert git revert --help 
 
# детали последнего коммита 
git show 
 
# откатить последний коммит (создавая новый `обратный коммит`) 
git revert HEAD 
 
# откатить последний коммит без ввода сообщения для коммита 
git revert HEAD --no-edit 
 
# откатить коммит по его идентификатору (хэш-коду) 
git revert 8ab14c 
 
# откатить третий коммит с конца 
git revert HEAD~3 

# отменить незавершенный откат коммита 
git revert --abort 
 
# откатить серию коммитов 
git revert 9e59768..4b2413e 
 
# откатить коммит без создания нового коммита (изменения попадают в индекс)
git revert 9e59768 --no-commit

- Удаление файлов

[!warning] Как так то...
Так как при использования Git файлы поступают в коммит, удаление данного файла переведет его в статус Untracked -> после Вам придется выполнить git add ., тогда файл станет Staged и лишь затем git commit чтобы окончательно и бесповоротно его удалить из коммита
Но есть более простое и лаконичное решение а именно: git rm <filename>
Он сразу переводит файл в состояние Staged и его можно сразу же коммитить

Если же файл был закоммичен, то необходимо добавить параметр -f (--force) чтобы его удалить из Staged
При удалении папок используйте параметр -r (--recursive) для удаления папки с её содержимым

[!cite] git cleanУдаление файлов, находящихся в состоянии UntrackedПо-умолчанию необходим параметр --force (-f)Для удаления директорий необходим параметр -d

# вызов справки 
git clean --help 

# сценарий 1 
# создадим ненужные файлы
touch some_binary_file{1..9}.bin 
ls
# посмотрим их статус git status 
# очистим Git от этих файлов
git clean -f
ls
git status

# сценарий 2
# создадим пустые папки
mkdir bin
mkdir tmp
ls
# посмотрим их статус
git status 
# очистим Git от этих пустых каталогов 
git clean -d -f 
ls 
git status 
# ключ -n -- 'холостой прогон команды' 
# покажет, что будет происходить при выполнении команды 
git clean -f -n 
git clean -f -d -n 
# ключ -q -- тихое выполнение команды # не выводит комментарии о ходе своего выполнения git clean -f -d -q

- Переименование файлов (git mv)

[!cite] git mv (move - перемещать)
Данная команда позволяет переименовывать файлы, а также перемещать их как Вырезать -> Вставить
Чтобы понять сколько экономии времени дает данная команда, можно пройти данную операцию через команду mv - базовая утилита для любого Linuxmv <filename1> <filename2> -> filename1 - Untracked, filename2 - Untrackedgit rm <filename1> -> filename1 - Removed, filename2 - Stagedgit commit -> filename2 - Unmodified
Очень кропотливо и долго!

[!success] Иначе...
А с использованием git mv <filename1> <filename2> вы сразу получаете <filename2> в Staged и просто его коммитите
Вот так, легко и просто!

# переименование файла в терминале 
mv page1.html index.html 
# набор команд для корректного переименования в Git 
mv page1.html index.html 
git add index.html 
git rm page1.html 

# переименование/перемещение файла в Git одной командой 
git mv page1.html index.html 
# вызов справки git mv --help # создаем папку styles 
mkdir styles 
# перемещаем файл с CSS-стилями в новую папку 
git mv styles.css styles 
# делаем коммит 
git commit -m "create folder for css styles" 
# перименование папки в Git 
git mv styles css 
# создаем папку web_pages 
mkdir web_pages 
# перемещение набора файлов 
git mv *.html web_pages

- Просмотр изменений в Git (git diff)

[!cite] git diff (differences - различия)
Именно это команда в Git позволяет просматривать различия в файлах, если Вы хотите понимать что было изменено в проекте

Данная утилита Git позволяет не только смотреть разницу в файлах и коммитах, но с помощью другой программы просматривать файлы ВНЕ репозитория, называется она git difftool

Для Вашего удобства изменения открываются последовательно и в терминальном текстовом редакторе. Круто!

![[git difftool.png]]

# вызов локальной справки по команде 
git diff 
git diff --help 
# вывод изменений после последнего коммита (не добавленных в индекс) 
git diff 
# вывод изменений после последнего коммита (включая добавленные в индекс) 
git diff HEAD 
# вывод изменений, добавленных в индекс 
git diff --staged 
git diff --cached 
# фоматирование изменений по словам (а не по строкам) 
git diff --word-diff 
# исключение пустых строк из вывода 
git diff -w 
# вывод изменений после HEAD~1 (и до HEAD) 
git diff HEAD~1 
# указание хэша коммита для вывода изменений после него 
git diff 8a8b14c 
# вывод разницы между двумя указанными коммитами 
git diff 8a8b14c b0272be 
# вывод изменений в конкретном файле после указанного коммита 
git diff HEAD~1 web_pages/index.html 
# сравнение двух произвольных файлов (даже вне git-репозитория) 
git diff index.html page2.html 
# вызов локальной справки по команде 
git difftool 
git difftool --help 
# указание хэша коммита для вывода изменений после него с помощью утилиты difftool 
git difftool 8a8b14c

Также для просмотра изменений можно использовать git show, работают он похоже но РАЗНИЦА ЕСТЬ и её важно понимать:

1. Если вы воспользуетесь командой git show ты Вы дополнительно увидите ещё и принадлежащий индексу комментарий, также изменения будут разделены на отдельные коммиты
2. Если вызвать те же самые коммиты в git diff, то утилита отобразит все изменения вместе

git diff HEAD filename2vsgit show HEAD:filename2

Если Вы воспользуетесь параметром --name-only то результаты будут совсем разные, например:
git diff --name-only HEAD

• Вы увидите все файлы изменённые с первого по текущий коммит
  git show --name-only HEAD
• Вы увидите изменения только в текущем коммите

# просмотр коммита (одно и то же) 
git show git diff HEAD~1 
# вывести все накопленные изменения между текущим состоянием и состоянием на момент указанного коммита 
git diff bea5ea0 
# вывести только изменения, выполненные в указанном коммите 
git show bea5ea0 
# вывести все коммиты с изменениями между двумя коммитами 
git show 0e47d61..ca3a6b1 
# вывести все накопленные изменения в файлах между двумя коммитами 
git diff 0e47d61..ca3a6b1 
git diff 0e47d61 ca3a6b1 
# аналогичные команды - просмотр изменений файла в определённом коммите 
git show HEAD~1:styles/styles.css 
git diff HEAD~1 css/styles.css 
# вывести только список файлов, измененных в указанном коммите 
git show 4b2413e --name-only 
git show 55f77dc --name-only 
# вывести только список файлов, измененных с указанного коммита и до текущего состояния репозитория 
git diff 55f77dc --name-only

- История коммитов (git log)

Изучим новые параметры для более подробного изучения коммитов

git log --stat - позволяет показать где происходили изменения, и сколько всего файлов было задействовано в коммите

git log -p (--patch - заплатка) - позволяет подробнее изучить изменения, производимые над каждым файлом

git log -2 - позволяет посмотреть подробно 2 коммита (-2)

git log --graph - позволяет вывести коммиты в псевдографическом последовательном формате

git log --author="Author" - если у Вас есть несколько веток, то можно посмотреть вклад другого пользователя (автора)

git log --pretty=format:"%h - %an - %as - %s" - это форматируемый вывод (%буквы смотреть в документации) %h - hash-код, %an - автор, %as - время, %s - сообщение
(%n = \n = перенос строки)

Также есть еще и git shortlog - данная команда выводит информации о каждом авторе и созданными ими коммитами (-e --email - вывод электронной почты авторов)
Параметры:
-n, --number - вывод количества коммитов,
-s, --summary - суммирует информацию о коммитах авторов
--since="2026-XX-XX" - указать дату с которой нужно сделать выборку коммитов
--until="2026-YY-YY" - обратная, параметру --since=""

# базовое использование команды просмотра логов
git log

# просмотр логов в кратком формате
git log --oneline

# вызов справки по команде
git log --help

# вывод статистики по коммитам
git log --stat	

# просмотр патчей (деталей каждого изменения) по коммитам
git log -p

# ограничение количества комитов в выводе
git log -4

# опции можно сочетать в одной команде
git log –-stat -p
git log -4 --stat -p

# отображение веток в истории коммитов
git log --graph

# клонирование нового репозитория в отдельной папке
cd ..
git clone https://github.com/githubtraining/hellogitworld
cd hellogitworld
ls –a

# использование изученных команд в новом репозитории
git status
git log
git log --oneline
git log --oneline README.txt
git log --stat	
git log --graph

# фильтр коммитов по автору
git log --author="Jordan McCullough" –-oneline

# форматирование: дата, автор, время, сообщение
git log -5 --pretty=format:"%h - %an - %as - %s"
git log -5 --pretty=format:"%h - %an - %as %n >> %s"

# читабельное предложение с помощью форматирования
git log --pretty=format:"This guy:%cn committed with hash '%h' on %cd"


# компактный отчёт о коммитах в репозитории группирует коммиты по авторам и выводит список их имён вместе с количеством сделанных ими коммитов и краткими описаниями этих коммитов
git shortlog

# показывает электронную почту автора рядом с его именем
git shortlog -e

# сортирует вывод по количеству коммитов, от большего к меньшему
git shortlog -n

# выводит только статистику (количество коммитов) без списка сообщений коммитов
git shortlog -s

# фильтрация коммитов по датам "до" и "после"
git shortlog --since="2012-01-01" --until="2012-12-31"

Полезные опции для git log --pretty=format

- Изменение истории (git reflog) - git reference log

[!cite] git reflog - git reference log - журнал операция git
В нём хранится:Перемещение HEADКоммитыСлияние и удаление ветокИзменение тегов

Благодаря данной команде можно отменить действие команды git reset --hard <UID>, достаточно лишь написать git reflog и найти предыдущий UID коммита и проделать git reset --hard <UID> ещё раз

Если Вы хотите отчистить накопившуюся историю действий, то стоит выполнить это:
git reflof expire --expire=7.days --all --verbose

• expire - очистка данных из reflog
• --expire=7.days (истекает за 7 дней) - начиная с 7 дней назад
• --all - данный параметр указывает что при очистке будет удалено всё, а именно:
  1. /refs/tags/* - тэги
  2. /refs/heads/* - ветки
  3. /refs/remote/* - удаленное отслеживание
  4. HEAD (текущая позиция)
• --verbose(многословный) - подробное описание, что было удалено

Также в Git есть и сборщик мусора, при очистке которого репозиторий уменьшает своё место на диске:

git gc --force (GC - Garbage Collector) - очистить мусор

# вывод reference log
# отображает только локальную историю
git reflog

# перемещение в другой репозиторий и вывод аналогичной информации о нем
cd ../hellogitworld
pwd
git reflog

# Сценарий использования: Восстановление удаленного коммита
# 
git reflog
git log --oneline
git reset --hard HEAD~1
git log --oneline
git reflog
git reset --hard 10f7044
git log –oneline

# Сценарий использования: Удаление старых записей
# 
git reflog
git reflog expire --expire=7.days --all --verbose
git reflog

git reflog expire --expire=1.minutes --all –-verbose
git reflog

# запуск сборщика мусора Git
git gc

- Игнорирование файлов (.gitignore)

# Блок 1

## простой пример
# вернемся в каталог с репозиторием first_project
cd ../first_project

# создадим лог-файл
touch events.log
# проверим статус файлов
git status
# создадим файл для настроек игнора
nano .gitignore
# добавим в этот файл имя игнорируемого файла
 events.log

# снова проверим статус файлов
git status
# добавим все изменения в индекс
git add .
# снова проверим статус файлов
git status

# сделаем новый коммит
git commit -m "add .gitignore file"
# проверим список коммитов
git log --oneline


##	шаблоны (*, ?)
# создадим еще пару файлов с логами
touch events_123.log e_123123.log
# проверим, что они появились
ls
# проверим гит-статус
git status
# откроем файл .gitignore, чтобы добавить в него новый шаблон
nano .gitignore
 *.log

# снова проверим гит-статус
git status
# добавим все изменения в индекс
git add .
git status
# добавим новые изменения в прошлый коммит
git commit --amend --no-edit
git status
git log --oneline


## игнор папки
# создадим новую папку с указанным именем
mkdir logs
# переместим все файлы с расширением 'log' в эту папку
mv *.log logs
ls
ls logs/
git status
# откроем файл .gitignore, чтобы добавить в него новый шаблон
nano .gitignore
  logs/*

git status
git add .
git status
git commit --amend --no-edit
git log --oneline
git status
ls


## отмена игнора (“!”)
# 
touch rare_critical_errors.log
ls
git status
nano .gitignore
  !rare_critical_errors.log

git status
git add .
git status
git commit --amend --no-edit
git status
git log –oneline
git log --stat -1

# Блок 2

## форсированное добавление
## (это редкий сценарий)

touch debug.log
ls
git status
# принудительно добавляем в индекс файл debug.log
git add -f debug.log
git status
git commit -m "force adding debug.log"
git status
git log --oneline


## глобальные настройки
# указываем глобальную настройку для пути к файлу .gitignore
git config --global core.excludesfile ~/.gitignore_global
# создаем сам файл по указанному пути
touch ~/.gitignore_global
nano ~/.gitignore_global
  *.tmp

ls
git status
# создаем тестовый файл (должен игнорироваться)
touch tempfile.tmp
git status

- Подробный Roadmap по Git

### Этап 1: Базовые настройки и старт
git init — инициализировать пустой репозиторий, создав скрытую папку `.git`, в которой будут храниться все объекты, индексы и указатели.
git clone — скопировать удаленный репозиторий на локальную машину, автоматически создав ссылку на `origin` и вытащив все историю коммитов.
git config — задать глобальные или локальные параметры (имя, email, редактор), которые будут прописываться в создаваемых коммитах.

### Этап 2: Три состояния Git (Тристаножник)
git add — добавить снимок состояния файла из рабочей директории в индекс (staging area), подготовив его к будущему коммиту.
git status — показать текущее состояние: какие файлы изменены, что находится в индексе, а что не отслеживается Git-ом.
git commit — зафиксировать слепок индекса, создать новый объект коммита в базе данных `.git/objects` и сдвинуть указатель текущей ветки на этот коммит.
git diff — вывести построчные различия: между рабочей директорией и индексом (без флагов) или между индексом и последним коммитом (с флагом `--staged`).
git rm — удалить файл из рабочей директории и одновременно убрать его из индекса (в отличие от ручного удаления, где еще нужен `git add`).
git mv — переименовать файл или переместить его (под капотом это делает git rm старого имени и `git add` нового).

### Этап 3: Ветвление и слияние
git branch — создать, перечислить или удалить независимую линию разработки (ветку), которая под капотом является лишь легковесным указателем на определенный коммит.
git switch — безопасно переключить `HEAD` (указатель на текущую ветку) на другую ветку, обновив рабочую директорию файлами из целевого коммита.
git merge — объединить две ветки, найдя их общего предка и создав новый коммит-слияние (merge commit), который имеет двух родителей.
git rebase — взять коммиты текущей ветки, "отменить" их и поочередно накатить поверх указанной ветки, переписав историю и сделав её линейной.
git log — вывести историю коммитов (в виде графа с флагом `--graph`), читая ее от текущего коммита назад к началу.

### Этап 4: Путешествия во времени (отмена и исправление)
git reset — сдвинуть текущую ветку на другой коммит; в зависимости от флага (`--soft`, `--mixed`, `--hard`) оставит изменения в индексе, вернет в рабочую директорию или полностью удалит.
git restore — безопасно восстановить файлы в рабочей директории из индекса или восстановить файлы в индексе из коммита (современная замена части функционала `git checkout`).
git revert — создать *новый* коммит, который вносит изменения, прямо противоположные указанному коммиту (безопасный способ отмены для публичных веток).
git stash — временно спрятать грязное состояние рабочей директории и индекса в специальный стек, вернув папку к состоянию последнего коммита.
git cherry-pick — взять один конкретный коммит из любой ветки и скопировать его изменения в текущую ветку в виде нового коммита.

### Этап 5: Удаленная работа
git remote — управлять списком закладок на удаленные репозитории (добавить `add`, переименовать `rename`, удалить `rm`).
git fetch — скачать все новые объекты (коммиты, теги, ветки) с удаленного сервера, обновив локальные ссылки (например, `origin/main`), но не трогая локальные ветки.
git pull — сделать `git fetch`, а затем автоматически смержить (`merge`) или перебазировать (`rebase`) скачанные изменения в текущую локальную ветку.
git push — отправить локальные коммиты на удаленный сервер, обновив там ссылку на ветку (потребует `--force` при перезаписи истории).

### Этап 6: Под капотом (Plumbing-команды)
*Изучение этих команд раскроет, что Git — это просто файловая система ключ-значение, а не магия.*
git hash-object — вычислить SHA-1 хэш содержимого файла и записать его как блоб-объект (blob) в базу данных `.git/objects`.
git cat-file — inspected-команда для просмотра типа объекта (`-t`) и его содержимого (`-p`) по его хэшу (распаковывает блобы, деревья и коммиты).
git update-index — вручную добавить блоб в индекс (staging area), минуя рабочую директорию (показывает, что индекс — это просто текстовый файл со ссылками).
git write-tree — прочитать текущее состояние индекса и записать его как объект-дерево (tree) в `.git/objects`.
git commit-tree — создать объект коммита вручную, указав ему дерево (tree) и родительские коммиты (parents), получив на выходе SHA-1 нового коммита (именно так работает `git commit`).
git ls-tree — вывести содержимое объекта-дерева, показывая какие блобы (файлы) и поддеревья (папки) в него входят.

### Этап 7: Инспекция и вспомогательные инструменты
git reflog — показать журнал перемещений указателя `HEAD` (спасательный круг, если ты сделал `reset --hard` и потерял коммиты — они никуда не удалились, пока не собраны сборщиком мусора).
git tag — присвоить постоянное имя (метку) конкретному коммиту, чтобы не искать его по хэшу (используется для релизов).
git bisect — запустить бинарный поиск по истории коммитов, чтобы автоматически найти тот коммит, который ввел баг в проект.
git clean — жестко удалить все неотслеживаемые файлы из рабочей директории (полезно для очистки от «мусора» после сборки).