Рубрики
Uncategorized

Профессиональный контроль версий с GIT: PT 1 — Основы

Добро пожаловать в первую часть первой статьи Erik’s Code Space серии 2021 года! В этой серии мы собираемся узнать все о контроле версий, используя […]. Tagged with git, svc, cicd.

Часть 2 — Сотрудничество, часть 3 — Rebase and Bisect

Добро пожаловать в первую часть первой статьи Erik’s Code Space серии 2021 года! В этой серии мы собираемся узнать все о контроле версий, используя GIT и GitHub. В этой первой части серии мы собираемся немного поговорить об идее контроля версий, а затем перейти прямо на практическое использование. Это та вещь, которая поможет вам сразу, и Это такой навык, который работодатели ожидать, что вы будете иметь. Без лишних слов давайте прыгнем прямо в это.

Что такое контроль версий?

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

  • Ведение записи об изменениях и решениях, принятых в ваш код
  • Предоставление сети безопасности для экспериментов
  • Разрешение сотрудничества по проектам по всему миру

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

Управление версией Softwares

Есть много разных продуктов, которые вы можете использовать. GIT, безусловно, является самым популярным инструментом для управления версиями, и это инструмент, который мы будем использовать для этой серии, потому что он бесплатный, и потому что это наиболее вероятная вещь, которую вы используете на работе. Существуют другие продукты управления версиями, которые получают много использования в профессиональном мире, таких как Subversion и Mercurial. Я не уверен, есть ли у этих инструментов нишевые отрасли или области, но вы не ошибетесь, зная git.

Наряду с git, есть два майор Git servers-as-a-service: GitHub и Gitlab Анкет Оба имеют много услуг для сотрудничества, непрерывной интеграции (CI), непрерывного развертывания (CD), обмена версиями, обмена, отслеживания проблем и многого другого. Для наших целей мы собираемся придерживаться GitHub, так как этот сервис, который автор знает лучше всего. Однако мы будем не Используйте GitHub в первой части этой серии, так что пока не беспокойтесь об этом. Но, если вы хотите сэкономить время, идите вперед и сделайте себе учетную запись GitHub, чтобы вы были готовы к части 2.

Установка git

Хорошо, мы готовы начать работу. Сначала мы должны установить GIT на наших компьютерах. Вполне возможно, что у вас уже есть GIT на вашем компьютере, так что давайте проверем и посмотрим, очень ли это так быстро. Откройте командную строку по выбору и запустите следующую команду:

> git --version

Если у вас уже есть на вашем компьютере, вы получите что -то вроде

git version 2.16.2.windows.1

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

> sudo dnf install git-all

Если вы в Windows, вам придется перейти к gitforwindows и следуйте инструкциям скачать там. Не беспокойтесь о установке каких -либо программ GUI. По моему опыту, GIT гораздо более интуитивно понятен, когда вы привыкаете использовать ее из командной строки, чем любая программа GUI (но если вы должны использовать ее, я рекомендую настольный компьютер GitHub).

После того, как вы установили соответствующую версию для своей ОС, перезагрузите свой терминал и введите в git -версия Снова командуйте, чтобы убедиться, что git находится на вашем пути. Как только вы это сделаете, вы готовы начать использовать его!

GIT Основные понятия

Мы используем GIT, чтобы вести записи о том, что мы сделали в наших программных проектах, чтобы мы могли видеть все изменения, которые мы когда -либо вносили, и вести запуск журнала того, что мы делали. Начиная с того, что лучше думать о GIT как о инструменте для сохранения временной шкалы. Помните эти графики сроков в ваших учебниках по истории 6 -го класса? Они выглядели как это:

Посмотрите, как есть линия, изображающая время, и стрела и реклама о каждом важном событии, которое произошло во время этого (предположительно составленного) истории компании? GIT создает что -то подобное, но для наших программных проектов. Сплошная линия похожа на «ветвь» Гит, а сообщения вдоль линии очень похожи на «коммиты» Гита.

