Как работают репо (SVN, GIT)? - PullRequest
       54

Как работают репо (SVN, GIT)?

6 голосов
/ 19 февраля 2010

Я читаю ТАК почти каждый день, и в основном есть ветка об управлении источниками. У меня есть несколько вопросов. Я собираюсь использовать SVN в качестве примера.

1) Есть команда (малое, большое дело). Утром все проверяют код, чтобы начать работать. В полдень человек А совершает, а человек Б все еще работает над этим. Что происходит, когда человек В совершает? как человек Б узнает, что есть обновленный файл?

2) Я предполагаю, что ответ на первый вопрос «запустить команду обновления, которая сообщает вам», хорошо, так что человек Б узнает, что файл, с которым они работали все утро, изменился. Когда они видят обновленный файл, кажется, что человек А перезаписал файл для повышения производительности. Что делает человек Б? Кажется, целый день был пустой тратой времени. Или, если они передадут свою версию, это пустая трата времени человека А?

3) Что такое филиалы?

спасибо, и если кто-нибудь знает непрофессионалы с выражениями pdf или чем-то, что объясняет это, это было бы замечательно.

Ответы [ 13 ]

5 голосов
/ 19 февраля 2010

1 && 2)
SVN : Когда B пытается выполнить фиксацию, возникает ошибка, говорящая о том, что у него нет последней версии кода. Ему нужно будет сделать svn update и объединить изменения, которые человек А сделал со своими собственными. См. Как разрешить конфликты SVN .

GIT : Поскольку у вас есть собственный локальный репозиторий, вы можете свободно фиксировать. Когда вы вносите изменения (git push) в удаленный репозиторий, вы должны объединить их. См. Разрешение конфликтов слияния в GIT

.

3) Вики-страница ветвления

5 голосов
/ 19 февраля 2010

1) Предполагается, что существует центральный репозиторий (как в случае с SVN и CVS, но не обязательно Git, Bazaar, Mercurial и т. Д.), И человек A фиксирует (а затем нажимает коммит, который просто передает различия и отправлять сообщения в центральное хранилище), лицо B должно обновить свою копию вручную.

2) В этом случае, да, кто-то будет тратить свое время впустую. Системы SCM (Source Control Management) ничего не могут сделать, чтобы вылечить команду от организационных проблем. Это конечно крайний случай. В большинстве случаев будут существовать только незначительные различия (здесь определение незначительных заключается в том, что какой-либо конкретный файл не должен быть полностью или частично переписан) в каждом коммите, и если эти модификации не затрагивают раздел, над которым работает человек B, программное обеспечение SCM сможет объединить эти коммиты в один рабочий файл.

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

3) Ветвь - это коммит строка истории :

feature->    /R-S-T
master->  A-B-C-D-E-F
bugfix->       \J-K-L-M

Здесь feature, master и bugfix - ветви, а буквы - конкретные коммиты. Для ветви master самая новая фиксация (самая последняя версия каждого файла) - F. С другой стороны, новейшая фиксация ветки feature - это T и , она включает в себя только коммиты A и B из ветви master. Любые изменения, сделанные в коммитах C, D, E и F, не включаются в эту конкретную ветку. Это может быть переписано как:

feature-> A-B-R-S-T
master->  A-B-C-D-E-F
bugfix->  A-B-C-J-K-L-M

Теперь ветви важны для разделения рабочего процесса на разные части и сосредоточения работы на определенных частях. Представьте, что в ветви master находится стабильный код, и представьте, что мы реализуем новую функцию в ветви feature, которая еще не готова к выпуску. Теперь представьте, что система плагинов изменилась, и важные исправления зафиксированы в ветке master, и, поскольку реализуемая мной функция опирается на систему плагинов, мне нужно передать эти коммиты (с C до F). ) к филиалу feature. Для этого вы вводите команду rebase (я здесь использую Git в качестве руководства) для программного обеспечения SCM, так что:

feature->            /R-S-T
master->  A-B-C-D-E-F
bugfix->       \J-K-L-M

Итак, вы закончили всю работу над веткой feature. Чтобы перевести коммиты R, S и T в master, вы вводите команду merge:

master->  A-B-C-D-E-F-R-S-T
bugfix->       \J-K-L-M

Это ветка основы . Есть много других интересных вещей, которые вы можете сделать с ветками. Надеюсь, что это не слишком долго и помогает: P

2 голосов
/ 19 февраля 2010

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

1 голос
/ 19 февраля 2010
  1. Пользователь B знает, что есть изменение, когда он запускает обновление или пытается зафиксировать на сервере.
  2. Этот процесс называется слиянием. Большинство систем очень умны и пытаются объединиться для вас. Однако иногда возникают конфликты, и в этом случае человека информируют и просят разрешить конфликт. Это может произойти, если человек A и B изменят одну и ту же строку кода в одном файле.
1 голос
/ 19 февраля 2010

1 & 2 зависят от того, какой элемент управления исходным кодом вы используете, но необходимо выполнить какое-то слияние.А ветки - это версии кода, которые были разветвлены из магистрали (основная версия).

1 голос
/ 19 февраля 2010
  1. Человек B может выполнить проверку на наличие изменений из SVN. Я на самом деле уверен, что есть какой-то инструмент, который проверяет изменения каждые несколько минут и предупреждает вас о них.
  2. Они объединяют изменения вместе.
  3. По сути, когда вы вносите ломающееся изменение, вы хотите взять, как ваша рабочая копия, и изменить ее вне рабочей копии всех остальных (ствола). Итак, вы делаете ветку. Таким образом, другие люди могут работать над веткой, если они хотят, но в основном хорошо, что они могут работать в магистрали, не беспокоясь об этом, и затем вы объединяете ветку, когда закончите с этим критическим изменением
0 голосов
/ 19 февраля 2010

Я не могу рекомендовать достаточно Source Control HOWTO Эрика Синка.Он даст вам ответы, которые вы ищете, и хорошее понимание управления источниками в целом.

0 голосов
/ 19 февраля 2010
  1. В SVN B узнает об изменении A, когда B пытается обновить свою копию или регистрацию. В GIT он узнает, когда он пытается вставить изменения в свой локальный репозиторий или отправить свои изменения в мастер. (На самом деле, я не знаю, GIT, поэтому я продолжаю то, что я знаю о Mercurial.)

  2. В таком случае у вас есть проблемы, независимо от того, что вы делаете, и независимо от того, какой тип управления версиями вы используете. Единственное преимущество блокировки VCS состоит в том, что это позволит A или B узнать, что другой работает над программой, но это можно сделать другими способами. Нужно сделать так, чтобы все знали о происходящих больших изменениях и координировали свои действия оттуда. Однако на практике это случается не часто. В большинстве случаев, если A и B работают с файлом, их изменения будут объединены легко и правильно.

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

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

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

0 голосов
/ 19 февраля 2010

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

Хорошо прочитано: -)

0 голосов
/ 19 февраля 2010

2) На этом этапе B должен объединить изменения, сделанные A, с его собственными изменениями.Если они работали над различными частями кода в файле, инструмент управления исходным кодом обычно делает это автоматически.Если их изменения перекрываются, это может стать довольно одиозной задачей, но это случается редко.

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

...