Tirei um projeto do GitHub há alguns dias atrás. Desde então, descobri que existem vários garfos no GitHub e deixei de notar qual deles eu peguei originalmente. Como posso determinar qual desses garfos eu puxei?

Se você deseja apenas o URL remoto, ou se não estiver conectado a uma rede que possa acessar o repositório remoto:

git config --get remote.origin.url

Se você precisar de uma saída completa e estiver em uma rede que possa alcançar o repositório remoto onde a origem reside:

git remote show origin

Ao usar git clone(no GitHub ou em qualquer repositório de origem), o nome padrão para a origem do clone é "origem". O uso git remote showexibirá as informações sobre esse nome remoto. As primeiras linhas devem mostrar:

C:\Users\jaredpar\VsVim> git remote show origin
* remote origin
  Fetch URL: [email protected]:jaredpar/VsVim.git
  Push  URL: [email protected]:jaredpar/VsVim.git
  HEAD branch: master
  Remote branches:

Se você quiser usar o valor no script, use o primeiro comando listado nesta resposta.

Se você quiser isso para fins de script, poderá obter apenas o URL com

git config --get remote.origin.url

Podes tentar:

git remote -v

Ele imprimirá todos os URLs de busca / envio de seus controles remotos.

Para obter a resposta:

git ls-remote --get-url [REMOTE]

Isso é melhor do que ler a configuração; consulte a página de manual paragit-ls-remote :

--get-url

Expanda a URL do repositório remoto fornecido, levando em consideração qualquer "url.<base>.insteadOf"configuração (Consulte git-config(1)) e saia sem falar com o controle remoto.

Conforme apontado por @Jefromi, esta opção foi adicionada na v1.7.5 e não foi documentada até a v1.7.12.2 (2012-09).

Com o Git 2.7 (lançado em 5 de janeiro de 2015), você tem uma solução mais coerente usando git remote:

git remote get-url origin

(belo pingente de git remote set-url origin <newurl>)

Veja commit 96f78d3 (16 de setembro de 2015) de Ben Boeckel ( mathstuf) .
^{(Mesclado por Junio ​​C Hamano - gitster- no commit e437cbd , 5 de outubro de 2015)} :

remote: adicionar subcomando get-url

A expansão insteadOffaz parte ls-remote --urle também não há como expandir pushInsteadOf.
Adicione um get-urlsubcomando para poder consultar os dois, bem como uma maneira de obter todos os URLs configurados.

get-url:

Recupera os URLs para um controle remoto.
Configurações para insteadOfe pushInsteadOfsão expandidas aqui.
Por padrão, apenas o primeiro URL é listado.

• Com ' --push', os URLs push são consultados em vez de buscar URLs.
• Com ' --all', todos os URLs do controle remoto serão listados.

Antes do git 2.7, você tinha:

 git config --get remote.[REMOTE].url
 git ls-remote --get-url [REMOTE]
 git remote show [REMOTE]

Para resumir, há pelo menos quatro maneiras:

(O seguinte foi tentado para o repositório oficial do Linux)

Menos informação:

$ git config --get remote.origin.url
https://github.com/torvalds/linux.git

e

$ git ls-remote --get-url
https://github.com/torvalds/linux.git

Mais Informações:

$ git remote -v
origin    https://github.com/torvalds/linux.git (fetch)
origin    https://github.com/torvalds/linux.git (push)

Ainda mais informações:

$ git remote show origin
* remote origin
  Fetch URL: https://github.com/torvalds/linux.git
  Push  URL: https://github.com/torvalds/linux.git
  HEAD branch: master
  Remote branch:
    master tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

Eu acho que você pode encontrar abaixo .git/confige remote["origin"]se você não manipulou isso.

Resposta curta:

$ git remote show -n origin

ou, uma alternativa para scripts rápidos puros:

$ git config --get remote.origin.url

Algumas informações:

1. $ git remote -vimprimirá todos os controles remotos (não o que você deseja). Você quer origem, certo?
2. $ git remote show originmuito melhor, mostra apenas, originmas leva muito tempo (testado na versão 1.8.1.msysgit.1 do git).

Acabei com $ git remote show -n origin:, que parece ser o mais rápido. Com -nele não vai buscar cabeças remotas (ramos AKA). Você não precisa desse tipo de informação, certo?

http://www.kernel.org/pub//software/scm/git/docs/git-remote.html

Você pode se inscrever | grep -i fetchnas três versões para mostrar apenas o URL de busca.

Se você precisar de velocidade pura, use:

$ git config --get remote.origin.url

Obrigado a @Jefromi por apontar isso.

Para mim, esta é a maneira mais fácil (menos digitação):

$ git remote -v
origin    https://github.com/torvalds/linux.git (fetch)
origin    https://github.com/torvalds/linux.git (push)

na verdade, eu tenho isso em um aliaschamado sque faz:

git remote -v
git status

Você pode adicionar ao seu perfil com: alias s='git remote -v && git status'

Eu nunca consigo me lembrar de todos os parâmetros dos comandos do Git, então, bastai colocar um alias no ~/.gitconfigarquivo que faça mais sentido para mim, para que eu possa lembrar, e resulta em menos digitação:

[alias]
url = ls-remote --get-url

Após recarregar o terminal, você pode digitar:

> git url

Aqui estão mais alguns dos meus mais usados:

[alias]
cd = checkout
ls = branch
lsr = branch --remote
lst = describe --tags

Eu também recomendo o git-extras, que possui um git info comando que fornece informações muito mais detalhadas sobre as filiais remotas e locais.

