Git снизу вверх

Как пользоваться Git?

Дальше я буду предполагать, что вы выполнили установку и базовую настройку git. Кроме установки, вам нужно указать правильный адрес электронной почты и имя пользователя для доступа к серверу Git, например, на GitHub. Если вы этого еще не сделали смотрите инструкцию установка Git в Ubuntu 16.04.

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

Создание проекта

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

Эта команда создаст нужную структуру папок и переводит текущий каталог в только что созданный. Теперь создадим первый файл нашего проекта:

Проект готов, но система контроля версий git еще не знает об этом.

Настройка проекта в git

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

После того как репозиторий будет создан, вам нужно добавить свои файлы в него. Каждый файл нужно добавлять отдельно или сказать утилите, что необходимо добавить все файлы явно. Пока вы не добавите файл сам он не будет отслеживаться. Новые файлы в будущем тоже нужно добавлять, они не добавляются автоматически.  Сначала добавим текущую папку:

Если все прошло хорошо, то команда ничего не выведет.

Фиксация изменений

Изменения тоже автоматически не отслеживаются. Фиксация изменений выполняется с помощью команды commit. Вам нужно указать что было изменено с помощью небольшого комментария, буквально в несколько предложений. Хорошая практика выполнять фиксацию перед каждым серьезным изменением.

Таким образом, вы будете хранить все версии проекта, от самой первой и до текущей, а также сможете знать что, когда и где было изменено. Чтобы создать свой первый коммит выполните:

Команде необходимо передать два параметра, первый — это -m, ваш комментарий, второй -a, означает, что нужно применить действие ко всем измененным файлам. Для первого раза используется этот параметр, но обычно вам нужно указать измененные файлы или каталоги. Например, можно делать так:

Отправка изменений

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

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

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

Вы можете использовать не только github сервера, но и любые другие. Теперь для отправки ваших изменений используйте такую команду:

Команда push указывает, что нужно отправить данные в удаленный репозиторий, origin — наш настроенный репозиторий, а master — ветвь.

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

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

Опция -a указывает что нужно вывести все ветви, даже не синхронизированные. Звездочка указывает на активную ветвь. Теперь создадим ветвь для разработки с помощью команды checkout:

Переключаться между ветвями можно тоже с помощью той же команды:

Теперь создадим еще один файл:

И добавим его в нашу новую ветвь develop:

Сделаем коммит для внесенных изменений:

Дальше проверим существует ли этот файл в основной ветке master или только в дополнительной. Смотрим текущую ветку:

Затем переключаемся на ветку master и снова смотрим:

Здесь файла нет, так и должно быть. В git есть такая полезная вещь, как слияние. С помощью нее вы можете объединить две ветви. Например, переместить код из рабочей ветки в стабильную. Для этого достаточно выполнить команду merge:

Перед тем как будет выполнено слияние вам нужно ввести комментарий, зачем это нужно. Затем если вы еще раз выполните ls, то увидите, что здесь уже есть нужный файл. Наши примеры git подошли к концу.

Работа со своим первым репозиорием Git

Доступ получен, исходники в Вашем распоряжении. Теперь переключаемся на работу с TortoiseGit. Для порядка, каждую из операций, которые мы будем сейчас выполнять я буду также записывать в виде консольной команды – лишним знание работы с консолью никогда не будут.

Итак, выбираем директорию на жестком диске где мы будем хранить все файлы. Далее действуем следующим образом:

1. Вызываем контекстное меню и выбираем пункт “TortoiseGit — Settings“:

В появившемся окне переходим сразу к пункту “Git – Config” и записываем свое имя и адрес электронной почты. Эти данные должны в точности совпадать с теми, что записаны в Вашем аккаунте на github, иначе ваш ключ просто не подойдет.

2. Клонируем репозиторий. Для этого заходим на страницу проекта, и копируем в буфер адрес:

Теперь жмем правой кнопкой мыши на директории, в которой будем хранить исходники и в меню выбираем “Git Clone..“:

В открывшемся окне в поле URL вставляем скопированный адрес и жмем “Ok”:

Начнется процесс клонирования репозитория.

Всё вышесказанное можно было бы заменить всего двумя командами в консоли:

