Se quiser isto para fins de programação, só poderá obter o URL com

git config --get remote.origin.url

Podes tentar:

git remote -v

Irá imprimir todos os URLs de busca/envio dos seus comandos.

Para obter a resposta:

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

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

--obter o url

Expandir o URL do repositório remoto dado, tendo em conta qualquer configuração de configuração "url.<base>.insteadOf" (ver git-config(1)) e sair sem falar com o comando.

Tal como indicado por @Jefromi, esta opção foi adicionada em v1.7.5 e não documentada até v1.7.12.2 (2012-09).

Com o Git 2.7 (lançamento 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>)

Ver commit 96f78d3 (16 Set 2015) por Ben Boeckel (mathstuf).
^{(Intercalado por Junio C Hamano -- gitster -- em cometer e437cbd, 05 Outubro 2015)}:

Remoto: adicionar subcomand

get-url

Expandir {[7] } faz parte de ls-remote --url e não há maneira de para expandir pushInsteadOf como bem.
Adicione um get-url subcomand para ser capaz de consultar tanto quanto uma maneira de obter todos os URLs configurados.

get-url:

Recupera as URLs para um controlo remoto.
As configurações para insteadOf e pushInsteadOf são expandidas aqui.
Por padrão, apenas o primeiro URL está listado.

• Com '--push', Os URLs de empurrar são questionados em vez de ir buscar URLs.
• Com '--all', todos os URLs para o remoto serão listados.

Antes do git 2.7, tu tinha:

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

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

Informação mínima:

$ 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)

Mais informação ainda:

$ 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)

Resposta curta:

$ git remote show -n origin

Ou, uma alternativa para scripts rápidos:

$ git config --get remote.origin.url

Alguma informação:

1. $ git remote -v irá imprimir todos os comandos (não o que deseja). Queres a origem, certo?
2. $ git remote show origin muito melhor, mostra apenas origin mas leva muito tempo (testado na versão 1.8.1 do git.msysgit.1).

Acabei com: $ git remote show -n origin, que parece ser o mais rápido. Com -n ele não vai obter cabeças remotas (AKA ramificações). Não precisas desse tipo de informação., certo?

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

Você pode aplicar | grep -i fetch a todas as três versões para mostrar apenas o URL de obtenção.

Se necessitar de velocidade pura, então use:

$ git config --get remote.origin.url

Graças a @Jefromi por apontar isso.

O remoto do rio não pode ser chamado de "origem" , por isso 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 da máquina 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 ":"

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

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

Para completar as outras respostas: Se o remoto tiver, por alguma razão, sido alterado e por isso não reflectir a origem original, o primeiro item no reflog (ou seja, o último item apresentado pelo comando git reflog) deverá indicar de onde o repo foi originalmente clonado.

Por exemplo

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

(Tenha em mente que o reflog pode ser purgado, então isto não é garantido para funcionar.)

Nunca me lembro de todos os parâmetros dos comandos Git, por isso pus um nome falso no ficheiro {[[3]} que faz mais sentido para mim, para que me lembre, e resulta em menos digitação:

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

Depois de recarregar o terminal, pode então escrever apenas:

> git url

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

Imprimir arbitrariamente chamados URLs de busca remota:

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

Com git remote show origin tens de estar no directório de projectos. Mas se você quiser determinar os URLs de qualquer outro lugar você poderia usar:

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

Se precisar deste comando muitas vezes, pode definir um nome falso no seu .bashrc ou .bash_profile com MacOS.

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

Então você só precisa chamar giturl na pasta raiz do Git, a fim de simplesmente obter o seu URL.

Se estender este nome falso como este

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

Só obtém o URL simples sem o anterior

"url="

Em

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

Você tem mais possibilidades na sua utilização:

Exemplo

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

Ou chrome $(giturl) para o Abrir com o navegador Chrome no Linux.

Uma maneira simples é abrir o ficheiro .git/config:

cat .git/config

Para editar:

vim .git/config ou

nano .git/config

Eu basicamente uso:

git remote get-url origin

Funciona na consola de comandos do Git Bash ou na consola de comandos CMD do Windows. Dito isto, funciona com a versão 2.x of Git.

Se você não sabe o nome do remoto de upstream para um ramo, você pode procurar isso primeiro, inspecionando o nome do ramo de upstream em que o ramo atual foi construído. Utilizar git rev-parse assim:

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

Isto mostra que o ramo a montante era a fonte do ramo actual. Isto pode ser processado para obter o nome remoto como este:

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

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

#!/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"
}

Utilização:

# 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