C#-приложение для практики работы с Git (RU)

Это консольный проект на C# для обучения работе с Git.

Git

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

История Git начинается в 2005 году, когда Линус Торвальдс, создатель ядра Linux, начал разработку новой системы контроля версий. Он был недоволен тогдашними системами контроля версий, которые были неэффективными или сложными в использовании. Git был создан как быстрый, эффективный и легко расширяемый инструмент для работы с крупными проектами с распределенной архитектурой.

С тех пор Git стал не только популярным среди разработчиков Linux, но и быстро распространился по всему миру и стал одним из самых используемых инструментов в различных областях. Git является свободным программным обеспечением с открытым исходным кодом, что позволяет всем желающим использовать, изменять и распространять его бесплатно.

Основные действия с репозиторием

git init

• Cоздание нового локального репозитория Git.

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

• Cинтаксис команды git init:

  git init [--bare] [<directory>]
  

  --bare - определяет репозиторий как "голый", т.е. без рабочей директории. Это используется для создания удаленного репозитория.

  <directory> - указывает директорию, в которой создается локальный репозиторий. Если параметр не указан, репозиторий создается в текущей директории.

• Пример использования команды git init:

  $ cd my_project
  $ git init
  Initialized empty Git repository in /path/to/my_project/.git/
  

git clone

Команда git clone используется для создания локальной копии удаленного репозитория Git. Это позволяет вам получить копию проекта на вашем локальном компьютере и начать работу с ним.

Синтаксис команды git clone:

git clone <URL репозитория> [<название локальной папки>]
# где <URL репозитория> - это URL-адрес удаленного репозитория Git, а <название локальной папки> (необязательный параметр) - это название локальной папки, в которую будет склонирован репозиторий. Если <название локальной папки> не указан, Git автоматически создаст папку с названием репозитория.

Пример использования команды git clone:

git clone https://github.com/username/repo.git
# Эта команда создаст локальную копию удаленного репозитория repo, который находится в аккаунте username на GitHub, в папке с названием repo.

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

git clone https://github.com/username/repo.git myproject
# Эта команда создаст локальную копию удаленного репозитория repo в папке myproject. Если папка myproject уже существует, Git выведет сообщение об ошибке и не склонирует репозиторий.

Работа с изменениями

git add

Команда git add . используется для добавления изменений в индекс Git. Индекс - это промежуточный слой между рабочей директорией (где находятся ваши файлы) и репозиторием Git (где сохраняются изменения). Когда вы делаете изменения в файлах в рабочей директории, они не автоматически добавляются в индекс. Для того, чтобы добавить изменения в индекс, необходимо использовать команду git add.

Синтаксис команды git add .:

git add .
# Эта команда добавляет все измененные файлы в рабочей директории в индекс.

git commit

Команда git commit используется для сохранения изменений, сделанных в вашем локальном репозитории, в истории коммитов. Каждый коммит в Git имеет уникальный идентификатор, дату и время коммита, имя автора, электронную почту и сообщение, описывающее изменения.

Синтаксис команды git commit:

git commit -m "<сообщение коммита>"
Где -m означает "message" (сообщение) и <сообщение коммита> - это краткое описание изменений, сделанных в коммите.

git diff

Команда git diff используется для просмотра различий между версиями файлов в репозитории. Она показывает, какие изменения были сделаны в файлах с момента последнего коммита.

Основной синтаксис команды git diff выглядит так:

git diff [<опции>] [<источник>] [<цель>]
# Где:
<источник> - определяет начальную точку изменений для отображения различий.
<цель> - определяет конечную точку изменений для отображения различий.
<опции> - дополнительные флаги, изменяющие поведение команды.

Основные флаги git diff:

• --cached - сравнивает изменения между вашим индексом (т.е. тем, что будет в следующем коммите) и последним коммитом.
• --stat - показывает статистику изменений для каждого файла.
• --color - отображает различия с использованием цветов для лучшей читаемости.

Примеры использования:

• git diff - простой запуск команды покажет различия между вашей рабочей копией и последним коммитом.
• git diff --cached - покажет различия между вашим индексом и последним коммитом.
• git diff HEAD - покажет различия между вашей рабочей копией и последним коммитом.
• git diff HEAD~2 HEAD - покажет различия между двумя последними коммитами.
• git diff --stat - покажет статистику изменений для каждого файла.
• git diff --color - покажет различия с использованием цветов.

Кроме того, можно использовать git diff для сравнения любых двух коммитов, веток или тэгов в репозитории. Например, git diff branch1..branch2 покажет различия между двумя ветками branch1 и branch2.

git revert

Команда git revert используется для отмены определенного коммита и создания нового коммита, который отменяет изменения предыдущего коммита. Это делает команду безопасной для использования в общем репозитории, поскольку она не изменяет историю коммитов.

Синтаксис команды git revert:

git revert <commit>
# Где <commit> - это хэш-идентификатор коммита, который нужно отменить.

Пример использования команды git revert:

$ git log --oneline
d3b3d43 Commit C
786f7f8 Commit B
12556fa Commit A

$ git revert d3b3d43
# Эта команда создаст новый коммит, который отменяет изменения, внесенные коммитом с хэш-идентификатором d3b3d43.

Управление историей

git reset

Команда git reset используется для отмены изменений в вашем локальном репозитории. Она позволяет сбрасывать состояние вашего рабочего каталога до определённого коммита, изменяя при этом историю коммитов и/или состояние индекса (staging area). В зависимости от используемых опций, git reset может изменять HEAD (текущий коммит), индекс и рабочий каталог.

Синтаксис команды git reset:

git reset [--soft | --mixed | --hard] <commit>

Основные опции:

• --soft: Сбрасывает HEAD до указанного коммита, но оставляет рабочий каталог и индекс (staging area) без изменений. Изменения, которые были сделаны после указанного коммита, останутся в индексе, готовые к коммиту.
• --mixed (по умолчанию): Сбрасывает HEAD и индекс до указанного коммита, но оставляет рабочий каталог без изменений. Это означает, что изменения, которые были проиндексированы, будут отменены, но останутся в рабочем каталоге как неиндексированные изменения.
• --hard: Сбрасывает HEAD, индекс и рабочий каталог до состояния указанного коммита. Все изменения в рабочем каталоге и индексе будут потеряны. Эту опцию следует использовать с осторожностью.

Пример использования команды git reset:

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

$ git reset --mixed HEAD~2
# Для полного удаления последних двух коммитов, включая все изменения в рабочем каталоге:

$ git reset --hard HEAD~2
# Использование команды git reset обеспечивает отличный инструмент для управления историей ваших коммитов и состоянием индекса, позволяя исправлять ошибки в истории коммитов или отменять изменения до их публикации в удалённом репозитории. Однако, использование --hard может привести к потере данных, поэтому перед его применением рекомендуется убедиться в отсутствии важных несохранённых изменений.

git log

Команда git log используется для просмотра истории коммитов в репозитории Git. Она отображает список коммитов в обратном хронологическом порядке, начиная с последнего.

Пример использования команды git log:

git log
# Эта команда показывает список всех коммитов в репозитории, от самых последних до самых старых. Каждый коммит включает SHA-1 хеш, автора коммита, дату и время коммита, и комментарий.

Основные флаги команды git log:

• --oneline: показывает каждый коммит в одной строке, содержащей только его SHA-1 хеш и комментарий.

• --graph: показывает историю коммитов в виде графа, что позволяет легко визуализировать разветвленную историю ветвлений и слияний.

• --author=<имя>: показывает только коммиты, сделанные указанным автором.

• --since=<дата>: показывает только коммиты, сделанные после указанной даты.

• --until=<дата>: показывает только коммиты, сделанные до указанной даты.

• -n <количество>: показывает только указанное количество последних коммитов.

• --grep=<строка>: показывает только коммиты, содержащие указанную строку в своих комментариях.

Пример использования флага --since:

git log --since=2022-01-01
# Эта команда показывает список всех коммитов, сделанных после 1 января 2022 года.

Пример использования флага --author:

git log --author="John Doe"
# Эта команда показывает список всех коммитов, сделанных автором с именем "John Doe".

Пример использования флага --grep:

git log --grep="bug"
# Эта команда показывает список всех коммитов, содержащих слово "bug" в своих комментариях.

git checkout

Команда git checkout в Git используется для переключения между ветками, проверки коммитов и отката изменений. Она позволяет переключаться между различными состояниями вашего репозитория.

Основные флаги:

• -b: создать новую ветку и переключиться на нее. Например, git checkout -b new-branch создаст новую ветку с названием "new-branch" и переключится на нее.
• -f: принудительно перезаписывает локальные изменения, которые не были зафиксированы. Этот флаг используется только в крайних случаях.
• -p: позволяет просмотреть и выбрать конкретные изменения для восстановления.
• <commit/branch>: позволяет переключиться на определенный коммит или ветку.

Примеры использования:

Переключение на ветку:

git checkout main
# Эта команда переключает вас на ветку "main".

Создание новой ветки и переключение на нее:

git checkout -b new-branch
# Эта команда создает новую ветку с названием "new-branch" и переключает вас на нее.

Переключение на определенный коммит:

git checkout 2a3e8c9
# Эта команда переключает вас на коммит с указанным идентификатором.

Отмена изменений в файле:

git checkout myfile.txt
# Эта команда отменяет изменения в файле "myfile.txt" и восстанавливает его до последней зафиксированной версии.

Восстановление определенных изменений:

git checkout -p myfile.txt
# Эта команда позволяет вам просмотреть изменения в файле "myfile.txt" и выбрать, какие из них восстановить.

Управление ветками

git branch

Команда git branch используется для просмотра, создания и удаления веток в репозитории Git. Ветка - это отдельная линия разработки, которая может включать в себя свой собственный набор коммитов.

Основные флаги команды git branch:

• -a - показывает все ветки (включая удаленные)
• -d - удаляет ветку (данная команда удаляет только те ветки, которые были слиты в текущую ветку)
• -D - удаляет ветку без проверки, были ли все её изменения слиты с текущей веткой
• -m - переименовывает текущую ветку
• -r - показывает все удаленные ветки

Примеры использования команды git branch:

Просмотр списка веток:

git branch

Создание новой ветки:

git branch new-branch

Переименование текущей ветки:

git branch -m new-branch-name

Удаление ветки:

git branch -d branch-to-delete

Просмотр удаленных веток:

git branch -r
# Команда git branch позволяет управлять ветками в репозитории и помогает организовать работу в команде. Она также помогает контролировать историю изменений в проекте.

git merge

Команда git merge используется для объединения изменений из одной ветки в другую. Она применяется для слияния изменений, которые были внесены в отдельной ветке, обычно для объединения фиксации ошибок или добавления функциональности в проект.

Синтаксис команды git merge:

git merge <имя ветки>
# где <имя ветки> - это имя ветки, изменения из которой вы хотите объединить в текущую ветку.

Пример использования команды git merge:

Сначала, вам нужно переключиться на ветку, в которую вы хотите объединить изменения:

git checkout master

Затем вы можете выполнить команду git merge, указав имя ветки, из которой вы хотите получить изменения:

git merge feature-branch

В этом примере мы объединяем изменения из ветки feature-branch в текущую ветку master.

Основные флаги команды git merge:

• --no-ff: Отключает быстрое слияние, что создает коммит с объединением, даже если изменения можно было бы просто быстро применить.
• --abort: Отменяет текущее слияние и возвращает репозиторий в предыдущее состояние.

Пример использования флага --no-ff:

git merge --no-ff feature-branch
# В этом примере мы отключаем быстрое слияние и создаем новый коммит с объединением.

Пример использования флага --abort:

git merge --abort
# В этом примере мы отменяем текущее слияние и возвращаем репозиторий в предыдущее состояние.

Работа с удаленным репозиторием

git fetch