O URL do Git estará dentro do arquivo de configuração do Git. O valor corresponde à chave url.

Para Mac e Linux, use os comandos abaixo:

 cd project_dir
 cat .git/config | grep url | awk '{print $3}'

Para Windows, abra o arquivo abaixo em qualquer editor de texto e encontre o valor da chave url.

project_dir/.git/config

Nota: Isso funcionará mesmo se você estiver offline ou se o servidor git remoto tiver sido desativado.

Eu basicamente uso:

git remote get-url origin

Ele funciona no console de comando Git Bash ou no console de comando CMD no Windows. Dito isto, ele funciona com a versão 2.x do Git.

git config --list

Este comando fornecerá todas as informações relacionadas ao seu repositório.

O controle remoto do upstream pode não ser chamado de "origem", então aqui está uma variação:

remote=$(git config --get branch.master.remote)
url=$(git config --get remote.$remote.url)
basename=$(basename "$url" .git)
echo $basename

Ou:

basename $(git config --get remote.$(git config --get branch.master.remote).url) .git

Para variáveis ​​mais úteis, há:

$ git config -l

Para obter o endereço IP / nome do host de origin

Para ssh://repositórios:

git ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d "/"

Para git://repositórios:

git ls-remote --get-url origin | cut -f 2 -d @ | cut -f 1 -d ":"

Para complementar as outras respostas: Se o controle remoto foi alterado por algum motivo e, portanto, não reflete a origem original , a primeira entrada no reflog (ou seja, a última entrada exibida pelo comando git reflog) deve indicar onde o repositório foi originalmente clonado de.

por exemplo

$ git reflog | tail -n 1
f34be46 HEAD@{0}: clone: from https://github.com/git/git
$

(Lembre-se de que o reflog pode ser eliminado, portanto não é garantido que funcione.)

Com git remote show originvocê tem que estar no diretório de projetos. Mas se você quiser determinar os URLs de qualquer outro lugar, poderá usar:

cat <path2project>/.git/config | grep url

Se você precisar desse comando frequentemente, poderá definir um alias no seu .bashrcou .bash_profilecom o MacOS.

alias giturl='cat ./.git/config | grep url'

Então, você só precisa chamar giturla pasta raiz do Git para simplesmente obter seu URL.

Se você estender esse alias como este

alias giturl='cat .git/config | grep -i url | cut -d'=' -f 2'

você obtém apenas o URL simples sem o precedente

"url ="

no

url = http://example.com/repo.git

você tem mais possibilidades de uso:

Exemplo

No Mac, você pode ligar open $(giturl)para abrir o URL no navegador padrão.

Ou chrome $(giturl)para abri-lo com o navegador Chrome no Linux.

Uma maneira simples é abrir o .git/configarquivo:

cat .git/config

Editar:

vim .git/config ou

nano .git/config

Imprima URLs de busca remota nomeados arbitrariamente:

git remote -v | grep fetch | awk '{print $2}'

Se você não souber o nome do controle remoto upstream para uma ramificação, poderá procurar isso primeiro, inspecionando o nome da ramificação upstream na qual a ramificação atual foi construída. Use git rev-parseassim:

git rev-parse --symbolic-full-name --abbrev-ref @{upstream}

Isso mostra o ramo upstream que foi a fonte do ramo atual. Isso pode ser analisado para obter o nome remoto assim:

git rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1

Agora pegue isso e canalize-o para git ls-remoteobter a URL do controle remoto upstream que é a fonte da ramificação atual:

git ls-remote --get-url \
  $(git rev-parse --symbolic-full-name --abbrev-ref @{upstream} | cut -d / -f 1)

Agora, note-se que isso não é necessariamente o mesmo que o repositório remoto de origem do qual foi clonado. Em muitos casos, porém, será suficiente.

#!/bin/bash

git-remote-url() {
 local rmt=$1; shift || { printf "Usage: git-remote-url [REMOTE]\n" >&2; return 1; }
 local url

 if ! git config --get remote.${rmt}.url &>/dev/null; then
  printf "%s\n" "Error: not a valid remote name" && return 1
  # Verify remote using 'git remote -v' command
 fi

 url=`git config --get remote.${rmt}.url`

 # Parse remote if local clone used SSH checkout
 [[ "$url" == git@* ]] \
 && { url="https://github.com/${url##*:}" >&2; }; \
 { url="${url%%.git}" >&2; };

 printf "%s\n" "$url"
}

Uso:

# Either launch a new terminal and copy `git-remote-url` into the current shell process, 
# or create a shell script and add it to the PATH to enable command invocation with bash.

# Create a local clone of your repo with SSH, or HTTPS
git clone [email protected]:your-username/your-repository.git
cd your-repository

git-remote-url origin

Resultado:

https://github.com/your-username/your-repository

Eu prefiro este, pois é mais fácil lembrar:

git config -l

Ele listará todas as informações úteis, como:

user.name=Your Name
[email protected]
core.autocrlf=input
core.repositoryformatversion=0
core.filemode=true
core.bare=false
core.logallrefupdates=true
remote.origin.url=https://github.com/mapstruct/mapstruct-examples
remote.origin.fetch=+refs/heads/*:refs/remotes/origin/*
branch.master.remote=origin
branch.master.merge=refs/heads/master

fácil, basta usar este comando onde você colocou a pasta .git

git config --get remote.origin.url

se você estiver conectado à rede

git remote show origin

mostrará a URL da qual um repositório Git local foi originalmente clonado.

espero que isso ajude