В чем различия между "git commit" и "git push"?
В уроке по Git, который я изучаю, git commit используется для хранения внесенных вами изменений.
Что такое git push используется для тогда?
17 ответов
В принципе git commit " записывает изменения в хранилище ", в то время как git push msgstr " обновлять удаленные ссылки вместе со связанными объектами ". Таким образом, первый используется в связи с вашим локальным хранилищем, а второй - для взаимодействия с удаленным хранилищем.
Вот хорошая картинка от Оливера Стила, которая объясняет модель git и команды:
Узнайте больше о git push а также git pull на GitReady.com (статья, на которую я ссылался первой)
commit: добавление изменений в локальный репозиторий
push: перенести последние коммиты на удаленный сервер
Ну, в основном git commit помещает ваши изменения в локальное хранилище, а git push отправляет ваши изменения в удаленное местоположение.
git push используется для добавления коммитов, которые вы сделали в локальном репозитории, в удаленный - вместе с git pull, это позволяет людям сотрудничать.
Совершить: {Снимок | Changeset | История записи | Версия | 'Сохранить как'} хранилища. Git-репозиторий = серия (дерево) коммитов (плюс несколько дополнительных вещей).
Локальный репозиторий: репозиторий на вашем компьютере.
Удаленный репозиторий: репозиторий на сервере (например, Github).
git commit: Добавить новый коммит (последний коммит + поэтапные модификации) в локальный репозиторий.
git push, git pull: Синхронизировать локальный репозиторий с удаленным репозиторием. push - применить изменения из локального в удаленный, pull - применить изменения из удаленного в локальный.
Поскольку git - это распределенная система управления версиями, разница в том, что commit будет фиксировать изменения в вашем локальном репозитории, тогда как push будет передавать изменения до удаленного репо.
git commit запишите ваши изменения в локальный репозиторий.
git push обновите удаленный репозиторий с вашими локальными изменениями.
Три вещи на заметку:
1)Рабочий каталог ----- папка, в которой находится наш файл кодов
2)Локальный репозиторий ------ Это внутри нашей системы. Когда мы впервые создаем команду COMMIT, создается этот локальный репозиторий. там же, где находится наш рабочий каталог,
Checkit ( .git) файл будет создан.
После этого, когда мы делаем коммит, он сохраняет изменения, которые мы вносим в файл Working Directory в локальный репозиторий ( .git).
3)Удаленный репозиторий ----- Он расположен вне нашей системы, как и на серверах, расположенных в любой точке мира. как GitHub. Когда мы выполняем команду PUSH, коды из нашего локального репозитория сохраняются в этом удаленном репозитории.
Объяснение здравого смысла того, как работает Git
Я использую Git в течение многих лет, но, как ни странно, никто здесь или в Интернете не может объяснить простыми словами , как Git, , , или на самом деле работает. Итак, ниже приведено простое объяснение. Я надеюсь, что это объясняет вещи более ясно. Мне помогло!
КРАТКИЙ ОБЗОР КАК РАБОТАЕТ GIT
В Git вы всегда сначала создаете код на своем локальном компьютере, а затем сохраняете свой код в «локальном репозитории» (репозитории) Git на своем компьютере. Затем вы загружаете свои изменения в общий «удаленный репозиторий» Git, когда вы закончите, чтобы другие могли получить доступ к вашим изменениям кода. Вы также загружаете изменения из «удаленного репозитория» в «локальный репозиторий», чтобы ваш код оставался актуальным с изменениями других разработчиков. Затем вы начинаете процесс заново.
Таким образом, Git позволяет вам удаленно делиться своим локальным кодом проекта с другими, сохраняя при этом версии этих изменений кода на случай, если что-то пойдет не так и вам придется переделывать какой-то плохой код. Это простое объяснение того, как работает Git, и цикла его использования.
БОЛЬШЕ ИНФОРМАЦИИ О GIT
Первым шагом всегда является написание кода на вашем локальном компьютере, игнорируя Git, который никак не участвует в сохранении или тестировании кода. Когда вы сохраняете локальный код на своем компьютере, он по умолчанию не сохраняется в Git, как вы думаете. Вы должны сделать второй шаг , называемый «фиксация». (Кстати, сохраненный код, который еще не зафиксирован, называется «поэтапным» кодом.)
Аcommitэто то же самое, что и сохранение изменений локального кода, но в «мире Git» . Это смущает людей. Но когда я вижу слово «зафиксировать», я думаю об этом как о «Git Save». Это дополнительный шаг, потому что вы уже однажды сохранили свои изменения кода, и теперь вам нужно сохранить их во второй раз в системе Git как фиксацию, иначе они не станут частью вашей локальной системы репозитория Git. Я думаю, что «коммиты» — это одна из причин, по которой некоторые считают Git плохо спроектированным. Это просто не интуитивно понятно.
A выполняется после того, как вы завершили сохранение всего кода и локально зафиксировали свой код в своем репозитории Git. Команда push отправляет изменения вашего локального репозитория (только фиксации) в удаленный репозиторий для его обновления. Когда он делает это, он полностью записывает 100% ваших изменений в удаленный репозиторий.так что они синхронизированы или код совпадает на 100% между ними. Думайте об этом как об «удаленном сохранении Git». Он записывает код в удаленном репо с тем, что у вас есть локально на вашем компьютере. Сначала это не имело для меня никакого смысла. Разве это не удалит изменения, внесенные другими разработчиками на удаленном компьютере? Что делать, если удаленный конфликтует с вашими изменениями или у вас нет изменений в удаленном, который вам нужен в первую очередь в вашем локальном репо? Сначала это смутило меня, так как никто не мог объяснить в Интернете, было ли это таким же, как «слияние», «фиксация», «запрос на извлечение» и т. д. Оказывается, это работает ТОЛЬКО при ОДНОМ УСЛОВИИ. В противном случае он блокирует ваш толчок и терпит неудачу!
«Нажатие» работает только в том случае, если вы единственный человек, изменяющий удаленное репо, и две базы кода одинаковы, кроме коммитов, которые вы добавили локально. В противном случае любые изменения, сделанные другим пользователем на этом пульте, отменят вашу отправку. Так что подумайте о «Частной удаленной перезаписи» той же копии, что и у вашего местного представителя. Но мы знаем, что многие разработчики будут отправлять изменения в удаленную копию так же, как и вы, верно? Таким образом, push будет неудачным, и все будут постоянно не синхронизированы в своей локальной копии с удаленной копией в этом дизайне.
Как я уже говорил, этот толчок ТОЛЬКОразрешено (не заблокировано в удаленном репо), если удаленный репозиторий находится в том же состоянии, что и ваш локальный репозиторий ДО того, как вы внесли изменения. Другими словами, вы можете передать свои локальные изменения только в удаленный проект и полностью перезаписать их с помощью a, если удаленное репо не было изменено каким-либо другим разработчиком, когда вы отправляете локальные изменения. Это один из странных аспектов Git, который смущает людей. Если ваша локальная копия кода каким-либо образом не синхронизирована с удаленным репо из-за того, что она была изменена, отправка завершится ошибкой, и вы будете вынуждены выполнить или «перебазировать», что является причудливым словом для «обновить локальное репо». сначала с удаленной копией». Если ваш push заблокирован, а затем вы делаете , он скопирует удаленный код и «объединит» его изменения кода с вашей локальной копией. Еще раз синхронизировавшись,
Это отлично работает в большинстве случаев, если только изменение кода не конфликтует с фиксациями или изменениями кода, которые вы сделали другим разработчиком, которые также сделали в той же области кода. В этом редком случае вам необходимо разрешить конфликт локально, прежде чем вы сможете продолжить что-либо еще, так как вы можете случайно стереть изменения других разработчиков своими собственными. Именно здесь (см. ниже) полезно вместо принудительной отправки, поскольку в первом случае основные изменения кода должны быть разрешены в удаленной копии вручную владельцами кода или администраторами, прежде чем какому-либо коду будет разрешено изменять удаленное репо.
Интересно, что «вытягивание» делает то же самое, что и «выталкивание», но в этом случае извлекает копию последнего удаленного проекта в вашу локальную систему git, а затем «сливает» эти изменения в вашу собственную копию, а не записывает их, как "толчок" делает. Конечно, это снова синхронизирует ваши удаленные и локальные копии, за вычетом новых коммитов, которые вы настроены обновлять в удаленном репо, снова используя «push».
После того, как вы синхронизировали свою локальную копию с удаленной через файл , теперь вы можете сделать и отправить свойcommitsили изменения снова сохраняются в удаленной копии и переписываются безопасно, зная, что вы объединили свои изменения с изменениями, внесенными всеми другими разработчиками.
После записи удаленной копии с фиксациями или изменениями вашей локальной копии удаленная копия точно соответствует вашей локальной копии. Поскольку они оба совпадают, любые дополнительные коммиты или сохранения, которые вы делаете локально, могут быть отправлены снова удаленно без вытягивания - до тех пор, пока разработчики не изменили удаленное, как вы. Git всегда будет предупреждать вас о толчках, если это так. Вы не можете испортить это. Вы можете делать «принудительные» толчки, «перебазирование» и другие трюки, но это не важно. Но как только другие разработчики вносят свои изменения, вы снова теряете синхронизацию и должны сначала выполнить извлечение, прежде чем вносить изменения.
Этот коммит-тяни-толкай — настоящий ритм разработки Git, о котором вам никто не говорит и не предполагает, что вы его понимаете. Большинство этого не делает. Это просто не интуитивно и не логично.
Конечно, вы можете «форсировать» толчок и все равно переписать все. Но эта система предупредит вас, прежде чем вы попытаетесь это сделать. Эта система извлечения и отправки всегда работает лучше, когда один разработчик обновляет одну ветку в одном удаленном репозитории, которым он владеет. Он выходит из строя, как только новый человек добавляет или меняет что-либо в пульте. Это то, что вызывает push-уведомления и сбои, пока все снова не синхронизируются с удаленным. Когда это будет сделано, разработчик сможет внести изменения, поскольку их код снова будет соответствовать удаленному. Но лучше использовать команду Git, когда есть много изменений или слияний веток и кода, отправляемых в удаленные репозитории.
Наконец, важно отметить, что людям, разрабатывающим в Git, почти всегда рекомендуется сначала создать новую локальную и удаленную ветку репо , прежде чем вносить изменения в программное обеспечение. В этом случае и имеет смысл, так как изменения кода почти всегда выполняются в изолированной ветке программного обеспечения одним разработчиком, который никогда не конфликтует с изменениями других разработчиков. Затем это объясняет, почему один разработчик обычно работает над своей собственной веткой, и в этом случае он отлично работает, может быстро отправлять/извлекать изменения, никогда не вызывает конфликтов кода и позволяет одному разработчику хранить копии своих окончательных локальных изменений. на ветке удаленного репо он подталкивает для последующего слияния с основными ветками, используя систему, описанную ниже.
Странный запрос на вытягивание
Последняя часть головоломки Git. A — это «вытягивание» с точки зрения удаленного репозитория, извлекающего в него код локального репо. Но это запрос , и изначально он физически ничего не извлекает и не изменяет, а также не нажимает и не объединяет какой-либо код. Это просто запрос, который вы отправляете в удаленное репо из локального репо, чтобы проверить код и, если они одобрят, перенести ваш код в свою удаленную копию.
В случае вы просите администраторов или владельцев удаленного репо загрузить ваши изменения кода или фиксации, просмотреть изменения фиксации вашего локального репо, а затем объединить ваши изменения кода с удаленным репо после их одобрения. Когда они одобряют ваши проверенные фиксации или изменения в локальном репо, они извлекают ваш код или ветку локального репо и объединяют его с веткой удаленного репо.
У удаленного репозитория есть администраторы или владельцы, которые контролируют критически важные ветки кода в удаленном репо, которые готовятся к работе. Им не нравится объединять изменения кода в эти более крупные ветки без какого-либо контроля над качеством кода. Когда вы делаете это, вы предупреждаете администратора или владельцев удаленных репозиториев о том, что у вас, как у локального разработчика, есть некоторая законченная ветвь кода, и вы хотите, чтобы они вручную вставили код вашего локального репо в код удаленного репо. Это то же самое, что и из локального репозитория в удаленное, но в этом случае требуется, чтобы он выполнялся в противоположном направлении ведущими владельцами удаленного репо. Это также требует ручной проверки кода и одобрения изменений владельцами удаленного репо.
Примечание. Чаще всего происходит слияние кода между двумя удаленными ветками репо , и обычно это затрагивает готовые ветки кода на удаленном сервере или устройстве, которые необходимо объединить в основную удаленную ветку, а не только локальные изменения фиксации. Опять же, не интуитивно, но вот!
Зачем вам нужен запрос на извлечение, если у вас есть команды Git для синхронизации и слияния кода? работают лучше, чем отправка, в сценариях, где очень много людей извлекают и отправляют огромные изменения в готовые ветки со слиянием в основные ветки удаленного репо и где большое количество кода может конфликтовать или добавлен код, который необходимо протестировать или просмотреть код, прежде чем переходить к основной выпуск или обновление базы кода.Pushа «Вытягивание» лучше работает для изолированных небольших веток, над которыми работают и делятся только один или два разработчика. Гораздо прощеpullи код между локальными и удаленными репозиториями, чем объединять массивные ветки сложных изменений удаленного репо в основные ветки удаленного репо.
Так что помните...
Используйте «Push» для обновления небольших веток, которыми вы управляете как локально, так и удаленно.
Используйте «Pull Request», чтобы люди из удаленного репозитория объединили ваши меньшие ветки со своими более крупными на удаленных серверах.
Так что мне нравится думать оpull requestsкак Master Push иpushкак локальный толчок. Хотелось бы, чтобы ребята из Git сделали имена для этих процессов более логичными и понятными. Это просто не интуитивно понятно!
оказываетсяpull requestэто также способ добавления уровня безопасности кода, который сначала запрашивает разрешение у администраторов или членов команды при объединении больших стеков кода в критические удаленные ветки верхнего уровня или слияния ветвей в проектах. Таким образом, он просит членов команды одобрить большие пакеты изменений кода локального репо и сначала фиксирует их, прежде чем они перетащат их в важные удаленные ветки репо.
Это служит для защиты обновлений кода до критических ветвей с предварительными проверками и утверждениями кода. Но это также позволяет множеству команд обновлять удаленные репозитории, чтобы приостанавливать изменения кода в более важных ветвях и слияниях до их тестирования, утверждения и т. д. Вот почему небольшие ветки кода, закрытые для разработчика, просто извлекают и отправляют изменения, но вместо этого более крупные слияния этих ветвей обычно блокируются от push-уведомлений с помощью запросов на вытягивание. Это более типично для готовых веток, использующих push-уведомления, которые затем объединяются в более крупные ветки вверх по дереву Git.
Выяснение этого заняло часы и часы исследований, даже после того, как я использовал Git в течение многих лет, поскольку в Интернете нет документации, объясняющей эту разницу.
Так что… всегда используйте процедуру фиксации-вытягивания-выталкивания при работе над собственными изменениями кода или разделами назначенных вам проектов. Сначала откройте репозитории, чтобы убедиться, что в вашем локальном репозитории есть все последние изменения, внесенные в него другими разработчиками. Зафиксируйте или сохраните все свои локальные изменения до и после извлечения, если хотите... это не имеет значения. Если есть конфликты, постарайтесь решить их локально. Тогда и только тогда сделайте все возможное, чтобы перезаписать удаленную копию своим локальным кодом. Ваши локальные и удаленные репозитории будут на 100 % синхронизированы в Git World!
Наконец, когда ваши локальные и удаленные ветки будут готовы, отправьте запрос на включение администратору git и попросите его обработать слияние вашей завершенной ветки удаленного репозитория.
Просто хочу добавить следующие пункты:
Йон не может толкать, пока вы не совершите, как мы используем git push отправить коммиты, сделанные в вашей локальной ветке, в удаленный репозиторий.
git push Команда принимает два аргумента:
Удаленное имя, например, originНазвание ветви, например, master
Например:
git push <REMOTENAME> <BRANCHNAME>
Очень грубая аналогия: если сравнить git commit чтобы сохранить отредактированный файл, затем git push будет копировать этот файл в другое место.
Пожалуйста, не вынимайте эту аналогию из этого контекста - фиксация и нажатие не что иное, как сохранение отредактированного файла и его копирование. Тем не менее, это должно быть только для сравнения.
Проще понять использование команд git add а также commit если вы представите, что файл журнала поддерживается в вашем хранилище на Github. Типовой файл журнала проекта для меня может выглядеть так:
---------------- Day 1 --------------------
Message: Completed Task A
Index of files changed: File1, File2
Message: Completed Task B
Index of files changed: File2, File3
-------------------------------------------
---------------- Day 2 --------------------
Message: Corrected typos
Index of files changed: File3, File1
-------------------------------------------
...
...
...and so on
Я обычно начинаю свой день с git pull запросить и закончить его git push запрос. Таким образом, все в дневной записи соответствует тому, что происходит между ними. В течение каждого дня я выполняю одну или несколько логических задач, которые требуют изменения нескольких файлов. Файлы, отредактированные во время этой задачи, перечислены в индексе.
Каждая из этих подзадач (Задача A и Задача B здесь) является отдельными коммитами. git add Команда добавляет файлы в список "Индекс измененных файлов". Этот процесс также называется постановкой и в действительности записывает измененные файлы и выполненные изменения. git commit Команда записывает / завершает изменения и соответствующий индексный список вместе с пользовательским сообщением, которое может быть использовано для дальнейшего использования.
Помните, что вы все еще изменяете только локальную копию своего хранилища, а не ту, что на Github. После этого, только когда вы делаете git push Сделайте все эти записанные изменения вместе с вашими индексными файлами для каждого коммита, войдите в основной репозиторий (на Github).
В качестве примера, чтобы получить вторую запись в этом воображаемом лог-файле, я бы сделал:
git pull
# Make changes to File3 and File4
git add File3 File4
# Verify changes, run tests etc..
git commit -m 'Corrected typos'
git push
В двух словах, git add а также git commit позволяет разбить изменения в главном репозитории на систематические логические подмены. Как уже отмечалось в других ответах и комментариях, у них, конечно, есть много других применений. Тем не менее, это один из наиболее распространенных способов использования Git, который является многоступенчатой системой контроля версий в отличие от других популярных систем, таких как Svn.
git commit - это не что иное, как официальное сохранение наших изменений, для каждого коммита, который мы даем сообщению коммита, как только мы закончим с коммитами, мы можем переместить его на удаленный компьютер, чтобы увидеть наши изменения глобально
это означает, что мы можем сделать множество коммитов, прежде чем мы отправим их на удаленный сервер (мы можем увидеть список произошедших коммитов и сообщения), git сохраняет каждый коммит с идентификатором коммита, который представляет собой 40-значный код
и я использую git push только тогда, когда я хотел увидеть свои изменения в удаленном режиме (там после того, как я проверю, работает ли мой код в jenkins)
Когда вы фиксируете свои изменения, вы сохраняете изменения как единый логический набор в вашем локальном репозитории. Вы можете сделать это несколько раз, не нажимая. Пока они не будут отправлены, они не покинут ваш локальный репозиторий, то есть в удаленном репозитории еще не будет этих наборов изменений, поэтому, когда другие люди извлекают из удаленного репозитория, ваши коммиты не будут извлечены.
Когда вы нажимаете, все коммиты, которые вы сделали в локальном репозитории, будут перенесены в удаленный репозиторий, поэтому, когда другие разработчики, которые используют этот удаленный репозиторий, извлекут, они перенесут ваши изменения в свои локальные репозитории, проверьте команды Git и шпаргалку здесь
С точки зрения непрофессионала, git commit это шаг до git push вы запускаете их в таком порядке, чтобы успешно git ваш файл на github.
git commit это зафиксировать файлы, которые находятся в локальном репо. git push это быстрая перемотка слияния главной ветви локальной стороны с удаленной главной веткой. Но слияние не всегда будет успешным. Если появляется отказ, вы должны pull так что вы можете сделать успешный git push,
Ну, в основном git commit помещает ваши изменения в локальное хранилище, а git push отправляет ваши изменения в удаленное местоположение. Поскольку git - это распределенная система управления версиями, разница в том, что commit будет фиксировать изменения в вашем локальном репозитории, тогда как push будет передавать изменения до удаленного репо
источникGoogle
http://gitref.org/basic/ эта ссылка тоже будет очень полезна