Git — Git добавление файлов


Содержание

Работаем с Git, основные команды для начинающих

Кто вносил изменения в код можно определить по имени пользователя git. Для этого сообщим git свое имя и email-адрес. Для этого введите:

Превратим наш проект в репозиторий git. Для начала просто создайте папку git_site , затем введите следующие команды:

Где mkdir — команда для создания новых каталогов;
cd — переход в указанную папку; команда cd используется для смены текущего каталога.
cd .. на уровень выше
cd \ в корень текущего диска
d: перейти на диск D
cd c:\windows перейти в каталог windows

После инициализации каталога будет выведено соответствующее сообщение:

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

$ git add

Далее в наш каталог ( git_site ) можно поместить файлы сайта. Скопируем файлы сайта в папку git_site . Далее, давайте добавим файлы в репозиторий.

Для этого понадобится выполнить команду:

$ git status

Команда $ git status позволяет отследить состояние репозитория. Эта команда позволяет узнать, какие изменения необходимо зарегистрировать git (при необходимости, отменить).

$ git commit –a , $ git commit –am «. «, $ git commit –a –m «. «

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

–a означает: добавить все изменения в индекс до передачи.
-m : сообщение.

Подтверждение с описанием выполненных действий.

Мы сделали «снимок кода». Теперь мы можем редактировать файлы и регистрировать наши изменения.

$ git stash

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

$ git stash list

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

На изображении у нас одно незарегистрированное изменение. В самом файле эти изменения не будут отображены.

$ git stash pop

Восстановить же изменения поможет следующая команда:

$ git merge

Чтобы объединить ветки, например, ветку hotfix с веткой master , необходимо выполнить следующие команды:

Давайте удалим ветку hotfix . Для этого воспользуемся следующей командой:

Ветвление

Ветка позволяет отделить работу, например, над каким-то компонентом от основного кода сайта.

$ git checkout –b

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

Этим мы к тому же переключились на новую ветку hotfix . Теперь все внесенные в файлы изменения будут относиться к ветке hotfix .

Теперь давайте внесем изменения в файл index.html . Например, давайте подключим стилевой файл. И в самом стилевом файле увеличим размер шрифта у параграфа. Сделаем git status и зарегистрируем изменения:

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

git init (инициализируем git реп-й)

Чтобы проинициализировать Git репозиторий введите команду:

Будет создана папка /.git/ . Репозиторий — это скрытая папка, в которой работает Git.

git status (Проверяем статус)

Комнада, выводяюща статус репозитория, чтобы увидеть в каком состоянии находится наш проект:

git add (добавляем файл)

Чтобы сообщить Git о том, что пора начать отслеживать изменения, внесенные в файл, мы сначала должны добавить его с помощью:

Сейчас git отслеживает наш файл test.txt. Давайте выполним

снова, чтобы понять, что изменилось!

git commit (фиксируем изменения)

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

git commit -m «Add cute octocat story»