По сути, мы начинаем с инициализации git Репозиторий Анкет В метафоре временной шкалы компании репозиторий является фактической компанией. Это тело кода, о котором мы ведем бегущую запись.

Затем вы начинаете работать над репозиторием. Вы можете начать все, создав get get_started.py Скрипт Python. Вы начинаете с написания кода для этого файла, пока не дойдете до разумной остановки. Вы смотрите на код, который вы написали, и, если все выглядит хорошо, вы решите Компет Файл в репозиторий.

Чтобы совершить файл, вы также должны написать небольшое сообщение. Что -то вроде «написано подтверждение концепции сценария. «Как только вы сделаете коммит, это сообщение станет первым текстом на временной шкале вашего программного проекта. Эта временная шкала называется ветвь Анкет

В практически в любой момент вы находитесь в самой правой части филиала, над которой работаете. Каждый коммит, который вы делаете, добавляет другое событие к временной шкале. К счастью, мы можем породить ветви от других ветвей. Например, на вашей текущей временной шкале вы можете решить, что хотите поэкспериментировать с созданием нового файла, подобного file_two.py Но это не совсем готово быть официальной частью истории проекта. В этом случае вы создадите новую филиал из официального филиала (часто называемый что -то вроде Main, Master или Trunk). Таким образом, вы можете экспериментировать с альтернативной временной шкалой. Если вам нравится работа, которую вы проделали на новом филиале, тогда вы можете слияние эта ветвь в главную. Это сделает всю работу, которую вы проделали на альтернативной части официальной истории Main.

Это основные концепции, стоящие за тем, как работает GIT. Это намного больше, но не волнуйтесь, мы собираемся получить практический с этим инструментом И все это будет иметь гораздо больше смысла.

Инициализация вашего репозитория

Идите дальше и откройте свой терминал по выбору, будь то Bash, DOS, PowerShell или что -то еще. Найдите свой путь в папку, которую вы используете для проектов, и сделайте новый каталог под названием git_project и компакт -диск в это. Я делаю это на Powershell, так что выглядит так:

> mkdir git_project
> cd git_project

Теперь мы собираемся инициализировать наш репозиторий. Это в основном означает, что мы говорим GIT, что все в этом каталоге — это проект, который мы хотим отслеживать. Мы собираемся назвать нашу основную филиал «Main», так что команда для этого есть:

> git init -b main

Вы должны получить сообщение с надписью «Инициализированный репозиторий пустого GIT, и если вы посмотрите, здесь есть новый каталог, который называется .git . Не связывайтесь с этим, я просто хочу, чтобы вы знали, что это должно быть там. Кроме того, каталог, из которого вы запустили эту команду, теперь является проектом корень Анкет

Добавление файлов

Хорошо, теперь, когда у нас инициировано наш репозиторий, пришло время начать писать какой -то код для отслеживания GIT. Давайте создадим файл Python с именем get get_started.py . Поскольку мы находимся в командной строке, мне нравится использовать команды для этого, но вы можете сделать это от Explorer, или IDE, или чего -либо еще, что вы хотите. В любом случае, создайте файл и откройте его в своем редакторе. В Linux я использую

> touch getting_started.py

Или в PowerShell в Windows:

> echo '' > getting_started.py

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

def greet(name):
  return f'Hello, {name}!'

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

> git status
On branch main

No commits yet

Untracked files:
  (use "git add ..." to include in what will be committed)
        getting_started.py

nothing added to commit but untracked files present (use "git add" to track)

Обратите внимание, что getting_started.py указан в «Не отрываемых файлах». «Это потому, что мы еще не сказали GIT, что это файл, который мы хотим отслеживать. Чтобы сделать это, мы должны Добавить Файл в репозиторий. Команда для этого, вероятно, именно то, что вы думаете:

> git add getting_started.py