После клонирования репозитория Вы автоматически переключитесь на нашу главную ветку (master). Так как каждый из нас занят определенной работой в проекте, то у каждого своя ветвь в репозитории, поэтому и Вам придется создавать свой branch. Делается это достаточно просто.

3. Создаем свою ветку. Для этого жмем правую кнопку мыши на директории в которую мы клонировали репозиторий и выбираем в меню “TortoiseGit — Create Branch“:

В открывшемся оке задаем название новой ветки и указываем на основании какой ветки репозитория мы будем создавать новую. Жмем “Ок”, подтверждая создание ветки. Теперь переключаемся на свой новый branch.

Выбираем в меню “TortoiseGit – Switch/Checkout…“:

В открывшемся окне выбираем нашу новую ветку и жмем “Ок”. Убеждаемся, что мы успешно переключились:

По сути, все что касалось создания нового branch’a в консоли решилось бы всего одной командой:

4. Программируем. Теперь, когда мы все настроили – открываем необходимый проект в Delphi, вносим свои коррективы, изменяем модули и т.д. В общем ведем нормальную плодотворную работу с проектом.

5. Вносим изменения в репозиторий. После того как внесены какие-то изменения нам необходимо их закрепить в Git. И здесь опять же проявляется отличие этой системы контроля версий от того же SVN. Дело в том, что Commit в Git не сбрасывается сразу на сервер. Для того, чтобы внести изменения в удаленный репозиторий используется команда PUSH. В общем виде работа может быть построена следующим образом:

1. Вносятся изменения в проект

2. Изменения закрепляются в вашем локальном репозитории, используя команду Commit в меню или, используя консоль:

3. Когда Вам необходимо/удобно/требуется закрепить все изменения на сервере выполняем push в свою ветку (brunch). Команда консоли выглядит так:

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

Для этого выбираем новый файл, вызываем меню и выбираем “Add…”:

По рисунку можно видеть, что я вношу в индекс новый файл text.txt. Жмем “Ok”.

После того как файл добавлен, можно сразу же сделать Commit – кнопка Commit появится в окне с выводом консоли. Жмем её и откроется окно для внесения Commit’a:

Заполняем поле с описанием, жмем “Ок”  и коммит готов. Если хотите сразу отправить эти изменения в репозиторий, то в окне с выводом консоли появится также кнопка PUSH. Если же Вас не устраивает таскать по 1 файлику туда-сюда или изменения столь незначительны, что их нет смысла отправлять на сервер, то просто продолжаете дальше кодить, а push выполним позднее.

Чтобы выполнить команду push можете поступить следующим образом:

1. Зажимаем Shift и вызываем контекстное меню. В меню должны появится дополнительные команды:

Выбираем команду Push. Перед Вами откроется окно следующего содержания:

Все, что от Вас требуется на данном этапе – нажать на кнопку (на рисунке она выделена красным) найти в списке удаленную ветку в которую вы делаете push и два раза нажать Ok. Все изменения, произведенные Вами в локальном репозитории отправятся в Сеть.

Просмотр изменений в истории

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

 показывает изменения в каждом коммите;

 показывает сокращённую статистику для коммитов, например изменённые файлы и количество добавленных/удалённых строк в каждом их них;

 показывает n последних коммитов;

 и  позволяет отфильтровать коммиты по промежутку времени, например  покажет коммиты с 1 января 2019 года;

 позволяет указать формат логов (например, ), также можно использовать  для большей кастомизации, например ;

 и  фильтруют коммиты с сообщениями/изменениями кода, которые содержат указанную строку, например,  позволяет посмотреть добавление/удаление функции;

 пропускает коммиты со слиянием веток;

 позволяет посмотреть, какие коммиты из ветки 2 не находятся в ветке 1 (полезно при слиянии веток)

Например,  покажет, каких коммитов из ветки test нет в master (о ветках поговорим чуть позже).

 показывает коммиты, которые есть либо в ветке 1, либо в ветке 2, но не в обеих; знак  обозначает коммиты из , а  — из .Обратите внимание: используется три точки, а не две;

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

Это можно использовать, например, для выяснения того, какой коммит привёл к определённому багу (чтобы можно было его откатить)

Другой полезной командой является , которая для каждой строки файла показывает автора и контрольную сумму последнего коммита, который изменил эту строку.  позволяет ограничить эту команду заданными строками. Это можно использовать, например, для выяснения того, какой коммит привёл к определённому багу (чтобы можно было его откатить).

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

Примечание Не путайте  с ! Первый ищет по файлам среди коммитов, а последний смотрит на сообщения логов.

Step 0: Install git and create a GitHub account

The first two things you’ll want to do are install git and create a free GitHub account.

Follow the instructions here to install git (if it’s not already installed). Note that for this tutorial we will be using git on the command line only. While there are some great git GUIs (graphical user interfaces), I think it’s easier to learn git using git-specific commands first and then to try out a git GUI once you’re more comfortable with the command. A note: 95% of other online git resources and discussions will also be for the command-line interface. 

Once you’ve done that, create a GitHub account here.

Подробнее о внутреннем строении Git

Репозитории 

Репозиторий (репо, реп) – это хранилище файлов проекта. То есть все компоненты, относящиеся к одному приложению (код, изображения, конфигурационные файлы, стили, скрипты и т.п.). С ним как раз и работают люди, ведущие совместную работу над одним продуктом.

При создании репозитория в папке с файлами формируется .git-директория, включающая в себя информацию, необходимую для корректной работы с системой контроля версий (количество коммитов, ветвей разработки и прочих необходимых деталей). 

По умолчанию каталог .git скрыт, но его видят git-приложения, например git, Sublime Merge, Gitfox и другие аналоги. 

Коммиты, пуши и стейджинг

Коммит – это единица контента, хранящая в себе информацию о том, какие компоненты репозитория были изменены на текущий момент времени. 

За счет них и работает контроль версий. Допустим, вы решили немного поменять оформление сайта. Открываете файл .css, вводите туда новое значение шрифтов или цветов, а потом сохраняете их. Чтобы это изменение отразилось в git, нужно создать коммит (git commit — m, «описание коммита»). Теперь вы можете в любой момент вернуться к этому этапу в разработке сайта. 

Стейджинг-зона – это временное пристанище измененных файлов. Отправляясь в стейджинг-зону (git add), они помечаются как «в разработке», но при этом из них все еще можно выбрать готовые файлы, чтобы непосредственно их закоммитить. Файлы хранятся в стейджинг-зоне (git add) до тех пор, пока пользователь не сделает коммит и не запушит (git push) изменения на сервер, то есть не выгрузит с локального репозитория в удаленный. 

Удаленные репозитории (GitHub, GitLab и т.п.)

Большинство разработчиков хранят репозитории не на локальных машинах, а в хранилищах наподобие GitHub, BitBucket, GitLab и в их аналогах. Это специализированные веб-ресурсы, поддерживающие все функциональные особенности git и позволяющие работать десяткам разработчиков над одним проектом параллельно, используя единое пространство для хранения всех файлов, их версий и прочих компонентов приложения или сайта.

Коммиты остаются в локальном репо, но с помощью команды push можно отправить их в GitHub. А при помощи команды pull можно вытащить их в локальный реп, чтобы иметь под рукой самую новую версию проекта для дальнейшей разработки новых функций. 

Ветви и мерджинг

Две функции, вокруг которых строится параллельная разработка. 

Ветви (branches) – это разные состояния одной программы. Например, есть ветка master (иногда ее называют main) – в ней обычно хранится приложение с полным набором функций и дизайном, готовое к деплою (то есть публикации в App Store или загрузке на сервер). Есть ветка develop, в которой программисты корпят над нововведениями. Веток может быть неограниченное количество, хоть по одной для каждой функции. 

С помощью ветвей можно избежать изменений в программе до того, как новшества будут протестированы. А еще это помогает вносить срочные изменения в main-ветку, не добавляя при этом в программу недоделанные функции или изменения в дизайне. 

Мерджинг (merging) – это процесс объединения одной ветки с другой. Чаще всего – ветки develop с веткой main.

Пул-реквесты

