Como posso verificar um Git remoto?

Sidenote: com Git moderno(>= 1.6.6), Você é capaz de usar apenas

git checkout test

(note - se que é' teste 'não' Origem/Teste') realizar magia DWIM-mery e criar um' teste 'local para si, para o qual a montante seria'Origem/Teste' do ramo de localização remota.

O * (no branch) em git branch significa que estás num ramo sem nome, no estado chamado "cabeça separada" (pontos de cabeça directamente para cometer, e não é uma referência simbólica a algum ramo local). Se tiver feito alguns commits neste ramo sem nome, poderá sempre criar um ramo local fora da persistência actual:

git checkout -b test HEAD

Neste caso, provavelmente quer criar um ramo local test que esteja a seguir o ramo remoto test:

$ git branch test origin/test

Nas versões anteriores de git, você precisava de uma opção explícita --track, mas esta é a opção por omissão agora quando você está ramificando de um ramo remoto.

Resposta aceite {[10] } não funciona para ti?

Embora a primeira resposta seleccionada seja tecnicamente correcta , existe a possibilidade de ainda não ter recuperado todos os objectos e ref do repositório remoto. Se for esse o caso, você receberá o seguinte erro:

$ git checkout -b remote_branch origin/remote_branch

Fatal: checkout git: actualizar os caminhos é incompatível com a mudança de ramos.
Pretendia obter a 'origin/remote_branch' que não pode ser resolvida como comprometer?

Solução

Se você receber esta mensagem, você deve primeiro fazer um git fetch origin onde origin é o nome do repositório remoto, antes da execução git checkout remote_branch. Aqui está um exemplo completo com respostas:

$ git fetch origin
remote: Counting objects: 140, done.
remote: Compressing objects: 100% (30/30), done.
remote: Total 69 (delta 36), reused 66 (delta 33)
Unpacking objects: 100% (69/69), done.
From https://github.com/githubuser/repo-name
   e6ef1e0..5029161  develop    -> origin/develop
 * [new branch]      demo       -> origin/demo
   d80f8d7..359eab0  master     -> origin/master

$ git checkout demo
Branch demo set up to track remote branch demo from origin.
Switched to a new branch 'demo'

Como podem ver, ao executar {[[2]} recuperámos todos os ramos remotos que ainda não estávamos preparados para localizar na nossa máquina local. A partir daí, uma vez que agora temos um árbitro para o ramo remoto, podemos simplesmente correr git checkout remote_branch e vamos ganhar os benefícios de rastreamento remoto.

git fetch origin 'remote_branch':'local_branch_name'

Isto irá obter o ramo remoto e criar um novo ramo local (se não existir já) com o nome local_branch_name e seguir o remoto nele.

Isto irá DWIM para uma origem remota sem nome (documentação):

$ git checkout -t remote_name/remote_branch

Para adicionar um novo remoto, terá de fazer o seguinte primeiro:

$ git remote add remote_name location_of_remote
$ git fetch remote_name

O primeiro diz ao Git que o remoto existe, o segundo recebe os commits.

Utilizar:

git checkout -b <BRANCH-NAME> <REMOTE-NAME>/<BRANCH-NAME>

Ok , a resposta é fácil... Você basicamente vê o ramo, mas você não tem uma cópia local ainda!...

Tens de fetch o ramo...

Você pode simplesmente obter e, em seguida, obter para o ramo, use o comando de uma linha abaixo para fazer isso:

git fetch && git checkout test

Eu também criei a imagem abaixo para você compartilhar as diferenças, olhar para como fetch funciona e também como é diferente de pull:

Para clonar um repositório Git, Faça:

git clone <either ssh url /http url>

O comando acima verifica todos os ramos, mas apenas o ramo master será inicializado. Se quiser verificar os outros ramos, Faça:

git checkout -t origin/future_branch (for example)

Este comando verifica o ramo remoto, e o nome do seu ramo local será o mesmo que o ramo remoto.

Se quiser sobrepor o nome da sua sucursal local ao sair:

git checkout -t -b enhancement origin/future_branch

Agora o nome do seu ramo local é enhancement, mas o nome do seu ramo remoto é future_branch.

Documentação

Podes tentar

git fetch remote
git checkout --track -b local_branch_name origin/branch_name

Ou

git fetch
git checkout -b local_branch_name origin/branch_name

Primeiro, tens de fazer:

git fetch # Se você não sabe sobre o nome do branch

git fetch origin branch_name

Em segundo lugar, pode verificar a ramificação remota no seu local até:

git checkout -b branch_name origin/branch_name

-b irá criar uma nova ramificação em nome indicado a partir da sua ramificação remota seleccionada.

Comandos

git fetch --all
git checkout -b <ur_new_local_branch_name> origin/<Remote_Branch_Name>

São iguais a

 git fetch --all

E depois

 git checkout -b fixes_for_dev origin/development

Ambos irão criar um latest fixes_for_dev de development

Uso o seguinte comando:

git checkout --track origin/other_remote_branch

Se o ramo está em algo diferente do origin remoto, gosto de fazer o seguinte:

$ git fetch
$ git checkout -b second/next upstream/next

Isto irá verificar o ramo next No upstream remoto para um ramo local chamado second/next. O que significa que se você já tem um ramo local chamado next ele não vai entrar em conflito.

$ git branch -a
* second/next
  remotes/origin/next
  remotes/upstream/next

git fetch && git checkout your-branch-name

git branch -r diz que o nome do objeto é inválido, porque esse nome do branch não está na lista de branch local do Git. Actualizar a sua lista de ramificações locais a partir da origem com:

git remote update

Eu acredito git fetch puxa para dentro todos os ramos remotos, que não é o que o cartaz original queria.

git checkout -b feature/branch remotes/origin/feature/branch

O comando git remote show <origin name> irá listar todos os ramos (incluindo os ramos não rastreados). Então você pode encontrar o nome do ramo remoto que você precisa obter.

Exemplo:

$ git remote show origin

Use estes passos para obter ramificações remotas:

git fetch <origin name> <remote branch name>:<local branch name>
git checkout <local branch name > (local branch name should the name that you given fetching)

Exemplo:

$ git fetch origin test:test
$ git checkout test

Teste de caixa de Git que não faz nada

Does nothing não é igual a {[[1]}, por isso, quando escrever 'git checkout test' no seu terminal e carregar em enter key, não aparece nenhuma mensagem e não ocorre nenhum erro. Estou certo?

A causa é que existe um ficheiro (ou pasta) chamado 'test' na sua árvore de trabalho.

Quando git checkout xxx processado,

1. Git olha para xxx como um nome de ramo no início, mas não há nenhum ramo chamado teste.
2. Então o Git pensa que xxx é um caminho, e felizmente (ou infelizmente), existe um ficheiro chamado test. Então git checkout xxx significa eliminar qualquer modificação no ficheiro xxx.
3. se também não existe um ficheiro chamado xxx, Então o Git irá tentar criar o xxx de acordo com algumas regras. Uma das regras é criar um ramo chamado xxx Se remotes/origin/xxx existe.

Pode começar a seguir todos os ramos remotos com o seguinte programa Bash:

#!/bin/bash
git fetch --all
for branch in `git branch -r --format="%(refname:short)" | sed 's/origin\///'`
  do git branch -f --track "$branch" "origin/$branch"
done

Aqui está também uma versão de linha única:

git fetch --all; for branch in `git branch -r --format="%(refname:short)" | sed 's/origin\///'`; do git branch --track "$branch" "origin/$branch" ; done ;

Por favor, siga o comando para criar uma pasta vazia. Indique isso e use este comando:

saifurs-Mini:YO-iOS saifurrahman$ git clone your_project_url
Cloning into 'iPhoneV1'...
remote: Counting objects: 34230, done.
remote: Compressing objects: 100% (24028/24028), done.
remote: Total 34230 (delta 22212), reused 15340 (delta 9324)
Receiving objects: 100% (34230/34230), 202.53 MiB | 294.00 KiB/s, done.
Resolving deltas: 100% (22212/22212), done.
Checking connectivity... done.
saifurs-Mini:YO-iOS saifurrahman$ cd iPhoneV1/
saifurs-Mini:iPhoneV1 saifurrahman$ git checkout 1_4_0_content_discovery
Branch 1_4_0_content_discovery set up to track remote branch 1_4_0_content_discovery from origin.
Switched to a new branch '1_4_0_content_discovery'

Para obter ramos recém-criados

git fetch

Para mudar para outro ramo

git checkout BranchName

Obter a origem e verificar o ramo.

git fetch origin && git checkout branch_name 

Basta executar git checkout com o nome do ramo remoto. O Git irá criar automaticamente um ramo local que segue o remoto:

git fetch
git checkout test

No entanto, se esse nome do ramo for encontrado em mais de um remoto, isso não vai funcionar como o Git não sabe qual usar. Nesse caso, pode utilizar:

git checkout --track origin/test

Ou

git checkout -b test origin/test

Em 2.19, git aprendeu a checkout.defaultRemote configuração, que especifica um remoto para o default ao resolver tal ambiguidade.