Git Push e Pull Dicas e Truques

Empurrando para um controle remoto por padrão, envia para um ramo com o mesmo nome, por exemplo

se você está no ramo dev

$ git checkout -b dev 
 Switched to a new branch 'dev'

E você tem esses controles remotos

$ git remote 
 codebase 
 origin

Para ver quais controles remotos estão se referindo a você pode adicionar -v sinalizador

Fazer um push aqui irá empurrar para o controle remoto com o mesmo nome de ramificação

$ git push codebase 
 Total 0 (delta 0), reused 0 (delta 0) 
 remote: 
 remote: To create a merge request for dev, visit: 
 remote: https://codebase.your-gitlab.com/infra/cmp_configs_clone/merge_requests/new?merge_request%5Bsource_branch%5D=dev 
 remote: 
 To https://codebase.your-gitlab.com/infra/cmp_configs_clone.git 
 * [new branch] dev -> dev

Como você vê, ele empurra para uma ramificação chamada dev também no lado remoto. Se o ramo não existir no lado remoto, ele será criado automaticamente.

Se você está no dev branch localmente e você tenta empurrar para outro branch, digamos, master você receberá esta mensagem sem push real

$ git branch 
 * dev 
 master 
 customer1/add-ext-js-packages 
 customer1/batch_somefunc 
 customer1/desktop-upgrade 
 customer1/shrink-somefunc/req/PROJECT-726 
 customer1/upgrade-and-add-elastic-desktop 
 customer2/local-auth 
 customer3/somelib-pipeline-fix 
 $ git push codebase master 
 Everything up-to-date

Configurando o fluxo ascendente

Quando você empurra você tem a opção de configurar seu upstream. Upstream nesse contexto significa seu rastreamento remoto padrão.

A sintaxe:

 git push -u <remote> <branch>

Normalmente você quer que o nome da sua ramificação no local seja o mesmo nome da ramificação no mestre

Por exemplo:

 git push -u origem feat / new-feature-toggle

Depois de configurar seu upstream, você só precisa fazer

 git push

E ele saberá automaticamente a qual ramificação remota se refere. Upstreams são feitos por ramificação.

Para poder verificar a qual upstream você está se referindo atualmente para executar:

 git branch -avv

Observe que o sinalizador -v único -v só lhe dará as mensagens de confirmação, não incluindo o ramo de upstream.

Empurrando para um ramo diferente

Se você quiser empurrar para o mesmo controle remoto, mas um ramo diferente. Use a seguinte sintaxe;

git push <branch with new changes>:<branch you are pushing to>

Por exemplo:

git push origin dev:master

Isso empurra a ramificação dev local para o branch master origem

Puxando de um ramo diferente

Isso está usando a mesma sintaxe para empurrar

git pull origin master:dev

Isso atualiza sua ramificação dev local usando a ramificação master origem remota

Empurre para um ramo local

Verifique as filiais remotas e locais

$ git branch -av 
 * master 
 customer1/add-ext-js-packages 
 customer1/batch_somefunc 
 customer1/desktop-upgrade 
 customer1/shrink-somefunc/req/PROJECT-726

Empurre as alterações do mestre para -> customer1 / add-ext-js-packages

$ git push --force . master:customer1/add-ext-js-packages 
 Total 0 (delta 0), reused 0 (delta 0) 
 To . 
 + 3e205c3...31f2769 master -> customer1/add-ext-js-packages (forced update)

Observe o . onde um controle remoto deveria estar. também ramo para ramificação empurrando é branch1:branch2

A sintaxe é:

git push . <branch with new changes>:<branch you are pushing to>

Da mesma forma, é possível puxar de uma filial local para outra filial local

A sintaxe é

git checkout <branch you want updated> 
 git pull . <branch you want the updates>

Excluir um ramo remoto pressionando

Há um fato menos conhecido de que você pode excluir ramificações remotas, empurrando-as.

A sintaxe para excluir essas ramificações é.

git push origin :<branch>

Por exemplo:

$ git branch -av 
 * dev 
 master 
 customer1/add-ext-js-packages 
 customer1/batch_somefunc 
 customer1/desktop-upgrade 
 customer1/shrink-somefunc/req/PROJECT-726 
 $ git push codebase :dev 
 Username for 'https://codebase.your-gitlab.com': kenichi.shibata 
 Password for 'https://kenichi.shibata@codebase.your-gitlab.com': 
 To https://codebase.your-gitlab.com/infra/cmp_configs_clone.git 
 - [deleted] dev
$ git branch -av 
 * dev 
 master 
 customer1/add-ext-js-packages 
 customer1/batch_somefunc 
 customer1/desktop-upgrade 
 customer1/shrink-somefunc/req/PROJECT-726

Como você pode ver, ele excluiu o ramo dev no lado remoto.

Você também pode pressionar vários de uma só vez

$ git push codebase :customer1/add-ext-js-packages :customer1/batch_somefunc :customer1/shrink-somefunc/req/PROJECT-726 
 Counting objects: 14, done. 
 Delta compression using up to 56 threads. 
 Compressing objects: 100% (11/11), done. 
 Writing objects: 100% (14/14), 1.15 KiB | 0 bytes/s, done. 
 Total 14 (delta 8), reused 3 (delta 1) 
 remote: 
 remote: To create a merge request for customer1/upgrade-and-add-elastic-desktop, visit: 
 remote: https://codebase.your-gitlab.com/infra/cmp_configs_clone/merge_requests/new? merge_request%5Bsource_branch%5D=customer1%2Fupgrade-and-add-elastic-desktop 
 remote: 
 To https://codebase.your-gitlab.com/infra/cmp_configs_clone.git 
 - [deleted] customer1/add-ext-js-packages 
 - [deleted] customer1/batch_somefunc 
 - [deleted] customer1/shrink-somefunc/req/PROJECT-726

Para outros desenvolvedores que rastreiam este controle remoto, você deve pedir para eles pull ou fetch --prune depois, faça o branch -d em sua máquina local para deletar o branch local.

Empurrando uma cópia local (não remota) do repositório

Primeiro crie um diretório local e faça o git init

$ mkdir test 
 $ cd test 
 $ ls 
 $ git init 
 Initialised empty Git repository in /home/shibata100012/company_workspace/cmp_core/cmp/test/.git/

Em seguida, volte ao seu repo e adicione o diretório de teste como seu controle remoto (local)

$ git remote add local ../test 
 $ git remote -v 
 codebase https://codebase.your-gitlab.com/infra/cmp_configs_clone.git (fetch) 
 codebase https://codebase.your-gitlab.com/infra/cmp_configs_clone.git (push) 
 local ../test (fetch) 
 local ../test (push) 
 origin git@git.wsq.io:cmp_core/cmp_configs (fetch) 
 origin git@git.wsq.io:cmp_core/cmp_configs (push)

Finalmente, faça um push para esse remoto (local)

$ git push local 
 Counting objects: 14191, done. 
 Delta compression using up to 56 threads. 
 Compressing objects: 100% (5100/5100), done. 
 Writing objects: 100% (14191/14191), 1.41 MiB | 0 bytes/s, done. 
 Total 14191 (delta 6243), reused 14007 (delta 6097) 
 To ../test 
 * [new branch] dev -> dev

Puxando sem mesclar confirmações

Na maior parte do tempo, quando fazemos o git pull se tivermos um controle remoto com um commit, não teremos padrões locais do git para criar merge commits . Merge commits são commits aparentemente vazios e que só adicionam o commit no entanto, na realidade, se você olhar mais de perto e adicionar -m flag ao logar, você pode realmente ver que estes commits fazem mais algumas vezes. Isso pode causar confusão se você estiver tentando rastrear uma alteração que esteja em consolidação de mesclagem, especialmente se estiver mesclando confirmações manualmente.

Minha recomendação é acabar com os commits de merge e usar rebase em vez de merge.

A maioria dos desenvolvedores usa essa abordagem ao rebasar um clone local contra um controle remoto.

$ git fetch <remotename> 
 $ git rebase <localbranch> <remotename>/<branch>

Na maioria das vezes, funciona bem. No entanto, se você está escrevendo toneladas de commits e tem pouca paciência para buscar e rebasing manualmente, você pode fazer:

$ git pull --rebase

Isso fará automaticamente a busca e o rebase, em vez da busca e mesclagem do comportamento de extração padrão. Então você pode resolver os conflitos, se houver algum.

Ou se você é como eu e gosta de atalhos, pode adicioná-lo aos seus aliases do git

 [alias] 
 pullr = pull --rebase

Agora você só precisa fazer

 git pullr

Se você estiver procurando por mais conveniente aliases git https://kenichishibata.net/my-gitconfig-with-all-the-bells-and-whistles-9479530f12af