Pull Request – это запрос на проверку и одобрение кода. Когда один из программистов заканчивает свою работу, он отправляет PR своим коллегам. Те проводят аудит кода и выносят вердикт, публикуется этот код или нет. 

При этом сам пул-реквест является не просто оповещением о готовности куска кода – это целая система взаимодействия и обсуждения. Один PR может превратиться в десятки комментариев и правок кода. После «обработки» PR превращается в мердж. 

Начальная настройка

Давайте создадим каталог, внутри которого мы будем работать. В качестве альтернативы вы можете использовать Git для управления одним из существующих проектов; в таком случае вам не нужно будет создавать демо-каталог, как показано ниже:

mkdir my_git_project
cd my_git_project

Первым этапом является инициализация Git в каталоге. Это можно сделать с помощью команды init, которая создает каталог .git, содержащий всю информацию, связанную с Git для вашего проекта.

git init

Далее нам нужно указать имя и адрес электронной почты. Вы можете сделать это следующим образом, подставив свое имя и электронную почту:

git config --global user.name 'Shaumik'
git config --global user.email 'sd@gmail.com'
git config --global color.ui 'auto'

Важно отметить, что если вы не укажите свое имя и адрес электронной почты, то будут использованы значения по умолчанию. В нашем случае, значениями по умолчанию были бы имя пользователя donny и адрес электронной почты donny@ubuntu

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

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

Ветви в GIT

При разработке новой версии программы лучше всего работать над копией исходного проекта, называемой ветвью. Ветви имеют свою собственную историю, а их изменения изолированы от основного репозитория до тех пор, пока вы не решите снова объединить их. Это делается по нескольким причинам:

• Исправная, стабильная версия кода не будет повреждена;
• Люди могут безопасно разрабатывать собственные версии отдельно друг от друга;
• Разработчики могут работать на своей ветви без опасения, что кто-то изменит их код;
• Когда разработчики не уверены, как сделать лучше, они могут работать над своими версиями в отдельных ветвях, а затем сравнить результаты между собой.

1. Создание новых ветвей – git branch

Ветвь по умолчанию для каждого репозитория называется master. Для создания другой используйте команду .

Тем самым вы создаёте новую ветвь, на данном этапе одинаковую с master.

2. Смена ветвей – git checkout

Теперь, когда мы выполнили команду , мы получили доступ к двум опциям:

Master – текущая ветвь и помечена звёздочкой. Однако мы хотим работать над новыми замечательными версиями программы, поэтому нам нужно переключиться на другую ветвь. Это делается командой с указанием одного параметра – ветвь для переключения.

3. Объединение ветвей – git merge

Наша «новая версия» будет просто другим текстовым файлом под названием feature.txt. Мы создадим его, добавим и зафиксируем.

Далее мы вернемся в ветвь master.

Теперь, если мы откроем наш проект в файловом менеджере, мы заметим, что feature.txt исчез. Это потому, что мы вернулись в master-ветвь, и здесь feature.txt так и не был создан. Чтобы перенести его сюда, нам нужно объединить две ветви вместе командой , применив изменения, сделанные в amazing_new_feature, к основной версии проекта.

Ветвь master обновлена, а ветвь awesome_new_feature branch больше не нужна и мы можем её удалить.

Step 8: Create a pull request (PR)

A pull request (or PR) is a way to alert a repo’s owners that you want to make some changes to their code. It allows them to review the code and make sure it looks good before putting your changes on the primary branch.

This is what the PR page looks like before you’ve submitted it:

And this is what it looks like once you’ve submitted the PR request:

You might see a big green button at the bottom that says ‘Merge pull request’. Clicking this means you’ll merge your changes into the primary branch..

Sometimes you’ll be a co-owner or the sole owner of a repo, in which case you may not need to create a PR to merge your changes. However, it’s still a good idea to make one so you can keep a more complete history of your updates and to make sure you always create a new branch when making changes.

Что такое Git?

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

Чаще всего Git используется в разработке приложений и сайтов, но он также находит применение и в других сферах, например в переводах книг. 

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

Система контроля

Под системой контроля в контексте Git подразумевается программный механизм для работы с контентом. В «работу» также входит хранение, передача данных, отслеживание изменений и прочие аспекты.