Если вы опустите метку -m из командной строки, git перенесет вас в редактор по вашему выбору. В первой строке введите комментарий: «Added h1 tag». Сохраните файл и выйдите из редактора (для этого в редакторе по-умолчанию (Vim) вам нужно нажать клавишу ESC , ввести :wq и нажать Enter ). Вы увидите . (http://githowto.com/ru/commiting_changes)

Используем маску

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

git commit –a –m ”new comment here”

Коммитится только то, что проиндексировано. Индексирование происходит функцией add (она и добавляет файлы и индексирует их).

Коммит идет не сразу: файлы, которые находятся под присмотром ГИТ необходимо проиндексировать (то есть если нам нужно сделать коммит для 1-файла, то мы помещаем его в индекс и закоммитится только он). С помощью ключа –a мы индексируем ВСЕ файлы и, соответственно, сразу выполняем коммит (например,

—amend

git commit —amend

Эта команда берет область индексирования (add) и включает в коммит всю обнаруженную там информаци. Например,

Второй коммит заменит результат первого и в итоге останется 1 коммит

Работаем с GitHub

Зарегистрируйтесь на GitHub. Создайте репозиторий.

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

Эта команда принимает имя удаленного репозитория и его URL. В нашем случае это https://github.com/try-git/try_git.git

Выполняем команду с указанными аргументами:

git remote add origin https://github.com/try-git/try_git.git

Где origin — имя удаленного репозитория.

Плюсы и минусы bitbucket.org и GitHub

На bitbucket.org можно создавать неограниченное количество приватных репозиториев (плата взимается, если к репо привязываются более 5 пользователей). На GitHub большинство проектов open source, также для приватного репо уже приходится платить – даже для 1-го пользователя. Для своих проектов я рекомендую все же использовать bitbucket.org.

Процесс разработки:

Переходим на боевой сервере по SSH и стягиваем (PULL) с GitHub, при этом разработка идет на ПК разработчика (может быть более 1-го разработчика, с локального ПК делаем PUSH на GitHub).

Эта команда показывает имя удаленного репо, если такой имеется в наличии.

Ключ –v показывает путь к удаленному репо.

Подробно о любой команде можно узнать:

Коммитим и пушим на GitHub (global настройки matching и simple)

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

То по команде git push произойдет следующее: если на боевом репо есть 2 ветки, которые соответствуют 2-м локальным веткам, то на удаленный репо протолкнутся эти 2 ветки.

В данном случае протолкнется лишь текущая ветка.

git remote (прсматриваем уд. реп.)

Команда git remote позволяет просмотреть удаленные репозитории

git remote -v параметр -v позволяет увидеть URL-адреса.

git remote add (добавляем уд. реп.)

Добавление удаленных репозиториев под короким именем:

git remote add [сокращенное имя] [url]

git remote add kuku [url] — теперь вместо полного URL-адреса в командную строку можно вводить имя kuku

В уже сущест. реп. добавляем реп. сторонний и стягиваем из него ветку master

Иниц. пустой реп.
Добавляем реп.
извлекаем все данные (.git)
и стягиваем ветку master из реп. kuku

git remote show (получаем инфо. об уд. реп.)

Команда git remote show [имя удал. реп.] позволяет просмотреть дополнительную информацию о конкретном удал. реп.

git fetch (извлечение данных из уд. реп.)

Извлечение данных из уд. реп. выполняется командой:

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

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

git push (проталкиваем изменения)

Команда git push говорит Git, куда отправить наши изменения, когда все готово. Итак, запушим наши локальные изменения в наш удаленный репозиторий на GitHub. Имя удаленного репозитория origin , а ветка по умолчанию называется master (не думайте пока что о ветках). Параметр -u позволит нам в будущем не указывать дополнительные параметры, а просто выполнять git push . Git будет знать, что нужно делать.

git push -u origin master

где origin – это куда отправляем (удаленный репозитарий), а
master это то, что отправляем (в нашем случае master ).

git pull (стягиваем изменения)

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

git pull origin master

Забираем изменения из ветки ( master ) на удаленном сервере ( origin ) и проводим слияние с активной веткой.

git diff, git diff HEAD

Команда git diff показывает не все изменения, сделанные с момента последней фиксации состояния, а только те, которые еще не проиндексированы.

Команда git dif —cached покажет проиндексированные изменения

Ой! Похоже, кто-то еще вносил изменения в наш проект! Давайте посмотрим, что изменилось, с нашего последнего коммита, с помощью команды

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

Еще один полезный вариант использования git diff — просмотр изменения, которые уже были помещены в промежуточную область. Запомните! В этой области находятся файлы, которые git готов(!) закоммитить.

git reset (Откатываем изменения/удаляем файлы из промежуточной области)

Вы можете удалять файлы из промежуточной области с помощью git reset .

git reset octofamily/octodog.txt

git log (информация о последних коммитах)

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

покажет список последних коммитов и их хеши SHA1.

На самом верху мы видим самый последний коммит. Функция log очень богатая – позволяет смотреть, что было до и что было после, у git хорошая помощь (faq), чтобы просмотреть все возможности log можно воспользоваться командой:

Например, мы можем выводить историю в более удобном формате:

%h – короткий код самого коммита;
%an – автор;
%ar – когда был сделан;
%s — комментарий.

Ограничиваем коммиты по времени:

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

—stat используется для получения краткой статистики по каждому коммиту.

—graph добавляет графику с историей ветвлений и слияний

git checkout (Отмена изменений)

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

git checkout — octocat.txt

git checkout 82f5

Для указания коммита достаточно первых нескольких символов его хеша ( 82f5 ), но можете скопировать и весь хеш.

git checkout (получаем уд. ветку)

Для получения собственной копии [имя_ветки] (из уд. реп.) можно воспользоваться командой :

(?) или просто git checkout [имя_ветки] ; но тут главное, чтобы [имя_ветки] присутствовала в уд. реп.

git branch (создаем ветку)

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

Давайте создадим новую ветку и назовем ее clean_up :

git branch clean_up

git branch -d (удаление ветки)

Вы можете использовать команда git branch -d
для удаления ветки. Сделаем это:


git branch -d clean_up

git branch -vv (наблюдаем за уд. ветками)

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

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

git rm (удаляем файлы)

Команды git rm , которая не только удалит файлы с диска, но и добавит сведения об их удалении в Git.

Если вы проиндексировали файл, то следует воспользоваться параметром -f , который инициирует принудительное удаление

merge (смержим в текущую ветку другую)

Настал момент, когда вы должны смержить изменения из ветки clean_up в ветку master .

Мы уже находимся в ветке master (вы уже знаете, как в этом убедиться). Осталось только сказать Git, что мы хотим смержить в текущую ветку другую — clean_up :

git merge clean_up

git clone

По url создаем локальный репозиторий, склонировав удаленный, например, с gitHub. Предварительно необходимо выполнить команду git init .

$ mkdir epicgame & cd epicgame
$ git init
$ git remote add
$ git clone

rejected

Если при push появляется rejected , то это говорит о том, что необходимо скачать изменения с удаленного сервере и уже затем push -ть.

Конфликты

Сообщение о конфликте:

В статусе ( git st ) появляется блок:

То есть у нас появились файлы, которые автоматически не с merg -сь.

То есть в самом файле:

Это указатель на тот commit, с которым мы сейчас работаем. Нужно выбрать или оставить свои изменения ( // Fry comment ) или оставить строку пользователя Bender ( // Bender comment ).

Разные полезные команды:

Добавляем пользователя:

(config – работаем с конфигом; —global – ключ для глобального конфига; user.name — имя).

(задаем email глобально)

(данные о гите и о пользователе; хранятся в c:\users\name_user\.gitconfig )

Игнорирование файлов:

На одном уровне с папкой .git создаем текстовый документ: .gitignore (убираем разрешение .txt, то есть сохраняем с All types(.) в Notepad++).

В самом файле указываем игнорирование, например:

$ git rm

Файл name_file.txt станет обратно ( untracked ; от track — следить), то есть вернется в состояние перед командой git add .

СВОЙ РЕДАКТОР ДЛЯ КОММЕНТАРИЕВ

Без ключа –m откроется редактор vim ( :x – означает сохранить и выйти).

Поменяем редактрор по умолчанию (vim), он будет открываться в том случае, если мы не прописываем комментарий в командной строке.

Изменения можно проверить в C:\Users\name_user\.gitconfig

ВЕТКИ ($ git checkout –b new_branch)

Создаем ветку new_f и тут же переходим в нее.

С использованием –v показывает ветки с последними коммитами.

merge

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

Указываем какой утилитой будем разрешать конфликты

Далее в случае наличия CONFLICT прописываем (этим мы запускаем утилиту):

Пошаговая инструкция по работе с git и github для студентов

В первую очередь надо установить клиент git: обязательно потребуется консольный клиент, доступный по ссылке http://git-scm.com/downloads (поддерживаются основные ОС), графический клиент можно установить по желанию, исходя из своих предпочтений. На Unix системах можно воспользоваться менеджером пакетов (yum на fedora и подобных или apt-get на debian, ubuntu и подобных) вместо того, чтобы скачивать установщик с сайта.

Далее работа с git будет объясняться на примере работы с консольным клиентом по следующим причинам:

  • Чтобы у вас складывалось понимание происходящего и при возникновении проблем вы могли четко объяснить, что вы делали, и было видно, что пошло не так.
  • Все нажатия кнопок в графических клиентах в итоге сводят к выполнению определнных команд консольного клиента, в то же время возможности графических клиентов ограничены по сравнению с консольным
  • У тех, кто будет работать в классе на стоящих там компьютерах, не будет другого выбора, кроме как пользоваться консольным клиентом (на сколько мне известно, никаких графических клиентов для git там не установлено)

Аккаунт и репозитории на github.com

Затем надо зарегистрироваться на https://github.com/. После чего можно будет создавать свои репозитории или присоединиться к работе над проектами коллег, сделав fork другого репозитория. Вам предлагается начать с создания fork-а к заведенному мной репозиторию https://github.com/andreiled/mipt-cs-4sem, где я буду выкладывать примеры кода к занятиям и задания. О механизме обмена кодом между пользователями мы поговорим на следующем занятии.

Работа с кодом из репозитория на локальном компьютере

Создание локального репозитория, связанного с удаленным репозиторием

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

  1. Открываем консольный клиент.
  • На Windows после установки клиента появляется пункт Git Bash в контекстом меню папки. Достаточно перейти в желаемую папку и воспользоваться этим пунктом меню.
  • На Unix системах достаточно открыть терминал и перейти в нужную директорию. При стандартной установке консольного клиента будет доступна команда git без дополнительных усилий.
  1. Выполняем команду git clone https://github.com/%user_login%/%repo_name%.git . Полную https ссылку на репозиторий для его выкачивания можно также найти на странице самого репозитория на github. После этого в текущей папке появится новая папка с именем %repo_name% , содержащая копию удаленного (remote) репозитория.
  2. Переходим в свежесозданную папку репозитория и настраиваем его:
  3. git config user.name ivan.ivanov
  4. git config user.email ivanov@example.com
Цукерберг рекомендует:  Error - Помогите разобраться с ошибкой CS1061. C#

Внесение и оформление изменений в локальном репозитории

  1. Воспользовавшись командой git status можно узнать, на какой ветке (branch) репозитория вы сейчас находитесь, какие изменения присутствуют в вашей рабочей копии и другую информацию.
    Рабочей копией называется совокупность файлов в локальной папке репозитория за исключением служебных файлов.
  2. После внесения каких-либо изменений в рабочую копию их можно закоммитить в локальный репозиторий:
  3. сначала нужная часть изменений подготавливается к коммиту с использованием команды git add %file_path%
  4. после чего производится коммит командой git commit
    Использование команды без аргументов откроет текстовый редактор, где надо будет написать комментарий для коммита, коммит обязательно должен иметь комментарий. Другим вариантом задания комментария к коммиту является использование команды git commit -m «%commit_message%»
  5. Историю изменений можно посмотреть командой git log или git log —name-only . Если вся история изменений не умещается на экране, то можно пользоваться клавишами прокрутки на клавиатуре («стрелочки», PgUp, PgDown), выход из режима просмотра изменений осуществляется нажатием клавиши «q».

Загрузка локальных изменений в удаленный репозиторий

После того, как были выполнены нужные локальные коммиты, изменения можно загрузить в удаленный репозиторий с помощью команды git push origin master . GIT клиент при этом запросит имя пользователя и пароль для доступа к github.
Выполнение этой команды может закончиться с ошибкой, если в локально репозитории отсутствуют последние изменения, имеющиеся в удаленном репозитории. Для решения этой проблемы надо выполнить команду git pull , которая скачает последние изменения из удаленного репозитория и смержит их с вашими локальными правками, после чего можно повторить команду git push .

Git для начинающих. Часть 8. Добавление, удаление и переименование файлов в репозитории

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

Добавление файлов в git репозиторий

Добавление файлов в репозиторий – это достаточно простая операция, мало чем отличающаяся от отправки изменений в отслеживаемых файлах в репозиторий. Мы уже не раз выполняли эту операцию в предыдущих уроках, но сделаем это ещё раз. Создадим новый репозиторий, для этого перейдите в каталог, в котором вы хотите его расположить и введите команду git init .

Создайте в каталоге файл README.md любым удобным для вас способом, мы сделаем это с помощью команды touch .

Теперь проверим состояние отслеживаемой директории.

Как вы можете видеть: в рабочей директории есть один неотслеживаемый файл README.md . Git нам подсказывает, что нужно сделать для того, чтобы начать отслеживать изменения в файле README.md : необходимо выполнить команду git add , сделаем это.

Посмотрим ещё раз на состояние.

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

Теперь в рабочей директории и в stage нет объектов, информацию об изменении которых необходимо внести в репозиторий.

В репозиторий был сделан один коммит.

Удаление файлов из git репозитория и из stage

Удаление файла из stage

Вначале разберемся со stage . Создадим ещё один файл.

“Отправим” файл main.c в stage .

Внесем изменения в README.md .

Информацию об этом также отправим в stage .

Посмотрим на состояние stage .

Если нам необходимо убрать из stage , какой-то из этих файлов (main.c или README.md), то для этого можно воспользоваться командой git –rm cashed , сделаем это для файла main.c .

Теперь посмотрим на состояние рабочей директории и stage .

Видно, что изменения в файле README.md готовы для коммита, а вот файл main.c перешел в состояние – неотслеживаемый. Отправим main.c в stage и, после этого, сделаем коммит в репозиторий.

Удаление файлов из git репозитория

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

Удалим файл main.c из рабочей директории.

Уведомим об этом систему git .

Вместо команды git rm можно использовать git add , но само слово add в данном случае будет звучать несколько неоднозначно, поэтому лучше использовать rm . На данном этапе еще можно вернуть все назад с помощью команды git checkout — , в результате, в нашу рабочую директорию будет скопирован файл из репозитория. Создадим коммит, фиксирующий удаление файла.

Теперь в репозитории остался только один файл README.md .

Второй способ – это сразу использовать команду git rm без предварительного удаления файла из директории. Вновь создадим файл main.c и добавим его в репозиторий.

Удалим файл из репозитория.

Файла main.c больше нет в репозитории.

Его также нет и в рабочем каталоге.

Удалите файл README.md из репозитория самостоятельно.

Переименование файлов в git репозитории

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

Первый способ. Создадим файл test_main_file.c и добавим его в репозиторий.

Содержимое репозитория после этого будет выглядеть так.

Переименуем его на test_main.c .

Сделаем это в рабочей директории.

Теперь отправим изменение в репозиторий.

В репозитории и в рабочей директории будет находится только файл test_main.c .

Второй способ.

В рамках второго способа рассмотрим работу с командой git mv . Переименуем файл test_main.c в main.c . Текущее содержимое репозитория и рабочего каталога.

Переименуем файл test_main.c на main.c средствами git .

Имя файла изменилось как в репозитории так и в рабочем каталоге.

Отличный курс по git делают ребята из GeekBrains , найдите в разделе “Курсы” курс “Git. Быстрый старт” , он бесплатный!

Шпаргалка по консольным командам Git

Dolore ea vel quia alias in sed consequuntur. Aliquid harum rem quis. Voluptates nulla qui ipsam possimus animi. Sunt officiis amet esse adipisci architecto quidem repellat est.

Velit culpa repellendus ipsa. Eum minus blanditiis sint nisi nihil.

Et ut cumque accusamus dolor quis maiores. Quisquam provident modi natus sunt voluptatem voluptate aspernatur. Voluptatum voluptates explicabo sequi necessitatibus. Impedit distinctio in dolor ut necessitatibus consequatur. Adipisci voluptate dolorum et omnis asperiores. Consequatur molestias praesentium et molestiae aperiam pariatur. Similique autem aperiam debitis explicabo voluptatum iusto omnis voluptas.

Aut esse a aspernatur accusantium. Sapiente sunt provident est fugit.

Adipisci quia aut ut ipsum ut. Ut corporis aliquid voluptatem iusto mollitia. Assumenda voluptate ut tenetur sed temporibus aut quia. Et porro in quos pariatur ab ratione omnis. Neque quisquam enim dignissimos vel. Labore molestias quis molestiae optio. Nulla est velit laudantium velit ut minus consequuntur maiores. Architecto accusamus aut vel deleniti quis rem.

Общее

Git — система контроля версий (файлов). Что-то вроде возможности сохраняться в компьютерных играх (в Git эквивалент игрового сохранения — коммит). Важно: добавление файлов к «сохранению» двухступенчатое: сначала добавляем файл в индекс ( git add ), потом «сохраняем» ( git commit ).

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


Отслеживаемые файлы могут быть в 3-х состояниях: неизменённые, изменённые, проиндексированные (готовые к коммиту).

Концепция GIT

Ключ к пониманию концепции git — знание о «трех деревьях»:

  • Рабочая директория — файловая система проекта (те файлы, с которыми вы работаете).
  • Индекс — список отслеживаемых git-ом файлов и директорий, промежуточное хранилище изменений (редактирование, удаление отслеживаемых файлов).
  • Директория .git/ — все данные контроля версий этого проекта (вся история разработки: коммиты, ветки, теги и пр.).

Коммит — «сохранение» (хранит набор изменений, сделанный в рабочей директории с момента предыдущего коммита). Коммит неизменен, его нельзя отредактировать.

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

Простейший цикл работ

  • Редактирование, добавление, удаление файлов (собственно, работа).
  • Индексация/добавление файлов в индекс (указание для git какие изменения нужно будет закоммитить).
  • Коммит (фиксация изменений).
  • Возврат к шагу 1 или отход ко сну.

Указатели

  • HEAD — указатель на текущий коммит или на текущую ветку (то есть, в любом случае, на коммит). Указывает на родителя коммита, который будет создан следующим.
  • ORIG_HEAD — указатель на коммит, с которого вы только что переместили HEAD (командой git reset . , например).
  • Ветка ( master , develop etc.) — указатель на коммит. При добавлении коммита, указатель ветки перемещается с родительского коммита на новый.
  • Теги — простые указатели на коммиты. Не перемещаются.

Настройки

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

Если вы в Windows:

Указание неотслеживаемых файлов

Файлы и директории, которые не нужно включать в репозиторий, указываются в файле .gitignore . Обычно это устанавливаемые зависимости ( node_modules/ , bower_components/ ), готовая сборка build/ или dist/ и подобные, создаваемые при установке или запуске. Каждый файл или директория указываются с новой строки, возможно использование шаблонов.

Консоль

Длинный вывод в консоли: Vim

Вызов некоторых консольных команд приводит к необходимости очень длинного вывода в консоль (пример: вывод истории всех изменений в файле командой git log -p fileName.txt ). При этом прямо в консоли запускается редактор Vim. Он работает в нескольких режимах, из которых Вас заинтересуют режим вставки (редактирование текста) и нормальный (командный) режим. Чтобы попасть из Vim обратно в консоль, нужно в командном режиме ввести :q . Переход в командный режим из любого другого: Esc .

Если нужно что-то написать, нажмите i — это переход в режим вставки текста. Если нужно сохранить изменения, перейдите в командный режим и наберите :w .

Git — Git добавление файлов

git config —global user.name «[name]» — установить имя, которое будет прикрепляться к коммиту.

git config —global user.email «[email address]» — установить email, который будет прикрепляться к коммиту.

git config —global color.ui auto — включить полезную подсветку командной строки.

git config —global push.default current — обновлять удаленную ветку с таким же именем, что и локальная, при пуше изменений (если не указано иного).

git config —global core.editor [editor] — установить редактор для редактирования сообщений коммита.

git config —global diff.tool [tool] — установить программу для разрешения конфликтов при слиянии.

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

git init [project-name] — создать новый локальный репозиторий с заданным именем.

git clone [url] — загрузить проект и его полную историю изменений.

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

git status — полный список изменений файлов, ожидающих коммита.

git status -s — краткий вид изменений.

git diff — показать изменения в файлах, которые еще не были добавлены в индекс коммита (staged).

git add [file] — сделать указанный файл готовым для коммита.

git add . — сделать все измененные файлы готовыми для коммита.

git add ‘*.txt’ — добавить только файлы, соответствующие указанному выражению.

git add —patch filename — позволяет выбрать какие изменения из файла добавятся в коммит.

git diff —staged — показать что было добавленно в индекс с помощью git add , но еще не было закоммиченно.

git diff HEAD — показать что изменилось с последнего коммита.

git diff HEAD^ — показать что изменилось с предпоследнего коммита.

git diff [branch] — сравнить текущую ветку с заданной.

git difftool -d — то же самое, что и diff , но показывает изменения в заданной difftool.

git difftool -d master.. — показать изменения, сделанные в текущей ветке.

git diff —stat — показать статистику какие файлы были изменены и как.

git reset [file] — убрать файлы из индекса коммита (изменения не теряются).

git commit — записать изменения в репозиторий. для написания сообщения откроется назначенный редактор.

git commit -m «[descriptive message]» — записать изменения с заданным сообщением.

git commit —amend — добавить изменения к последнему коммиту.

Работа с ветками

git branch — список всех локальных веток в текущей директории.

git branch [branch-name] — создать новую ветку.

git checkout [branch-name] — переключиться на указанную ветку и обновить рабочую директорию.

git checkout -b /
— переключиться на удаленную ветку.

git checkout [filename] — вернуть файл в первоначальное состояние если он еще не был добавлен в индекс коммита.

git merge [branch] — соединить изменения в текущей ветке с изменениями из заданной.

git merge —no-ff [branch] — соединить ветки без режима “fast forwarding”.

git branch -a — посмотреть полный список локальных и удаленных веток.

git branch -d [branch] — удалить заданную ветку.

git branch -D [branch] — принудительно удалить заданную ветку, игнорируя ошибки.

git branch -m

    — переименовать ветку.

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

git rm [file] — удалить файл из рабочей директории и добавить в индекс информацию об удалении.

git rm —cached [file] — удалить файл из репозитория, но сохранить его локально.

git mv [file-original] [file-renamed] — изменить имя файла и добавить в индекс коммита.

Отслеживание файлов

.gitignore — текстовый файл, в котором задаются правила для исключения файлов из репозитория. Например:

git ls-files —other —ignored —exclude-standard — список всех игнорируемых файлов.

Сохранение фрагментов

git stash — положить во временное хранилище все отслеживаемые файлы.

git stash pop — восстановить последние файлы, положенные во временное хранилище.

git stash list — список всех сохраненных изменений во временном хранилище.

git stash drop — удалить последние файлы, положенные во временное хранилище.

Просмотр истории

git log — список изменения текущей ветки.

git log —follow [file] — список изменения текущего файла, включая переименования.

git log —pretty=format:»%h %s» —graph — изменение вида отображения истории изменений.

git log —author=’Name’ —after= <1.week.ago>—pretty=oneline —abbrev-commit — посмотреть над чем работал заданный пользователь последнюю неделю.

git log —no-merges master.. — посмотреть историю изменений только для текущей ветки.

git diff [file-branch]..[second-branch] — посмотреть различия между двумя заданными ветками.

git show [commit] — показать метадату и изменения в заданном коммите.

git show [branch]:[file] — посмотреть на файл в другой ветке, не переключаясь на неё.

Отмена коммитов

git reset — убрать изменения из индекса коммита, сами изменения останутся.

git reset [commit/tag] — отменить все коммиты после указанного коммита, изменения будут сохранены локально.

git reset —hard [commit] — принудительно вернутся к указанному коммиту, не сохраняя историю и изменения.

Синхронизация изменений

git fetch [bookmark] — загрузить всю историю с заданного удаленного репозитория.

git merge [bookmark]/[branch] — слить изменения локальной ветки и заданной удаленной.

git push — запушить текущую ветку в удаленную ветку.

git push [remote] [branch] — запушить ветку в указанный репозиторий и удаленную ветку.

git push [bookmark] :[branch] — в удаленном репозитории удалить заданную ветку.

git push -u origin master — если удаленная ветка не установлена как отслеживаемая, то сделать ее такой.

git pull — загрузить историю и изменения удаленной ветки и произвести слияние с текущей веткой.

git pull [remote][branch] — указать конкретную удаленную ветку для слияния.

git remote — посмотреть список доступных удаленных репозиториев.

git remote -v — посмотреть детальный список доступных удаленных репозиториев.

git remote add [remote][url] — добавить новый удаленный репозиторий.

Добавление изменений в Git и GitHub

Копирование репозитория с GitHub

Для выполнения заданий вы будете использовать приватный репозиторий, который создан на GitHub.

Для работы с ним локально, его нужно скопировать. Для этого используется команда git clone:

В этой команде вам нужно сменить имя репозитория “online-4-natasha-samoylenko” на свой репозиторий.

В итоге, в текущем каталоге, в котором была выполнена команда git clone, появится каталог с именем равным имени репозитория. В моем случае — online-4-natasha-samoylenko.

Если вы перейдете в этот каталог, то увидите в нем содержимое репозитория на GitHub.

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

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

  • был создан каталог .git
  • скачаны все данные репозитория
  • скачаны все изменения, которые были в репозитории
  • ваш репозиторий на GitHub настроен как remote для этого репозитория

Это значит, что теперь у вас готов полноценный репозиторий Git, в котором вы можете работать.

Обычно, последовательность работы будет такой:

  • перед началом работы, синхронизируете локальное содержимое с GitHub командой git pull (синхронизация из GitHub в локальный репозиторий)
  • редактируете какие-то файлы репозитория
  • добавляете их в staging командой git add
  • делаете commit с помощью git commit
  • когда вы готовы закачать локальные изменения на GitHub, делаете git push

Если вы работаете с заданиями с работы и дома, надо не забывать первый и последний шаг:

  • первый шаг — обновляет ваш локальный репозиторий на виртуалке
  • последний шаг — загружает изменения на GitHub

Синхронизация из GitHub в локальный репозиторий

Все команды выполняются внутри каталога репозитория (в примере выше — online-4-natasha-samoylenko)

Команда git pull:


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

Если что-то было изменено, вывод будет примерно таким:

Добавление новых файлов или изменений в существующих файлах

Добавление всех новых файлов или изменений в существующих:

Если необходимо добавить конкретный файл (в данном случае — README.md):

Commit

При выполнении commit обязательно надо указать сообщение. Будет лучше, если сообщение будет со смыслом, а не просто “update” или подобное:

Push на GitHub

Для загрузки всех локальных изменений на GitHub, используется git push:

Перед выполнением git push, можно выполнить команду $ git log -p origin/master.. — она покажет какие изменения вы собираетесь добавлять в свой репозиторий на GitHub.

Git для начинающих

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

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

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

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

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

Установка Git

На официальном сайте Git есть детальная информация об его установке на Linux, Mac и Windows. В нашем случае, мы будем использовать в целях демонстрации Ubuntu 13.04 , где установим Git с помощью apt-get:

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

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

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

Цукерберг рекомендует:  Php - Нужна помощь в проверке на php

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

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

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

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

Подготовка файлов для коммита

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

Проверить статус репозитория

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

Добавление файлов в Git для отслеживания

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

Добавляем файлы при помощи команды add :

Снова проверив состояние репозитория, мы увидим, что был добавлен один файл:

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

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

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

Удаление файлов

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

Но выполнение простой команды git rm удалит файл не только из Git , но также и из вашей локальной файловой системы! Чтобы

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

Коммит изменений

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

Вы можете привязывать к каждому коммиту сообщение, которое добавляется при помощи префикса -m :

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

Избегайте слишком общих сообщений типа « Исправлены ошибки ». Если у вас есть трекер задач, вы можете добавлять сообщения в виде « Исправлена ошибка #234 ».

Хорошей практикой является использование имени ветки или имени функции в качестве префикса к сообщению коммита. Например, « Управление активами: добавлена функция для генерации PDF файлов активов » — это содержательное сообщение.

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

Обратите внимание, что на скриншоте наш первый коммит определяется кодом 8dd76fc .

Дальнейшие коммиты

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

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

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

Вы можете избежать использования этой команды, воспользовавшись префиксом -a для команды git commit , который добавит все изменения в отслеживаемые файлы.

Этот процесс, однако, очень опасен, так как может навредить проекту. Например, допустим, что вы открыли файл и изменили его по ошибке.

Если вы избирательно размещаете файлы, то заметите изменения в каждом файле. Но если вы добавите префикс -a к вашему коммиту, все файлы будут закоммичены, и вы не сможете выявить возможные ошибки.

После того, как вы разместили ваши файлы, можно приступить к коммиту. Я упоминал, что с каждым коммитом может быть ассоциировано сообщение, которое мы вводим с помощью префикса -m .

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

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

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

Так будет показана вся история проекта, которая представляет собой список всех коммитов и информации по ним. Информация о коммите включает в себя хеш-код коммита, автора, время и сообщение коммита. Есть различные варианты git log , которые вы можете изучить, как только освоите понятие ветки (англ. branch) в Git .

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

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

Размещение кода в облаке

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

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

Если вы хотите разместить код в облаке, вы можете создать проект на GitHub , GitLab или BitBucket и поместить уже существующий код в репозиторий.

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

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

Заключение

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

Данная публикация представляет собой перевод статьи « Git for Beginners » , подготовленной дружной командой проекта Интернет-технологии.ру

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

Что такое Git и зачем он мне?

Git — это распределённая система контроля версий, которая позволяет сохранять все изменения, внесённые в файлы, хранящиеся в репозитории. Изменения хранятся в виде снимков, называемых коммитами, которые могут размещаться на многих серверах. Считайте это стандартным облаком для бэкапов на стероидах — вы не только можете восстановить код в случае сбоя, но и откатить код до любого из предыдущих сохранённых состояний. Также вы легко можете взаимодействовать с другими разработчиками — опять же, как несколько человек могут работать над одним файлом в Google Docs, так и разработчики могут одновременно работать над одним репозиторием и сохранять свои изменения.

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

Как работать с Git

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

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

Как правило, команды Git принимают вид git , где аргументом может быть путь к файлу. У команд также могут быть опции, которые обозначаются как — или — . Они позволяют более детально настроить действия команды. В этой статье команды будут представлены в общем виде, поэтому всё, что находится в <> , вам нужно будет заменить на собственные значения.

Если вы не знаете, как использовать команду, то можете открыть руководство с помощью git help , а если вам просто нужно напоминание, используйте git -h или git —help ( —help и -h эквивалентны).

Подготовка Git

Установка Git

Пользователи Windows могут скачать его отсюда.

В macOS (OS X) Git поставляется как часть инструментов командной строки XCode, поэтому нужно их установить. Чтобы проверить наличие Git, откройте терминал и введите git —version для проверки версии.

Если вы пользуетесь Linux, то используйте команду sudo apt install git-all (дистрибутивы на основе Debian) или sudo dnf install git-all (на основе RPM).

Настройка конфигурационного файла

Первое, что нужно сделать после установки Git, — настроить имя пользователя и email, так как они используются для идентификации и хранятся во всех сделанных вами снимках. Эти настройки вместе со всеми остальными хранятся в конфигурационном файле.

Вы можете либо напрямую отредактировать файл .gitconfig с помощью текстового редактора, либо с помощью команды git config —global —edit , а также можете отредактировать отдельные поля, используя команду git config —global — нас интересуют поля user.name и user.email .

Также можно настроить текстовый редактор для написания сообщений коммитов, используя поле core.editor . Изначально используется системный редактор по умолчанию, например, vi для Linux/Mac. Поле commit.template позволяет указать шаблон, который будет использоваться при каждом коммите.

Есть множество других полей, однако одно из самых полезных — это alias , которое привязывает команду к псевдониму. Например, git config —global alias.st «status -s» позволяет использовать git st вместо git status -s

Команда git config —list выведет все поля и их значения из конфигурационного файла.

Создаём Git-репозиторий

Для инициализации нового репозитория .git можно использовать команду git init или, если вы хотите скопировать существующий, git clone .

История коммитов в Git

Git хранит данные в виде набора легковесных «снимков», известных как коммиты. Они хранят состояние файловой системы в определённый момент времени, а также указатель на предыдущий(-ие) коммит(-ы). Каждый коммит содержит уникальную контрольную сумму — идентификатор, который Git использует, чтобы ссылаться на коммит. Чтобы отслеживать историю, Git хранит указатель HEAD, который указывает на первый коммит (мы следуем по цепочке коммитов в обратном порядке, чтобы попасть к предыдущим коммитам).

Мы можем ссылаться на коммит либо через его контрольную сумму, либо через его позицию относительно HEAD, например HEAD

4 ссылается на коммит, который находится 4 коммитами ранее HEAD.

Файловая система Git

Git отслеживает файлы в трёх основных разделах:

  • рабочая директория (файловая система вашего компьютера);
  • область подготовленных файлов (staging area, хранит содержание следующего коммита);
  • HEAD (последний коммит в репозитории).

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

Просмотр изменений в файловых системах

Команда git status отображает все файлы, которые различаются между тремя разделами. У файлов есть 4 состояния:

  1. Неотслеживаемый (untracked) — находится в рабочей директории, но нет ни одной версии в HEAD или в области подготовленных файлов (Git не знает о файле).
  2. Изменён (modified) — в рабочей директории есть более новая версия по сравнению с хранящейся в HEAD или в области подготовленных файлов (изменения не находятся в следующем коммите).
  3. Подготовлен (staged) — в рабочей директории и области подготовленных файлов есть более новая версия по сравнению с хранящейся в HEAD (готов к коммиту).
  4. Без изменений — одна версия файла во всех разделах, т. е. в последнем коммите содержится актуальная версия.

Примечание Файл может быть одновременно в состоянии «изменён» и «подготовлен», если версия в рабочей директории новее, чем в области подготовленных файлов, которая в свою очередь новее версии в HEAD.

Мы можем использовать опцию -s для команды git status , чтобы получить более компактный вывод (по строке на файл). Если файл не отслеживается, то будет выведено ?? ; если он был изменён, то его имя будет красным, а если подготовлен — зелёным.

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

  • git diff — сравнение рабочей директории с областью подготовленных файлов;
  • git diff —staged — сравнение области подготовленных файлов с HEAD.

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

Обновление файловых систем

Команда git add обновляет область подготовленных файлов версиями файлов/папок из рабочей директории.

Команда git commit обновляет HEAD новым коммитом, который делает снимки файлов в области подготовленных файлов.

Действие команды git reset состоит из трёх потенциальных шагов:

  1. Переместить указатель HEAD на (например, при откате коммита в рабочей директории и области подготовленных файлов будут более новые версии файлов, чем в HEAD). Также указатель HEAD ветки будет перемещён на этот коммит.
  2. Обновить область подготовленных файлов содержимым коммита. В таком случае только в рабочей директории будут новейшие версии файлов.
  3. Обновить рабочую директорию содержимым области подготовленных файлов. С этим нужно быть осторожнее, поскольку в итоге будут уничтожены изменения файлов.

По умолчанию команда git reset выполняет только шаги 1 и 2, однако её поведение можно изменить с помощью опций —soft (только 1 шаг) и —hard (все шаги).

Если передать путь к файлу/папке, то команда будет выполнена только для них, например git reset —soft HEAD

Команда git checkout HEAD приводит к тому же результату, что и git reset —hard HEAD — перезаписывает версию файла в области подготовленных файлов и в рабочей директорией версией из HEAD, то есть отменяет изменения после последнего коммита.

С другой стороны, git checkout (уже без HEAD) перезаписывает версию файла в рабочей директории версией в области подготовленных файлов, то есть отменяет изменения с момента последней подготовленной версии.

Наконец, git rm отменяет отслеживание файла и удаляет его из рабочей директории, опция —cached позволит сохранить файл.

Игнорирование файлов

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

  • файлы с чувствительной информацией вроде паролей;
  • большие бинарные файлы;
  • файлы сборок, которые генерируются после каждой компиляции;
  • файлы, специфичные для ОС/IDE, например, .DS_Store для macOS или .iml для IntelliJ IDEA — нам нужно, чтобы репозиторий как можно меньше зависел от системы.

Для игнорирования используется файл .gitignore . Чтобы отметить файлы, которые мы хотим игнорировать, можно использовать шаблоны поиска (считайте их упрощёнными регулярными выражениями):

  • /___ — позволяет избежать рекурсивности — соответствует файлам только в текущей директории;
  • __/ — соответствует всем файлам в указанной директории;
  • *___ — соответствует всем файлам с указанным окончанием;
  • ! — игнорирование файлов, попадающих под указанный шаблон;
  • [__] — соответствует любому символу из указанных в квадратных скобках;
  • ? — соответствует любому символу;
  • /**/ — соответствует вложенным директориям, например a/**/d соответствует a/d , a/b/d , a/b/c/d и т. д.


Мы даже можем использовать шаблоны поиска при указании файла/папки в других командах. Например, git add src/*.css добавит все файлы .css в папке src .

Коммиты

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

Команда git commit откроет текстовый редактор для ввода сообщения коммита. Также эта команда принимает несколько распространённых аргументов:

  • -m позволяет написать сообщение вместе с командой, не открывая редактор. Например git commit -m «Пофиксил баг» ;
  • -a переносит все отслеживаемые файлы в область подготовленных файлов и включает их в коммит (позволяет пропустить git add перед коммитом);
  • —amend заменяет последний коммит новым изменённым коммитом, что бывает полезно, если вы неправильно набрали сообщение последнего коммита или забыли включить в него какие-то файлы.

Несколько советов, к которым стоит прислушаться:

  • Коммитьте часто: вы не сможете откатить изменения, если откатывать не к чему.
  • Одно изменение — один коммит: не помещайте все не связанные между собой изменения в один коммит, разделите их, чтобы было проще откатиться.
  • Формат сообщений: заголовок должен быть в повелительном наклонении, меньше 50 символов в длину и должен логически дополнять фразу this commit will ___ (this commit will fix bugs — этот коммит исправит баги). Сообщение должно пояснять, почему был сделан коммит, а сам коммит показывает, что изменилось. Здесь подробно расписано, как писать сообщения для коммитов.
  • (Опционально) Не коммитьте незначительные изменения: в большом репозитории множество небольших коммитов могут засорить историю. Хорошим тоном считается делать такие коммиты при разработке, а при добавлении в большой репозиторий объединять их в один коммит.

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

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

  • -p показывает изменения в каждом коммите;
  • —stat показывает сокращённую статистику для коммитов, например изменённые файлы и количество добавленных/удалённых строк в каждом их них;
  • -n показывает n последних коммитов;
  • —since=___ и —until=___ позволяет отфильтровать коммиты по промежутку времени, например —since=»2020-01-01″ покажет коммиты с 1 января 2020 года;
  • —pretty позволяет указать формат логов (например, —pretty=oneline ), также можно использовать —pretty=format для большей кастомизации, например —pretty=format:»%h %s» ;
  • —grep и -S фильтруют коммиты с сообщениями/изменениями кода, которые содержат указанную строку, например, git log -S имя_функции позволяет посмотреть добавление/удаление функции;
  • —no-merges пропускает коммиты со слиянием веток;
  • ветка1..ветка2 позволяет посмотреть, какие коммиты из ветки 2 не находятся в ветке 1 (полезно при слиянии веток). Например, git log master..test покажет, каких коммитов из ветки test нет в master (о ветках поговорим чуть позже).
  • —left-right ветка1. ветка2 показывает коммиты, которые есть либо в ветке 1, либо в ветке 2, но не в обеих; знак обозначает коммиты из ветка1 , а > — из ветка2 . Обратите внимание: используется три точки, а не две;
  • -L принимает аргумент начало,конец:файл или :функция:файл и показывает историю изменений переданного набора строк или функции в файле.

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

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

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

Удалённые серверы

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

Цукерберг рекомендует:  Sql server - Статус базы данных MS SQL подозрительная

Команда git remote -v выводит список удалённых репозиториев, которые мы отслеживаем, и имена, которые мы им присвоили.

При использовании команды git clone мы не только загружаем себе копию репозитория, но и неявно отслеживаем удалённый сервер, который находится по указанному адресу и которому присваивается имя origin.

Наиболее употребляемые команды:

  • git remote add — добавляет удалённый репозиторий с заданным именем;
  • git remote remove — удаляет удалённый репозиторий с заданным именем;
  • git remote rename — переименовывает удалённый репозиторий;
  • git remote set-url — присваивает репозиторию с именем новый адрес;
  • git remote show — показывает информацию о репозитории.

Следующие команды работают с удалёнными ветками:

  • git fetch — получает данные из ветки заданного репозитория, но не сливает изменения;
  • git pull — сливает данные из ветки заданного репозитория;
  • git push — отправляет изменения в ветку заданного репозитория. Если локальная ветка уже отслеживает удалённую, то можно использовать просто git push или git pull .

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

Ветвление

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

Это ведёт нас к ключевой особенности Git — ветвлению, возможности работать над разными версиями проекта. Это значит, что вместо одного списка с упорядоченными коммитами история будет расходиться в определённых точках (что делает её похожей на дерево). Каждая ветвь в Git содержит легковесный указатель HEAD на последний коммит в этой ветке, что позволяет без лишних затрат создать много веток. Совет: называйте ветку в соответствии с разрабатываемой в ней функциональностью. Ветка по умолчанию называется master.

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

  • git branch — создаёт новую ветку с HEAD, указывающим на HEAD. Если не передать аргумент , то команда выведет список всех локальных веток;
  • git checkout — переключается на эту ветку. Можно передать опцию -b , чтобы создать новую ветку перед переключением;
  • git branch -d — удаляет ветку.

Как наш локальный репозиторий, так и удалённый, могут иметь множество ветвей, поэтому когда вы отслеживаете удалённый репозиторий, на самом деле отслеживается удалённая ветка ( git clone привязывает вашу ветку master к ветке origin/master удалённого репозитория).

Привязывание к удалённой ветке:

  • git branch -u / — привязывает текущую ветку к указанной удалённой ветке;
  • git checkout —track / — аналог предыдущей команды;
  • git checkout -b / — создаёт новую локальную ветку и начинает отслеживать удалённую;
  • git branch —vv — показывает локальные и отслеживаемые удалённые ветки;
  • git checkout — создаёт локальную ветку с таким же именем, как у удалённой, и начинает её отслеживать.

В общем, git checkout связан с изменением места, на которое указывает HEAD ветки, что похоже на то, как git reset перемещает общий HEAD.

Прятки и чистка

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

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

Однако порой у вас есть незавершённые изменения, которые нельзя фиксировать. В такой ситуации их можно сохранить и «спрятать» с помощью команды git stash . Чтобы вернуть изменения, используйте git stash apply .

Возможно, вместо этого вы захотите стереть все внесённые изменения. В таком случае используйте команду git clean . Опция -d также удалит неотслеживаемые файлы. Совет: добавьте опцию -n , чтобы увидеть, что произойдёт при запуске git clean без непосредственного использования.

Совмещение веток

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

Слияние

Оно включает в себя создание нового коммита, который основан на общем коммите-предке двух ветвей и указывает на оба HEAD в качестве предыдущих коммитов. Для слияния мы переходим на основную ветку и используем команду git merge .

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

После открытия таких файлов вы увидите похожие маркеры разрешения конфликта:

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

Перемещение

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

Для перемещения используется команда git rebase , которая воспроизводит изменения тематической ветки на основной; HEAD тематической ветки указывает на последний воспроизведённый коммит.

Перемещение vs. слияние

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

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

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

Поэтому вот совет:

Перемещайте изменения только на вашей приватной локальной ветке — не перемещайте коммиты, от которых зависит ещё кто-то.

Откат коммитов — revert и reset

Похожие дебаты по поводу того, что лучше использовать, возникают, когда вы хотите откатить коммит. Команда git revert создаёт новый коммит, отменяющий изменения, но сохраняющий историю, в то время как git reset перемещает указатель HEAD, предоставляя более чистую историю (словно бы этого коммита никогда и не было). Важно отметить, что это также означает, что вы больше не сможете вернуться обратно к этим изменениям, например, если вы всё-таки решите, что отмена коммита была лишней. Чище — не значит лучше!

Резюмируем

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

GitHub

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

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

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

Продвинутое использование: интерактивная подготовка

Вы можете с удобством управлять областью подготовленных файлов (например при фиксации нескольких небольших коммитов вместо одного большого) с помощью интерактивной консоли, которую можно запустить git add -i . В ней доступны 8 команд:

  • status — показывает для каждого файла краткое описание того, что (не)подготовлено;
  • update — подготавливает отслеживаемые файлы;
  • revert — убрать один или несколько файлов из подготовленной области;
  • add untracked — подготавливает неотслеживаемый файл;
  • patch — подготавливает только часть файла (полезно, когда вы, например, изменили несколько функций, но хотите разбить изменения на несколько коммитов). После выбора файла вам будут показаны его фрагменты и представлены возможные команды: Stage this hunk [y,n,q,a,d,j,J,g,/,e,?]? . Можно ввести ? , чтобы узнать, что делает каждая команда;
  • diff — показывает список подготовленных файлов и позволяет посмотреть изменения для каждого из них;
  • quit — выходит из интерактивной консоли;
  • help — показывает краткое описание каждой команды.

Символ * рядом с файлом означает, что команда изменит его статус (подготовлен/неподготовлен в зависимости от того, происходит ли обновление или откат). Если нажать Enter, не введя ничего ни в одном из под-меню команды, то все файлы перейдут в (не)подготовленное состояние.

Обратите внимание, что создание патчей (подготовка только части файла) доступно не только в интерактивной консоли, но и через команду git add -p .

Продвинутое использование: правим историю

Для большего контроля над историей коммитов локальной ветки можно использовать команду git rebase -i HEAD

n , которая откроет интерактивную консоль для перемещения набора последних n коммитов, перечисленных в порядке от старых к новым (то есть в том порядке, в котором они будут перемещены). Таким образом вы можете «редактировать историю», однако помните, что оригинальные коммиты нельзя изменить, только переместить.

Вы можете поменять порядок коммитов, изменив порядок, в котором они перечислены.

Измененяем сообщение коммита/разбиваем коммиты

Для указания коммита, который вы хотите изменить, используется команда edit . Затем, когда Git будет проводить перемещение, он остановится на этом коммите. После этого вы можете использовать git commit —amend , чтобы изменить сообщение или подготовить забытые файлы. Если вы хотите разделить коммит, после остановки введите git reset HEAD^ (в результате HEAD будет перемещён на один коммит назад и все изменённые в этом коммите файлы перейдут в статус неподготовленных). Затем вы сможете зафиксировать файлы в отдельных коммитах обычным образом.

После завершения редактирования введите git rebase —continue .

Перезапись нескольких коммитов

Иногда вам может потребоваться перезаписать несколько коммитов — в таких случаях можно использовать git filter-branch . Например, чтобы удалить случайно зафиксированный файл, можно ввести git filter-branch —tree-filter ‘git rm -f ‘ HEAD . Однако учтите, что при этом вся история перемещается.

Объединение нескольких коммитов

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

Переносим отдельный коммит

Кроме слияния/перемещения всех коммитов в тематической ветке, вас может интересовать только определённый коммит. Допустим, у вас есть локальная ветка drafts, где вы работаете над несколькими потенциальными статьями, но хотите опубликовать только одну из них. Для этого можно использовать команду git cherry-pick . Чтобы получить определённые коммиты, из которых мы хотим выбирать, можно использовать git log .. .

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

Заключение

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

450 страниц) и описывает Git более глубоко.

Хотите копнуть глубже в Git, но вам мало (или наоборот, много) одной большой книги? Тогда вам стоит взглянуть на наш план изучения.

Краткая инструкция как заливать на gitHub

Содержание

Быстрый старт (для нетерпеливых)

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

Создание репозитория на гитхабе

Теперь поговорим более подробно о гите и как заливать локальный репозиторий на удаленный. Начнем с создания удаленного репозитория на популярном сервисе https://github.com. Чтобы залить проект на gitHub нужно сначала создать в gitHub аккаунт и залогиниться.
После этого жмем на + New repository:

Появится страница Create a New Repository. В поле Repository name вводим имя репозитория, например your_project и жмем на Create repository:

Появится созданный репозиторий your_project:

Если это будет java-приложение, то нужно за комментировать *.jar в файле .gitignore. Открываем на редактирование файл .gitignore и за комментируем, в нашем случае, седьмую строчку:

.gitignore

Подготовка локального git репозитория

Подготовить локальный репозиторий можно двумя способами: создать репозиторий с нуля с последующим переносом изменений в удаленный репозиторий и сделать клон удаленного репозитория.
Первый способ создание локального репозитория с нуля командой git init.
Создадим проект на локальной машине с таким именем:

перейдем в этот каталог:

Выполним команду git init которая инициирует локальный репозиторий:

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

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

Подготовка локального файла

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

TestGitHub.java

Помещение файла в репозиторий

После того как мы создали файл его надо подготовить для фиксации и зафиксировать в репозитории, то есть закомитить. Подготовить для фиксации это означает, что его надо проиндексировать командой git add:

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

Если гит ругнется как показано ниже:

значит перед тем как коммитить изменения надо сообщить гиту свое имя и почту. Это нужно сделать так как гит включает эту инфу в каждую фиксированную версию:

Перенос изменений на удаленный репозиторий

Локальный репозиторий готов, теперь осталось перенести его на удаленный. Переносится репозиторий командой git push, но прежде чем переносить мы должны выяснить со сколькими репозиториями мы работаем и выбрать из списка тот, в который мы хотим перенести наши изменения. Для того, чтобы увидеть все удаленные репозитории нужно выполнить команду git remote -v:

Но мы увидим удаленные репозитории только в том случае, если мы с клонировали его командой git clone, в случае если мы создали локальный репозиторий командой git init, то мы ничего не увидим, в этом случае нам надо добавить удаленный репозиторий, это будет далее. А сейчас, допустим у нас есть клон удалённого репозитория. Выполнив команду git remote -v мы увидим url адреса и короткое имя для удалённых репозиториев с которыми мы работаем. В данном случае мы работаем с одним удаленным репозиторием, которому присвоено короткое имя по умолчанию origin, который находится по адресу https://github.com/your_account/your_project как для фетча, так и для пуша.
Теперь можем переносить все изменения для репозитория origin командой git push:

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

Добавление удаленных репозиториев

Если мы создали репозиторий командой git init, то чтобы перенести изменения на удаленный репозиторий, нам надо его добавить командой git remote add и придумать ему уникальное имя. Вот как добавляется удаленный репозиторий:

Мы задали удаленный репозиторий с коротким именем ourRep, который располагается по адресу https://additional_git_address/your_account/your_project. Если выполним команду git remote, то увидим url адреса для пуша и фетча только что добавленного удаленного репозитория:

Теперь зальём на него изменения командой git push:

Добавление изменений в Git и GitHub

Копирование репозитория с GitHub

Для выполнения заданий вы будете использовать приватный репозиторий, который создан на GitHub.

Для работы с ним локально, его нужно скопировать. Для этого используется команда git clone:

В этой команде вам нужно сменить имя репозитория “online-4-natasha-samoylenko” на свой репозиторий.

В итоге, в текущем каталоге, в котором была выполнена команда git clone, появится каталог с именем равным имени репозитория. В моем случае — online-4-natasha-samoylenko.

Если вы перейдете в этот каталог, то увидите в нем содержимое репозитория на GitHub.

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

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

  • был создан каталог .git
  • скачаны все данные репозитория
  • скачаны все изменения, которые были в репозитории
  • ваш репозиторий на GitHub настроен как remote для этого репозитория

Это значит, что теперь у вас готов полноценный репозиторий Git, в котором вы можете работать.

Обычно, последовательность работы будет такой:

  • перед началом работы, синхронизируете локальное содержимое с GitHub командой git pull (синхронизация из GitHub в локальный репозиторий)
  • редактируете какие-то файлы репозитория
  • добавляете их в staging командой git add
  • делаете commit с помощью git commit
  • когда вы готовы закачать локальные изменения на GitHub, делаете git push

Если вы работаете с заданиями с работы и дома, надо не забывать первый и последний шаг:

  • первый шаг — обновляет ваш локальный репозиторий на виртуалке
  • последний шаг — загружает изменения на GitHub

Синхронизация из GitHub в локальный репозиторий

Все команды выполняются внутри каталога репозитория (в примере выше — online-4-natasha-samoylenko)

Команда git pull:

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

Если что-то было изменено, вывод будет примерно таким:

Добавление новых файлов или изменений в существующих файлах

Добавление всех новых файлов или изменений в существующих:

Если необходимо добавить конкретный файл (в данном случае — README.md):

Commit

При выполнении commit обязательно надо указать сообщение. Будет лучше, если сообщение будет со смыслом, а не просто “update” или подобное:

Push на GitHub

Для загрузки всех локальных изменений на GitHub, используется git push:

Перед выполнением git push, можно выполнить команду $ git log -p origin/master.. — она покажет какие изменения вы собираетесь добавлять в свой репозиторий на GitHub.

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих