Основы Git

Моя цель - предложение широкого ассортимента товаров и услуг на постоянно высоком качестве обслуживания по самым выгодным ценам.

Изучаем Git по командам

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

Когда я учил Git мне говорили, что в работе мне понадобятся всего 3 команды:

  • add

  • commit

  • push

Правда, по сути мне немного слукавили, нужен был ещё как минимум:

  • pull

  • clone

  • status

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

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

Основная терминология

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

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

  • коммит - специальное название сохранения версии. Таким образом мы называем все изменения в файлах одним именем и сможем перемещаться между коммитами

  • откат - переход на предыдущий коммит и отмена изменений с текущего коммита до того, на который мы хотим вернуться

  • пуш - отправка изменений на удаленный репозиторий (в Github, Gitlab, BitBucket)

  • фетч - скачивание изменений из репозитория

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

  • мердж - слитие веток в одну

Работа с Git

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

init

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

git init

clone

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

git clone ссылка-на-репозиторий

add

Данная команда понадобится вам, когда вам нужно добавить файл для кэширования. Давайте разберёмся как это работает:

  1. Вы изменяете файлы, можете изменять достаточно много файлов, задачи изменения которых вообще никак не связаны

  2. Вы решаете "закоммитить" ваши файлы (сделать сохранение версии, для того чтобы Git запомнил все ваши изменения в файлах и как-то назвал их, для этого есть отдельная команда git commit)

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

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

git add . # Занесение всех файлов для отслеживания
git commit -m "init" # Создание версии

Проделав данный алгоритм, состоящий из двух команд вы занесёте все файлы из вашего проекта в систему контроля версий Git.

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

git add ./file # Добавление файла для отслеживания
git add ./dir # Добавление всех файлов из директории и дочерних директорий для отслеживания

Так, хорошо, но что если нам нужно занести весь проект в систему отслеживания, однако есть пару директорий, которые мы не хотим заносить (например, node_modules или out)? Для этого мы можем создать файл .gitignore, в котором будут прописаны пути до файлов и директорий, которые Git должен игнорировать:

node_modules
out
one_file.tsx

В данном случае Git будет игнорировать директорию node_modules, out и файл one_file.tsx

Также мы можем сделать так, чтобы Git искал некоторые названия в дочерних директориях и игнорировал их:

./*/**/node_modules

Данный пример говорит о том, что Git будет игнорировать директорию node_modules, которая будет находится в любой дочерней директории (включая корневую).

Больше о .gitignore можно прочитать здесь

А что если я хочу обновить уже закэшированные файлы, мне что теперь их писать по одному? Конечно же нет. Для этого существует специальный флаг -u (сокращение от --update), который позволяет закэшировать только те файлы, которые уже отслеживаются:

git add -u

rm

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

git rm file.txt

Данный пример удалит файл file.txt из кэша и файловой системы.

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

git rm --cached file.txt

Данная команда удалит файл из "кэша", но что это значит? Допустим, что мы "закоммитили" (сохранили версию, об этом поговорим вот уже совсем скоро) наш файл, а теперь хотим, чтобы Git считал что мы его удалили, а сами просто оставили его на диске. Для этого и нужна команда выше. Она просто говорит Git: "Слушай, а давай ты просто удалишь этот файл из кэша и не будешь его показывать в репозитории, а я оставлю копию у себя на ПК, ок?"

Таким образом мы можем работать с данным файлом и Git не будет знать что именно в нём мы изменяем, а затем просто можем опять добавить его. Файл будет висеть в состоянии "untracked" (не отслеживается) до тех пор, покуда мы его опять не добавим.

commit

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

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

git commit -am "Что было сделано"

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

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

git commit --amend -am "Название коммита"

show

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

git show

Выведутся изменения следующим образом:

commit 090b467c8b1d1b66c7bd3e732ee581d18eeab597
Author: Daniil Shilo 
Date:   Thu Oct 14 03:43:58 2021 +0300

    Lorem

diff --git a/1 b/1
new file mode 100644
index 0000000..cee7a92
--- /dev/null
+++ b/1
@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
diff --git a/git b/git
new file mode 100644
index 0000000..e69de29

status

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

git status

Если вы хотите узнать более подробно о том, что же именно случилось с вашими файлами, то можете добавить ключ -v (сокращение от --verbose - внимательно):

git status -v

Если же вам наоборот хочется увидеть бриф по информации, то добавьте флаг -s (сокращение от --short):

git status -s

log

До этого момента мы могли только посмотреть что творилось в предыдущем коммите, однако с помощью git log мы можем посмотреть историю наших коммитов:

git log

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

git log --graph --pretty=oneline --abbrev-commit

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

diff

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

git diff ID-коммита-1 ID-коммита-2

Так называемые "ID-коммита" можно взять и вышеприведенной git log

Также, можно посмотреть что было изменено с момента последнего коммита (что изменено и попало в кэш) с помощью флага --cached:

git diff --cached

Если вы хотите посмотреть историю изменений в файлах в определенном коммите, то используйте следующую команду:

git diff ID-коммита

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

git diff --stat ID-коммита

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

git diff --staged

branch

В Git есть ветки для разделения версий. Если коммит нужен для того, чтобы сделать snapshot (слепок изменений) файлов, то ветки нужны для того, чтобы эти snapshot'ы разделять. У вас может быть ветка

  • master

  • build

  • beta

  • alpha

  • любое другое название

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

git branch

Для того чтобы создать новую ветку нужно ввести:

git branch имя-ветки

checkout

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

git checkout имя-ветки

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

git checkout -b имя-ветки

merge

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

git merge название-ветки-с-которой-будем-мерджить

push

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

В завершение

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

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

Надеюсь данная статья помогла вам чуть лучше узнать Git. Хорошего дня и продуктивной недели!

Только зарегистрированные пользователи могут участвовать в опросе. Войдите, пожалуйста.
Нужно ли делать развернутую статью о продвинутом использовании Git?
73.33% Да 11
26.67% Нет 4
Проголосовали 15 пользователей. Воздержались 3 пользователя.
Источник: https://habr.com/ru/post/583478/

Интересные статьи

Интересные статьи

В настоящий момент появилось достаточно большое количество библиотек дополненной реальности с богатым функционалом (ARCore, ARKit, Vuforia). Тем не менее я решил начать свой открытый пр...
В этой серии статей я расскажу почти всё, что нужно знать о генераторах в JavaScript: что это такое, как их использовать и какие тонкости с ними связаны. И, как всегда, начнём мы с осно...
Я делаю много ревью для чужого кода на Ансибл и много пишу сам. В ходе анализа ошибок (как чужих, так и своих), а так же некоторого количества собеседований, я понял основную ошибку, ...
Мы воспринимаем центральный процессор как «мозг» компьютера, но что это значит на самом деле? Что именно происходит внутри миллиардов транзисторов, благодаря которым работает компьютер? В нашей...
Эта статья посвящена одному из способов сделать в 1с-Битрикс форму в всплывающем окне. Достоинства метода: - можно использовать любые формы 1с-Битрикс, которые выводятся компонентом. Например, добавле...