Alguém empurrou um ramo chamado testcom git push origin testa um repositório compartilhado. Eu posso ver o ramo com git branch -r.

Agora estou tentando verificar o testramo remoto .

Eu tentei:

• git checkout test que não faz nada

• git checkout origin/testdá * (no branch). O que é confuso. Como posso estar no "sem ramificação"?

Como faço para verificar uma ramificação remota do Git?

Atualizar

A resposta de Jakub realmente melhora isso. Nas versões Git ≥ 1.6.6, com apenas um controle remoto, você pode apenas fazer:

git fetch
git checkout test

Como o usuário masukomi aponta em um comentário, git checkout testNÃO funcionará no git moderno se você tiver vários controles remotos. Nesse caso, use

git checkout -b test <name of remote>/test

ou a taquigrafia

git checkout -t <name of remote>/test

Resposta antiga

Antes de começar a trabalhar localmente em uma ramificação remota, é necessário buscá-lo conforme descrito nas respostas abaixo.

Para buscar uma ramificação, basta:

git fetch origin

Isso buscará todas as ramificações remotas para você. Você pode ver as agências disponíveis para checkout com:

git branch -v -a

Com as filiais remotas em mãos, agora você precisa verificar a filial em que está interessado, fornecendo uma cópia de trabalho local:

git checkout -b test origin/test

Nota: Com o moderno Git (> = 1.6.6 ), você pode usar apenas

git checkout test

(observe que é 'teste' e não 'origem / teste') executar uma mágica mágica de DWIM e criar um 'teste' de ramificação local para você, para o qual upstream seria 'origem / teste' de ramificação de rastreamento remoto.

A saída * (no branch)in git branchsignifica que você está em uma ramificação sem nome, no chamado estado "desanexado HEAD" (HEAD aponta diretamente para confirmação, e não é uma referência simbólica a alguma ramificação local). Se você fez algumas confirmações nesta ramificação sem nome, sempre pode criar ramificação local com a confirmação atual:

git checkout -b test HEAD

** EDIT (pelo editor, não autor) **

Encontrei um comentário enterrado abaixo, que parece modernizar esta resposta:

@Dennis: git checkout, por exemplo, resultados de origem / teste do git checkout em HEAD desanexado / ramificação sem nome, enquanto teste de git checkout ou git checkout -b teste de origem / resultados do teste no teste de ramificação local (com origem / teste de ramificação de rastreamento remoto como upstream) ) - Jakub Narębski 9 / jan / 14 às 8:17

ênfase em git checkout origin/test

Nesse caso, você provavelmente deseja criar uma testfilial local que esteja rastreando a testfilial remota :

$ git branch test origin/test

Nas versões anteriores git, você precisava de uma --trackopção explícita , mas esse é o padrão agora quando você está ramificando uma ramificação remota.

A resposta aceita não está funcionando para você?

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

$ git checkout -b remote_branch origin/remote_branch

fatal: git checkout: atualizar caminhos é incompatível com a alternância de ramificações.
Você pretendia fazer checkout 'origin / remote_branch' que não pode ser resolvido como confirmação?

Solução

Se você receber esta mensagem, primeiro faça um git fetch originwhere 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 você pode ver, a execução git fetch originrecuperou quaisquer ramificações remotas que ainda não estavam configuradas para rastrear em nossa máquina local. A partir daí, como agora temos uma referência ao ramo remoto, podemos simplesmente executar git checkout remote_branche obteremos os benefícios do rastreamento remoto.

Eu tentei a solução acima, mas não funcionou. Tente isso, funciona:

git fetch origin 'remote_branch':'local_branch_name'

Isso buscará a ramificação remota e criará uma nova ramificação local (se já não existir) com o nome local_branch_namee rastreará a remota nela.

Isso fará o DWIM para uma origem remota não nomeada ( documentação ):

$ git checkout -t remote_name/remote_branch

Para adicionar um novo controle remoto, faça o seguinte primeiro:

$ git remote add remote_name location_of_remote
$ git fetch remote_name

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

Usar:

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

Outras respostas não funcionam com o Git moderno no meu caso benigno. Pode ser necessário puxar primeiro se o ramo remoto for novo, mas eu não verifiquei esse caso.

OK , a resposta é fácil ... Você basicamente vê a filial, mas ainda não possui uma cópia local! ...

Você precisa fetchdo ramo ...

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

git fetch && git checkout test

Também criei a imagem abaixo para você compartilhar as diferenças, ver como fetchfunciona e também como é diferente pull:

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

git clone <either ssh url /http url>

O comando acima faz check-out de todas as ramificações, mas somente a masterramificação será inicializada. Se você quiser fazer check-out dos outros ramos, faça:

git checkout -t origin/future_branch (for example)

Este comando faz check-out da filial remota e o nome da sua filial local será o mesmo da filial remota.

Se você deseja substituir o nome da sua filial local na finalização da compra:

git checkout -t -b enhancement origin/future_branch

Agora, o nome da sua filial local é enhancement, mas o nome da sua filial remota é 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, você precisa fazer:

git fetch # Se você não souber o nome da filial

git fetch origin branch_name

Segundo, você pode verificar a filial remota no seu local:

git checkout -b branch_name origin/branch_name

-b criará uma nova ramificação no nome especificado a partir da ramificação remota selecionada.

Eu uso o seguinte comando:

git checkout --track origin/other_remote_branch

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 criarão um latest fixes_for_devdedevelopment

