Зачем использовать rebase, если он заставляет вас оставаться локальным?

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

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

Таким образом, правильный способ использования переустановки - это совершение только локально. Но, по крайней мере, в моем кратком опыте это нежелательно:

что, если ваш компьютер украден?
что, если вы потеряете данные из-за сбоя диска?
что делать, если вам нужно работать в двух местах (например, этот человек)

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

В течение этого периода происходят изменения в мастер. Но другой человек уже основан на удаленной ветки, поэтому он должен либо использовать слияние, либо rebase и force-push (что, опять же, может навредить вещам, если другие люди основывали свои ветки на этом тем временем).

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

Итак, использует "rebase" хороший способ пойти в этих случаях, или слияние (с дополнительными "коммитами" ) является более безопасным и более простым вариантом?

Ответ 1

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

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

Когда мы сливаемся, мы делаем две вещи: мы перестраиваем верх над master, а затем сливаемся с --no-ff. Это создает пузырь слияния с пустым левым путем, который (1) группирует вместе, и (2) совершает коммиты, которые попадают непосредственно в мастер-статус (иногда это допустимо - исправления, небольшие улучшения, опечатки, пробелы и т.д.).

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

Разновидности функций не являются локальными.
История сохраняется довольно чистой.
Точные коммиты группируются через пузырь слияния.
Силовое нажатие обычно не является проблемой, потому что (1) это случается редко и (2) вы либо работаете в одиночку, либо не более в паре.

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

Ответ 2

Точно сформулированное правило: "не переустанавливайте ветвь, которая может быть базой для другой ветки". Обычно вы можете легко достичь этого, только не публикуя свою ветку - никто ее не видит, поэтому никто не сможет ее использовать. Поэтому почему "не следует использовать, если вы нажали". Но в некоторых ситуациях это приемлемый рабочий процесс - rebase/push/rebase/push/... Вам просто нужно как-то согласиться с другими, что они не используют подталкиваемую ветку для своих нужд или явно согласны с ротой, которая перегружает/толкает следующий (в случае болезни/праздника/и т.д.), или если вы просто работаете из нескольких мест (надеюсь, вы в какой-то момент согласитесь с собой).

Кстати, существует опция --force-with-lease, чтобы избежать некоторого вреда, который может быть вызван перетасованными перестановками.

Ответ 3

Вы можете безопасно использовать rebase для обновления своей локальной ветки из той же удаленной отслеживаемой ветки (например, git pull --rebase), тогда как, как вы сказали, лучше использовать слияние, когда вы работаете в "разделяемой" ветке с другими сотрудниками, и вы не хотите переписывать удаленную историю (используя git push -force).

Таким образом, в зависимости от вашего рабочего процесса git из-за распределенного характера git, если вы предпочитаете, чтобы переустановка слияния предпочтительнее использовать отдельную ветвь (или когда-либо отдельную репо, например, вилки github), для нажмите свои изменения и, наконец, объедините их в ветку назначения.

Ответ 4

Я склонен соглашаться с консервативным правилом, чтобы не пересобирать толкаемые ветки. Как указывалось другими ответами, это не обязательно проблема, а опция --force-with-lease устраняет большую боль. Тем не менее консервативная стратегия имеет два преимущества:

Легко запомнить, что нет ifs и buts, вы даже можете обеспечить его соблюдением, запретив push --force.
Вы всегда в безопасности - возможно, кто-то работал над вашей веткой, и вы не знали об этом.

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

$ git checkout -b my_branch/WIP/01
... do some work, add some commits ...
$ git push
... notice that you want to clean up your history ...
$ git checkout -b my_branch/WIP/02
$ git rebase ...
$ git push

Таким образом, если кто-то полагался на вашу ранее опубликованную работу, она все еще существует, история воспроизводима и нет push --force.

Недостатком этого подхода является то, что другим людям, которые работали над my_branch/WIP/01, приходится вручную вишнево-отбирать свою работу в последней ветке.