https://github.com/mindlessmuse666/git-practice-app

Это консольный проект на C# для обучения работе с Git. // This is a C# console-project for training how to work with Git.
https://github.com/mindlessmuse666/git-practice-app

git git-practice git-practice-repo gitignore practice-project

Last synced: about 1 year ago
JSON representation

Это консольный проект на C# для обучения работе с Git. // This is a C# console-project for training how to work with Git.

• Host: GitHub
• URL: https://github.com/mindlessmuse666/git-practice-app
• Owner: MindlessMuse666
• Created: 2023-12-08T18:40:24.000Z (over 2 years ago)
• Default Branch: master
• Last Pushed: 2024-12-14T21:48:50.000Z (over 1 year ago)
• Last Synced: 2025-02-15T14:20:35.363Z (about 1 year ago)
• Topics: git, git-practice, git-practice-repo, gitignore, practice-project
• Language: C#
• Homepage:
• Size: 18.6 KB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

          
# 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] []

  ```

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

  

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

* Пример использования команды `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-адрес удаленного репозитория 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 

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

```

Пример использования команды `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] 

```

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

* `--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`: позволяет просмотреть и выбрать конкретные изменения для восстановления.

* ``: позволяет переключиться на определенный коммит или ветку.

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

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

```

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 [] [...]

```

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

* ``: имя удаленного репозитория `Git` (например, `origin`). Если не указан, `Git` использует имя `origin` по умолчанию.

* ``: имена веток и тегов, которые вы хотите получить из удаленного репозитория. Если не указан, `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 [] [ [...]]

```

Основные флаги `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  

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

```

Пример использования команды `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[=]]

```

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

* `-s` или `--short`: показывает краткую информацию о состоянии файлов в формате `git diff --shortstat`.

* `--long`: показывает длинный формат состояния файлов, включая информацию о последнем коммите для каждого файла.

* `--branch`: показывает текущую ветку и ее состояние.

* `--porcelain`: показывает состояние файлов в машинно-читаемом формате, что полезно для автоматизации.

* `--ignore-submodules`: позволяет игнорировать изменения в подмодулях.

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

```

$ git status

На ветке main

Ваша ветка опережает «origin/main» на 1 коммит.

  (используйте «git push», чтобы опубликовать локальные коммиты)

изменения, которые будут включены в коммит:

  (используйте «git restore --staged ...», чтобы убрать из индекса)

        изменён:   README.md

изменения, которые не проиндексированы для коммита:

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

        изменён:   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 ...

```

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

* `--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.