Se a ramificação estiver em algo diferente do origincontrole remoto, eu gosto de fazer o seguinte:

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

Isso fará o checkout da nextfilial no upstreamcontrole remoto para uma filial local chamada second/next. O que significa que, se você já tiver um ramo local chamado next, ele não entrará em conflito.

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

git fetch && git checkout your-branch-name

nenhuma dessas respostas funcionou para mim. isso funcionou:

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

Eu estava preso em uma situação vendo error: pathspec 'desired-branch' did not match any file(s) known to git.todas as sugestões acima. Estou no git versão 1.8.3.1.

Então, isso funcionou para mim :

git fetch origin desired-branch
git checkout -b desired-branch FETCH_HEAD

A explicação por trás disso é que notei que, ao buscar a ramificação remota, ela foi buscada em FETCH_HEAD:

$ git fetch origin desired-branch
From github.com:MYTEAM/my-repo
    * branch            desired-branch -> FETCH_HEAD

Simplesmente execute git checkoutcom o nome da ramificação remota. O Git criará automaticamente uma ramificação local que rastreia a ramificação remota:

git fetch
git checkout test

No entanto, se esse nome de filial for encontrado em mais de um controle remoto, isso não funcionará, pois o Git não sabe qual usar. Nesse caso, você pode usar:

git checkout --track origin/test

ou

git checkout -b test origin/test

Na 2.19 , o Git aprendeu a checkout.defaultRemoteconfiguração, que especifica um controle remoto para o padrão ao resolver essa ambiguidade.

git branch -rdiz que o nome do objeto é inválido, porque esse nome não está na lista de ramificações locais do Git. Atualize sua lista de agências locais da origem com:

git remote update

E tente verificar novamente sua ramificação remota.

Isso funcionou para mim.

Acredito que git fetchatrai todos os ramos remotos, o que não é o que o pôster original queria.

O git remote show <origin name>comando listará todas as ramificações (incluindo ramificações não rastreadas). Em seguida, você pode encontrar o nome da filial remota que precisa buscar.

Exemplo:

$ git remote show origin

Siga estas etapas para buscar 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

Busque no controle remoto e faça o checkout da filial.

git fetch <remote_name> && git checkout <branch_name> 

Por exemplo:

origem de busca git && recurso de check-out git / XYZ-1234-Add-alertas

Outros caras e moças dão as soluções, mas talvez eu possa lhe dizer o porquê.

teste de checkout git que não faz nada

Does nothingnão é igual doesn't work, então acho que quando você digita 'git checkout test' no seu terminal e pressiona a tecla Enter, nenhuma mensagem aparece e nenhum erro ocorre. Estou certo?

Se a resposta for sim, posso lhe dizer a causa.

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

Quando git checkout xxxanalisado,

1. O Git aparece xxxcomo um nome de filial no início, mas não existe nenhuma filial chamada teste.
2. Então o Git pensa que xxxé um caminho e, felizmente (ou infelizmente), existe um arquivo chamado test. Então, git checkout xxxsignifica descartar qualquer modificação no xxxarquivo.
3. Se também não houver um arquivo com nome xxx, o Git tentará criar o xxxacordo com algumas regras. Uma das regras é criar um ramo nomeado xxxse remotes/origin/xxxexistir.

Para obter ramificações criadas recentemente

git fetch

Para mudar para outro ramo

git checkout BranchName

Você pode começar a rastrear todas as ramificações remotas com o seguinte script 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 também está 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 ;

git checkout -b "Branch_name" [B significa Criar ramificação local]

git branch --all

git checkout -b "O nome da sua filial"

ramo git

saída com êxito da ramificação mestre para a ramificação dev

para obter todas as ramificações remotas, use isto:

git fetch --all

depois faça o checkout para a filial:

git checkout test

Use fetchpara puxar todo o seu controle remoto

   git fetch --all

Para listar ramificações remotas:

   git branch -r

Para listar todas as suas filiais

   git branch -l
   >>outpots like-
     * develop
       test
       master

Para fazer checkout / alterar uma filial

   git checkout master

Para nós, parece que a remote.origin.fetchconfiguração deu um problema. Portanto, não conseguimos ver outras ramificações remotas master, portanto git fetch [--all], não ajudamos. Nem git checkout mybranchnem git checkout -b mybranch --track origin/mybranchfez trabalho, embora certamente estava no remoto.

A configuração anterior só pode masterser buscada:

$ git config --list | grep fetch
remote.origin.fetch=+refs/heads/master:refs/remotes/origin/master

Corrija-o usando *e busque as novas informações de origem:

$ git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'

$ git fetch
...
 * [new branch] ...
...

Agora nós poderíamos git checkouto ramo remoto localmente.

Não faço ideia de como essa configuração acabou em nosso repositório local.

Se o nome do ramo remoto começar com caracteres especiais, você precisará usar aspas simples no comando checkout, caso contrário, o git não saberá de qual ramo você está falando.

Por exemplo, tentei fazer check-out de uma ramificação remota chamada como, #9773mas o comando não funcionou corretamente, conforme mostrado na figura abaixo:

Por alguma razão, me perguntei se o símbolo afiado (#) poderia ter algo a ver com isso, e então tentei '#9773'colocar o nome do ramo entre aspas simples, como uma pena do que simplesmente #9773, e felizmente funcionou bem.

$ git checkout -b '#9773' origin/'#9773'

Por favor, siga o comando para criar uma pasta vazia. Digite 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'