Команда git fetch используется для получения изменений из удаленного репозитория Git, но не вносит изменения в локальную ветку. Эта команда позволяет вам получить информацию о ветках и коммитах, которых еще нет в локальном репозитории.

Синтаксис команды git fetch:

git fetch [<remote>] [<refspec>...]

Основные флаги:

• <remote>: имя удаленного репозитория Git (например, origin). Если не указан, Git использует имя origin по умолчанию.
• <refspec>: имена веток и тегов, которые вы хотите получить из удаленного репозитория. Если не указан, Git получает все ветки и теги.

Пример использования команды git fetch:

git fetch
# Эта команда получает все изменения из удаленного репозитория Git, который связан с вашим локальным репозиторием. После выполнения этой команды вы можете выполнить команду git log origin/master для просмотра истории изменений в удаленной ветке master.

git fetch origin feature-branch
# Эта команда получает все изменения из удаленной ветки feature-branch в удаленном репозитории Git, связанном с вашим локальным репозиторием. После выполнения этой команды вы можете выполнить команду git log origin/feature-branch для просмотра истории изменений в удаленной ветке feature-branch.

git pull

Команда git pull используется для получения изменений из удаленного репозитория и объединения их с вашей локальной веткой.

Основной синтаксис команды git pull выглядит следующим образом:

git pull [<options>] [<repository> [<refspec>...]]

Основные флаги git pull:

• --rebase: выполняет перебазирование текущей ветки на самый новый коммит вместо создания слияния (merge). Рекомендуется использовать этот флаг, если вы хотите, чтобы история коммитов оставалась простой и понятной.
• --no-rebase: отменяет перебазирование и выполняет слияние вместо этого.
• --no-commit: предотвращает создание автоматического коммита после выполнения слияния. Это дает возможность внести дополнительные изменения перед фиксацией изменений.
• --ff-only: выполнить слияние только в том случае, если это можно сделать быстрым перемещением ветки вперед (fast-forward).
• --no-ff: выполнить слияние только как коммит слияния (merge commit), даже если это можно сделать быстрым перемещением ветки вперед.

Примеры использования команды git pull:

Простой git pull, который получает изменения из удаленной ветки и автоматически объединяет их с локальной веткой:

git pull

git pull с использованием флага --rebase, который перебазирует текущую ветку на самый новый коммит из удаленной ветки вместо создания слияния:

git pull --rebase

git pull с использованием флага --no-commit, который предотвращает создание автоматического коммита после выполнения слияния:

git pull --no-commit

git pull с использованием флага --ff-only, который выполнит слияние только в том случае, если это можно сделать быстрым перемещением ветки вперед (fast-forward):

git pull --ff-only

git pull с использованием флага --no-ff, который выполнит слияние только как коммит слияния (merge commit), даже если это можно сделать быстрым перемещением ветки вперед:

git pull --no-ff

git push

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

Синтаксис команды git push:

git push <remote> <branch>
# Где <remote> - это имя удаленного репозитория, куда вы хотите отправить изменения, а <branch> - это название ветки, которую вы хотите отправить.

Пример использования команды git push:

git push origin main
# Эта команда отправляет изменения из вашей локальной ветки main в удаленный репозиторий с именем origin.

Помимо базового синтаксиса, команда git push имеет несколько флагов, которые можно использовать для дополнительной настройки:

• -u или --set-upstream - устанавливает отслеживание для ветки, что позволяет вам использовать git push и git pull без указания имени удаленного репозитория и названия ветки;
• -f или --force - заставляет Git принудительно заменить удаленную ветку измененной локальной веткой, даже если это приведет к потере данных;
• -n или --dry-run - позволяет протестировать команду git push, не отправляя реальных изменений в удаленный репозиторий;
• -v или --verbose - выводит дополнительную информацию о процессе отправки изменений.

Пример использования команды git push с флагом:

git push -u origin main
# Эта команда отправляет изменения из вашей локальной ветки main в удаленный репозиторий с именем origin и устанавливает отслеживание для этой ветки.

Работа с файлами

git status

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

Синтаксис команды git status:

git status [-s] [--long] [--branch] [--porcelain] [--ignore-submodules[=<when>]]

Основные флаги:

• -s или --short: показывает краткую информацию о состоянии файлов в формате git diff --shortstat.
• --long: показывает длинный формат состояния файлов, включая информацию о последнем коммите для каждого файла.
• --branch: показывает текущую ветку и ее состояние.
• --porcelain: показывает состояние файлов в машинно-читаемом формате, что полезно для автоматизации.
• --ignore-submodules: позволяет игнорировать изменения в подмодулях.

Пример использования команды git status:

$ git status

На ветке main
Ваша ветка опережает «origin/main» на 1 коммит.
  (используйте «git push», чтобы опубликовать локальные коммиты)

изменения, которые будут включены в коммит:
  (используйте «git restore --staged <file>...», чтобы убрать из индекса)

        изменён:   README.md

изменения, которые не проиндексированы для коммита:
  (используйте «git add <file>...», чтобы проиндексировать)

        изменён:   index.html

нет изменений добавленных для коммита (используйте «git add» и/или «git commit -a»)
Эта команда показывает, что находитесь на ветке "main", ваша локальная ветка опережает ветку "origin/main" на один коммит, и что были внесены изменения в файлы "README.md" и "index.html". Файл "README.md" был проиндексирован и готов к коммиту, а файл "index.html" не был проиндексирован. Для того, чтобы проиндексировать файл "index.html", нужно использовать команду "git add index.html".

git rm

Команда git rm используется для удаления файлов из рабочего каталога и индекса (staging area). Это эффективный способ одновременно удалить файл из отслеживаемых и подготовить это изменение к коммиту. После применения команды файлы будут удалены из вашего рабочего каталога и не будут отслеживаться Git.

Синтаксис команды git rm:

git rm <file>...

Основные опции:

• --cached: Удаляет файлы из индекса, сохраняя их в вашем рабочем каталоге. Это полезно, если вы хотите перестать отслеживать файл (например, добавить его в .gitignore), но не хотите физически удалять его из своей файловой системы.
• -f или --force: Принудительно удаляет файлы, даже если они имеют изменения, отслеживаемые Git, или уже добавлены в индекс. Используйте с осторожностью, чтобы не потерять важные изменения.

Пример использования команды git rm:

$ git rm example.txt
# Удаление файла example.txt из рабочего каталога и индекса.

$ git rm --cached config.ini
# Для удаления файла config.ini только из индекса, сохраняя его в рабочем каталоге.

После выполнения команды git rm, изменения готовы к коммиту. Это означает, что вы можете зафиксировать удаление файлов в истории репозитория, используя git commit.

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

git mv

Команда git mv используется для перемещения или переименования файла или директории в репозитории Git. Это действие автоматически индексируется Git, что упрощает подготовку изменений к коммиту. В отличие от ручного переименования и последующего использования git add на новый файл и git rm на старый, git mv выполняет обе операции одновременно.

Синтаксис команды git mv:

git mv <источник> <назначение>
# <источник>: текущее имя файла или директории.
# <назначение>: новое имя файла или директории, или путь к директории, куда должен быть перемещён файл или директория.

Примеры использования команды git mv:

Переименование файла:

$ git mv староеИмя.txt новоеИмя.txt
# Эта команда переименовывает файл староеИмя.txt в новоеИмя.txt и автоматически индексирует это изменение для следующего коммита.

Перемещение файла в директорию:

$ git mv example.txt директория/
# Эта команда перемещает файл example.txt в директорию директория/ и также индексирует это изменение.

После выполнения команды git mv, изменения готовы к коммиту. Вы можете использовать git commit для зафиксирования переименования или перемещения файлов в истории вашего репозитория.

Использование команды git mv обеспечивает эффективный и простой способ управления файлами и директориями в вашем репозитории, автоматически отслеживая эти изменения в системе контроля версий.

---

C#-application for Git practice (ENG)

This is a project for training how to work with Git.