Введите вышеуказанную команду и нажмите Enter. Теперь мы официально добавили get get_started.py На репозиторий и GIT отслеживает его изменения с этого момента. Иди и беги GIT Статус снова и обратите внимание на новый вывод:

> git status
On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached ..." to unstage)
        new file:   getting_started.py

Смотрите теперь, что get get_started.py перечислен в разделе «Изменения, которые должны быть совершены. » Это довольно хороший переход в нашу следующую команду, Компет Анкет

Совершение изменений

Теперь мы решили, что достаточно довольны нашими приветствовать функция в get get_started сценарий Пришло время совершить эти изменения или сделать их официальной частью истории этого проекта. Как я уже говорил ранее, нам придется придумать короткое сообщение, чтобы описать то, что мы сделали. Все, что мы действительно сделали, это создать приветствовать Функция, так что давайте пойдем с этим. Команда совершить наши изменения с этим сообщением следующей:

> git commit -m "Create greet function"

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

> git status
On branch main
nothing to commit, working tree clean

При совершении нашей работы мы сделали этот файл и функционировали официальной частью истории проекта. Таким образом, нет «изменений» для совершения, когда мы проверяем статус репозитория. Давайте продолжим и сделаем еще несколько изменений в get get_started.py Хотя я хочу добавить новую функцию под названием double_this Анкет Функция будет выглядеть так:

def double_this(number):
  return number * 2

Обязательно сохраните изменения, а затем вернитесь к терминалу. Давайте снова запустим команду Status и посмотрим, как выглядит наш репозиторий:

> git status
On branch main
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git restore ..." to discard changes in working directory)
        modified:   getting_started.py

no changes added to commit (use "git add" and/or "git commit -a")

Заметьте на этот раз, что get get_started.py не указан в разделе «Не отрываемые файлы», а в «изменениях не установлены для коммита. «Это потому, что всякий раз, когда мы меняем файл, мы должны запустить git add снова к этапу Изменения, прежде чем мы сможем их совершить. Другими словами, как только мы будем готовы совершить наши изменения, мы должны сначала запустить Добавить командование а затем Компет командовать снова. Не запускайте следующие команды (я собираюсь показать вам лучший путь), но это то, что они будут выглядеть: 

> git add getting_started.py
> git commit -m "Added double_this function"

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

> git commit -am "Added double_this function"

С этой командой мы одновременно устроили наши изменения и совершили их. (Примечание: это не будет работать для «не отстраненных файлов», которые вы должны вручную добавить в репозиторий с помощью git add ) Лично это то, как я занимаюсь 99% случаев. Теперь »добавлено double_this Функция «официально является частью истории нашего проекта. Но что это за история, о которой я продолжаю говорить? Ну, это действительно больше журнала, давайте поговорим об этом:

Увидеть историю вашего проекта

Помните, как я сказал, что репозиторий GIT похож на график для вашего проекта? Ну, мы можем просмотреть эту график с git log , который может показать нам всю нашу историю, посмотрите:

> git log
commit bfae576bca086e682eae6ca0a7b12d23621234a8 (HEAD -> main)
Author: erik-whiting 
Date:   Thu Mar 25 20:01:47 2021 -0500

    Added double_this function

commit 47308246e7a8dbfe6fd3b4361f28c4a1e6643f79
Author: erik-whiting 
Date:   Thu Mar 25 19:50:01 2021 -0500

    Create greet function

Есть несколько вещей, которые могут выглядеть немного чуждо в этом журнале, поэтому давайте пройдемся через каждый. Во -первых, мы видим » Commit » с хэшем. Это неудивительно, что хэш коммита. Он уникален для всего вашего проекта, и есть команды, которые мы узнаем позже, в которых вы будете использовать этот хэш. Что ж, вы на самом деле используете только первые несколько символов хэша, так как git обычно достаточно умный, чтобы выяснить остальные.

Далее вы видите «Автор». Это ваше имя пользователя GIT, и вы можете увидеть его, запустив git config user.name или установите, запустив git config-global user.name "новое имя" Если вам нужно. То же самое касается следующего адреса электронной почты.