Система контроля версий

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

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

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

Распределенная система контроля версий

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

Для этого используются удаленные файловые хранилища, где лежат различные вариации кода. Например:

• основное приложение со всеми нужными функциями,

• его версия с новым дизайном,

• новая версия с дополнительными возможностями. 

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

Step 10: Get changes on GitHub back to your computer

Right now, the repo on GitHub looks a little different than what you have on your local machine. For example, the commit you made in your branch and merged into the primary branch doesn’t exist in the primary branch on your local machine.

In order to get the most recent changes that you or others have merged on GitHub, use the git pull origin master command (when working on the primary branch). In most cases, this can be shortened to “git pull”.

This shows you all the files that have changed and how they’ve changed.

Now we can use the git log command again to see all new commits.

(You may need to switch branches back to the primary branch. You can do that using the git checkout master command.)

Ummmmm … что? Могу ли я сделать это на сайте?

Вы можете!

GIF черезGIPHY

Один из способов сделать это — просто проверить кнопку, о которой мы упоминали ранее, когда редактировали файл README. Супер просто!

Вы также можете в любое время создать новую ветку прямо на веб-сайте, перейдя в свой репозиторий, щелкнув раскрывающееся меню в левой и средней части экрана с надписью «Branch: master», введя имя ветви и выбрав Ссылка «Создать ветку» (или нажмите Enter на клавиатуре). Теперь у вас есть две ветви, которые выглядят одинаково! Это отличное место для внесения изменений и их тестирования, прежде чем вы захотите, чтобы они повлияли на основную ветку.

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

Если вы работаете с отдельной веткой, ваши изменения влияют только на эту ветку.

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

Вы можете открыть запрос на удаление, как только сделаете коммит, даже если вы еще не закончили свой код. Вы можете сделать это прямо на сайте, если вам удобнее. Если вы внесли некоторые изменения в свою ветку и хотите объединить их, вы можете

• Нажмите вкладку запроса на извлечение рядом с верхним центром экрана.
• Нажмите зеленую кнопку «Новый запрос на извлечение»
• Перейдите в поле «Примеры сравнений» и выберите ветку, которую вы сделали, чтобы сравнить с исходной веткой.
• Посмотрите свои изменения, чтобы убедиться, что они действительно то, что вы хотите зафиксировать.
• Затем нажмите большую зеленую кнопку «Создать запрос на извлечение». Дайте ему название и напишите краткое описание ваших изменений. Затем нажмите «Создать запрос на извлечение!»

Новый запрос на извлечение
Создать пул-запрос

Теперь, если это ваш репозиторий, вы можете объединить ваш запрос на извлечение, нажав зеленую кнопку «Слить запрос на извлечение», чтобы объединить изменения в мастер. Нажмите «Подтвердить слияние», затем удалите ветвь после того, как ваша ветвь была включена с помощью кнопки «Удалить ветвь» в фиолетовом поле.

Если вы участвуете в проекте, у людей в команде (или у рецензента) могут возникнуть вопросы или комментарии. Если вам нужно что-то изменить, это время! Если все хорошо, они могут развернуть изменения прямо из ветки для окончательного тестирования перед тем, как объединить их. И вы можете развернуть свои изменения, чтобы проверить их в производстве.

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

Навигация

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

Detaching HEAD

Давайте разберемся, как нам откатиться к более старой версии нашего репозитория.

У git есть указатели на коммиты, своеобразный ярлыки (бирка), которые перемещаются от коммита к коммиту. Одним из таких ярлыков-указателей является .

— это символическое имя текущего выбранного коммита. По сути это, тот коммит, над которым мы в данным момент работаем.

Указатели могут ссылаться на другие указатели, обычно указывает на имя ветки. Но это можно изменить, например указать hash нужного коммита, чтобы откатиться к нему.

Создадим еще один файл и сделаем третий коммит:

Мы видим, что сейчас указывает на , это тоже указатель, обозначающий ветку. То есть указывает на , который в свою очередь указывает на коммит . Отделение (detaching) означает лишь присвоение его не ветке, а конкретному коммиту.

Представим, что нам надо посмотреть, как выглядел наш репозиторий после второго коммита. Для этого используем команду и хэш второго коммита. Кстати, можно не указывать его целиком, достаточно первых 5 символов.

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

Вызвав видим, что теперь указывает на второй коммит:

При этом мы не потеряли третий коммит и все изменения в нем, можем убедиться в этом с помощью следующей команды:

Вернем указатель на :

Относительные ссылки

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

Относительные ссылки — мощный инструмент, но мы разберем два простых способа использования:

• Перемещение на один коммит назад
• Перемещение на коммитов назад

Для начала рассмотрим оператор каретки Когда мы добавляем его к имени указателя, Git воспринимает это как команду найти родителя выбранного коммита. Так что означает “первый родитель ветки main”. означает прародитель (родитель родителя) .

Давайте переключимся на коммит выше :

Да, мы снова попали на второй коммит, то есть сейчас вновь указывает на второй коммит.

Может показаться, нужно еще раз вызвать команду , чтобы попасть на первый коммит. Но это не так, указатель остался на третьем коммите, мы сдвинули . Поэтому запросит снова родителя третьего коммита.

Чтобы попасть на первый коммит, можно использовать указатель . Попробуем перейти к первому коммиту:

Вернемся на третий коммит:

Оператор Предположим, нужно переместиться на много шагов назад. Было бы неудобно печатать несколько раз, так что Git поддерживает также оператор тильда .

Опционально к тильде можно добавить количество родительских коммитов, через которые нужно пройти. Посмотрим, как это работает.

Мы переместились на первый коммит. Вернемся:

Distributed

One of the nicest features of any Distributed SCM, Git included, is that it’s distributed. This means that instead of doing a «checkout» of the current tip of the source code, you do a «clone» of the entire repository.

Multiple Backups

This means that even if you’re using a centralized workflow, every user essentially has a full backup of the main server. Each of these copies could be pushed up to replace the main server in the event of a crash or corruption. In effect, there is no single point of failure with Git unless there is only a single copy of the repository.

Any Workflow

Because of Git’s distributed nature and superb branching system, an almost endless number of workflows can be implemented with relative ease.

Subversion-Style Workflow

A centralized workflow is very common, especially from people transitioning from a centralized system. Git will not allow you to push if someone has pushed since the last time you fetched, so a centralized model where all developers push to the same server works just fine.

Integration Manager Workflow

Another common Git workflow involves an integration manager — a single person who commits to the ‘blessed’ repository. A number of developers then clone from that repository, push to their own independent repositories, and ask the integrator to pull in their changes. This is the type of development model often seen with open source or GitHub repositories.

Dictator and Lieutenants Workflow

For more massive projects, a development workflow like that of the Linux kernel is often effective.
In this model, some people (‘lieutenants’) are in charge of a specific subsystem of the project and they merge in all changes related to that subsystem. Another integrator (the ‘dictator’) can pull changes from only his/her lieutenants and then push to the ‘blessed’ repository that everyone then clones from again.

GitHub

GitHub — это платформа, которая хранит Git-репозитории на своих множественных серверах. Как пользователь GitHub вы можете хранить свои удалённые репозитории на их серверах, а также вносить вклад в другие open-source репозитории. GitHub дополняет использование Git некоторыми новыми возможностями.

Например, вы можете сделать форк удалённого репозитория, то есть создать свою копию репозитория на севере GitHub. Это полезно в тех случаях, когда у вас нет прав на создание ветки в оригинальном репозитории. Когда вы воспользуетесь командой , ваш локальный репозиторий будет отслеживать удалённый форк как origin, а оригинальный репозиторий как upstream.

После этого вам может понадобиться слить тематическую ветку вашего удалённого репозитория в основную ветку оригинального. Для этого вы можете создать новый Pull Request — запрос на внесение изменений, где GitHub проверяет наличие конфликтов прежде чем повзолить вам провести слияние. Зачастую существуют и другие проверки перед слиянием, например просмотр и одобрение кода или даже запуск тестов. В запросе можно обсудить код, а все коммиты, которые вы отправляете в удалённую тематическую ветку, будут автоматически добавлены в запрос, даже если он был создан до этих коммитов.