Поле «даты» достаточно очевидно, но обратите внимание, что следующая строка — это сообщение о коммите, которое мы написали ранее. Это то, что я имею в виду, когда говорю, что git сохраняет историю вашего проекта. Журнал GIT важен по нескольким причинам, и крайне важно, чтобы вы написали хорошие сообщения о коммите. Много раз, журнал GIT используется другими участниками в вашей команде, чтобы увидеть, что была сделана совсем недавно. В других случаях люди, прокручивающие ваш проект, могут прочитать его, чтобы почувствовать, о чем занимается ваш проект и как вы работаете.

Самое главное, что для вас это способ оглянуться на свой проект и посмотреть, какие изменения вы внесли в любой момент. Однажды вы можете смотреть на странный кусок кода и подумать: «Почему в мире я это сделал?» Используя GIT, вы можете вернуться назад и посмотреть, когда вы написали этот код, какой код был там раньше, и ваше собственное сообщение о коммите. Это очень полезный инструмент, и вы никогда не знаете, когда он может пригодиться.

Отменить изменения

Давайте поговорим о другой вещи, которую GIT помогает нам: экспериментирование. Иногда у вас есть большая идея, и вы хотите посмотреть, сможете ли вы заставить его работать в своем проекте. Вы не хотите испортить проект, поэтому вы убедитесь, что вы начинаете с чистого коммита (то есть без выдающихся изменений, поэтапных или иных). В какой -то момент вы решаете, что изменения, которые вы хотели внести, либо слишком сложны, либо не будут работать. С GIT вы можете взорвать все, независимо от того, что вы изменили, и вернуться к тому, как все было до того, как вы начали. Давайте посмотрим на эту идею в действии.

Откройте get get_started.py Скрипт снова и давайте связывается с double_this функционируйте, заставив его использовать поплавок вместо целого числа:

def double_this(number):
  return number * 2.0

Сохраните свои изменения и вернитесь к терминалу, запустите GIT Статус чтобы убедиться get get_started.py перечислены как «изменения, не поставленные для коммита»

Скажите, что теперь, когда мы думали об этом, нам нравится удваиваться с целым числом вместо поплавка. Мы мог Вернитесь назад и просто нажмите Ctrl+Z, пока все не вернется к тому, как они были, но по мере того, как изменения начинают становиться все больше, такие подходы не работают. К счастью, в GIT есть команда одной строки, чтобы отменить все неоставленные изменения, запустите следующую команду:

> git checkout getting_started.py

Теперь вернись к get get_started.py в вашем редакторе кода. Заметьте что -нибудь? double_this Функция должна была вернуться в свое исходное состояние. Разве это не удобно? Даже если у вас есть несколько изменений, охватывающих несколько файлов, если эти файлы отслеживаются, Оформление Команда вернет их в их последний коммит.

Кстати, вы можете применить команды GIT, такие как Добавить и Оформление Для нескольких файлов вместо запуска одной команды на файл. Большую часть времени, Я просто бегаю

> git add .

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

> git checkout file1.txt file2.py file3.sql

Наконец, вы также можете использовать команды, подобные Regex. Например, скажем, вы хотите поставить изменения в любые файлы Ruby, вы бы написали:

> git add *.rb

Вернувшиеся изменения

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

Возвращение наших изменений означает уничтожение всего коммита. Допустим, теперь мы не хотим double_this Функция в нашем скрипте вообще Анкет Конечно, мы могли бы удалить его вручную и сделать новый коммит с сообщением «Удаленный double_this». Но если бы мы хотели хирургически удалить всю работу, которую мы проделали, мы могли бы использовать команду Revert. Первое, что вам нужно сделать, это найти хэш коммита, который вы хотите отменить, помните, что мы получаем это от log командование Проверьте это:

> git log
commit bfae576bca086e682eae6ca0a7b12d23621234a8 (HEAD -> main)
Author: erik-whiting 
Date:   Thu Mar 25 20:01:47 2021 -0500

    Added double_this function

commit 47308246e7a8dbfe6fd3b4361f28c4a1e6643f79
Author: erik-whiting 
Date:   Thu Mar 25 19:50:01 2021 -0500

    Create greet function

Мы хотим вернуть коммит с сообщением »« Добавлена функция double_this. » Найдите хэш коммита, для меня это «BFAE576BCA086E682EAE6CA0A7B12D23621234A8», но это будет отличаться для вас. Чтобы вернуть, запустите следующую команду, но замените мой хэш на свой (примечание, вы можете использовать только первые 5 или 6 символов вашего хэша коммита):

> git revert --no-edit bfae576bca086e682eae6ca0a7b12d23621234a8

И нажмите Enter. Вернитесь к своему редактору кода и примечайте это double_this теперь ушел. Вернитесь к терминалу и запустите git log Чтобы увидеть, как выглядит история:

> git log
commit 275c72742cf806d2517661d5ae8f2d9e516efed2
Author: erik-whiting 
Date:   Thu Mar 25 20:51:56 2021 -0500

    Revert "Added double_this function"

    This reverts commit bfae576bca086e682eae6ca0a7b12d23621234a8.

commit bfae576bca086e682eae6ca0a7b12d23621234a8
Author: erik-whiting 
Date:   Thu Mar 25 20:01:47 2021 -0500

    Added double_this function

commit 47308246e7a8dbfe6fd3b4361f28c4a1e6643f79
Author: erik-whiting 
Date:   Thu Mar 25 19:50:01 2021 -0500

    Create greet function

Обратите внимание, что мы все еще сохраняем историю. У нас есть «добавленная функция double_this» в журнале GIT, но у нас также есть «вернуть» добавленную функцию double_this ». «Revert…» Сообщение о коммите на самом деле является сообщением по умолчанию при выполнении команды revert , что мы получаем, когда мы передаем флаг -no-edit . Если вы хотите написать свое собственное сообщение, оставьте этот флаг. GIT спросит вас, какую программу вы хотите использовать, чтобы написать сообщение о коммите (я обычно использую блокнот ++ на Windows и Nano на Linux). Как только вы закончите редактировать файл, закройте программу, и будет сделан коммит.

Это основы!

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

GIT филиалы

Одна из лучших вещей в GIT — это разветвляется. Это позволяет нам, по сути, жить несколькими историями за один раз, не нарушая Верно История, пока мы не будем готовы. Мы можем экспериментировать, проверить новые функции без изменения производственной системы и сотрудничать с другими разработчиками.

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

Вместо того, чтобы нарушать операции, когда выкапывали и сталкивались с общественным веб -сайтом компании, я делаю новый филиал с Главный ветвь, чтобы я мог исследовать источник ошибки и исправить это. Когда я делаю новую филиал из основного, я, по сути, копирую его: все, от кода до истории коммита. Но когда я внося изменения в новую ветвь, основной остается таким, каким он есть. Я даже могу вернуться к нему, если новая, более важная вещь нуждается в решении, а затем переключиться на мою другую работу, когда это будет сделано.

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

Создание нового филиала

В нашем git_project Репозиторий, мы решаем снова сделать новую функцию, но мы не хотим, чтобы он был в основной ветви, пока мы не закончим. Во -первых, мы делаем создание новой ветви с ветвь командование Тогда мы Оформление Эта ветвь так, чтобы работа, которую мы выполняем, отслеживалась в истории новой филиала, а не в главной.

Во -первых, перейдите к своему терминалу и посмотрите, в какой филиале мы находимся, набрав Git Branch Анкет Вывод должен иметь работу «основной» в зеленом со звездочкой рядом с ним. Звездочка указывает, в какой ветви вы находитесь (в «ветви» означает, что изменения, которые вы вносят, отслеживаются и записываются в истории этой ветви). Давайте сделаем новую ветку с ветвь Команда:

> git branch add-new-method

Эта команда создает ветвь, теперь нам нужно Оформление филиал. Как только мы запустим следующую команду, мы будем на Add-New-Method ответвляться:

> git checkout add-new-method

И терминал должен вывести » Переключится на ветвь 'Add-New-Method' «. В будущем, если вы хотите создать ветвь и проверить ее в одной команде, вы используете Оформление командование с -b аргумент как так:

> git checkout -b add-new-method

Хорошо, теперь, когда мы находимся на Add-New-Method Бранч, я хочу, чтобы ты что -то увидел. В терминале запустите git log и увидеть вывод. Это должно быть точно так же, как и в прошлый раз, когда вы смотрели на это на Главный ответвляться. На самом деле, пока мы не сделаем что -либо в любой филиале, их журнал будет таким же.

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

def triple_this(number):
  return 3 * number

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

> git commit -am "Add triple this function"

Теперь мы посвятили эту работу Эта ветвь история Проверьте выход из git log :

commit 65ed67a53aeb94b27865e401cc456e6b2b33bf2a (HEAD -> add-new-method)
Author: erik-whiting 
Date:   Thu Mar 25 22:55:58 2021 -0500

    Add triple_this function

commit 0ea7a943b604f5efebaecb7e2ede33cf00cf7de2 (main)
Author: erik-whiting 
Date:   Thu Mar 25 20:54:16 2021 -0500

    Revert "Added double this"

    This reverts commit ae2a9fe016ab88a07dc6b06b9ca4417dd3f0933e.

commit ae2a9fe016ab88a07dc6b06b9ca4417dd3f0933e
Author: erik-whiting 
Date:   Thu Mar 25 20:53:37 2021 -0500

    Added double this

...
(truncated)

Коммит о добавлении triple_this Функция в истории этой отрасли. Давайте вернемся к Главный Бранч, это заставит все это иметь больше смысла. В типе терминала:

> git checkout main

Прежде всего, посмотрите на get get_started.py Скрипт и заметьте, что triple_this Функции нет. Это потому, что эта работа была на Add-New-Method ветвь, а не главная. Кроме того, запустите git log снова и заметьте, что коммит для triple_this там нет.

Еще одна ветвь

Чтобы проиллюстрировать еще один момент, который я хочу сделать позже, давайте сделаем еще одну ветвь. На этот раз мы отредактируем Приветствую метод Итак, в терминале убедитесь, что вы находитесь на Главный ветвь путем набора Git Branch и обеспечение Главный снимается в главной роли. Теперь введите следующую команду:

> git checkout -b edit-greet-method

Мы сейчас в РЕДАКТИРОВАТЬ-ГРИТ-МЕТОД ветвь, так что отправляйтесь в get get_started.py Скрипт и установите Приветствую метод, чтобы выглядеть так:

def greet(name):
  return f'What\'s up, {name}?'

Теперь давайте продолжим и сделаем это изменение:

> git commit -am "Edit greet function"

Еще раз, проверьте журнал и обратите внимание, что единственное сообщение о коммите после нашего возврата «добавленного двойного этого», который мы только что сделали: «Редактировать функцию приветствия. «Переключитесь обратно в ветвь В терминале и еще раз отметьте, что самое последнее сообщение в журнале — это то, что касается возврата double_this метод Также обратите внимание, что в get get_started.py Скрипт, метод — это то, как мы его оставили, с приветствием «привет» вместо «Что случилось».

Объединение ветвей

Хорошо, теперь, когда мы внесли изменения в две разные ветви И мы думаем, что довольны ими, пришло время объединить эти изменения в нашем Главный ветвь и объединение историй. Во -первых, убедитесь, что вы на Главный ответвляться. Во -первых, мы собираемся объединиться в РЕДАКТИРОВАТЬ-ГРИТ-МЕТОД Анкет В типе терминала:

> git merge edit-greet-method

Вы получите некоторые выводы о Fast-Breadling и сколько файлов было изменено. Посмотрите на сценарий и обратите внимание, что Приветствую Функция теперь использует приветствие «Что случилось» вместо «Привет». В терминале проверьте журнал:

> git log
commit ad0ca3092e6e49a86d8f228d2b9e7f39b8a559ca (HEAD -> main, edit-greet-method)
Author: erik-whiting 
Date:   Thu Mar 25 23:08:03 2021 -0500

    Edit greet function

commit 0ea7a943b604f5efebaecb7e2ede33cf00cf7de2
Author: erik-whiting 
Date:   Thu Mar 25 20:54:16 2021 -0500

    Revert "Added double this"

    This reverts commit ae2a9fe016ab88a07dc6b06b9ca4417dd3f0933e.

commit ae2a9fe016ab88a07dc6b06b9ca4417dd3f0933e
Author: erik-whiting 
Date:   Thu Mar 25 20:53:37 2021 -0500

    Added double this
...
(truncated)

Теперь мы видим, что история коммита (эквивалентная примечанию из нашего примера сроки ранее) из РЕДАКТИРОВАТЬ-ГРИТ-МЕТОД Филиал теперь объединен — или объединен –В с историей коммита Главный Анкет По сути, мы сделали работу, которую мы проделали над РЕДАКТИРОВАТЬ-ГРИТ-МЕТОД Филиал Части официальной истории.

Давайте сделаем то же самое для Add-New-Method ответвляться. Мы создали эту ветвь до того, как создали РЕДАКТИРОВАТЬ-ГРИТ-МЕТОД ветвь, как вы думаете, это вызовет проблемы? Давай выясним. Запустите следующее в терминале:

> git merge add-new-method

Вы, вероятно, получите вывод, аналогичный следующему:

warning: Cannot merge binary files: getting_started.py (HEAD vs. add-new-method)
Auto-merging getting_started.py
CONFLICT (content): Merge conflict in getting_started.py
Automatic merge failed; fix conflicts and then commit the result.

О, что случилось? Есть конфликты слияния. Это потому, что когда мы создали Add-New-Method ветвь, get get_started.py История GIT File была одним из способов, но когда мы объединились РЕДАКТИРОВАТЬ-ГРИТ-МЕТОД в Главный Филиал, эта история была обновлена. Это означает, что Add-New-Method теперь не синхронизируется с Главный ветвь, вызывая объединить конфликт . Есть простой способ исправить это, не волнуйтесь.

То, что вам придется сделать, это войти в свою IDE, или в чем -то, с чем вы писали свой код, и найти, где находятся конфликты. Если вы используете IDE, такой как VSCODE, Pycharm или что -то в этом роде, изменения будут отмечены очень очевидно. В противном случае вам придется что -то следить за это говорит

<<<<<<< HEAD
  return f'What\s up, {name}'
=======
  return 'Hello, {name}'

def triple_this(number):
  return 3 * number
>>>>>>> add-new-method

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

В нашем случае мы хотим не только удалить все <<<< Тип вещей, которые нам не нужны, но также мы хотим удалить старый метод возврата из приветствовать функция Другими словами, ваш последний сценарий должен выглядеть как:

def greet(name):
  return f'What\s up, {name}!'

def triple_this(number):
  return 3 * number

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

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

Вывод

На этом завершается первая часть нашей профессиональной серии GIT. Во второй части мы собираемся узнать о публикации, клонировании и предъявлении запросов на притяжение на GitHub. Часть 3 будет охватывать некоторые более продвинутые темы, такие как Rebase и Bisect. Это действительно хорошая информация, которая очень важна для выравнивания ваших навыков кодирования, так что следите за обновлениями!

Оригинал: «https://dev.to/erikwhiting88/professional-version-control-with-git-pt-1-the-basics-3ahm»

Читайте ещё по теме: