Si vous le souhaitez à des fins de Script, vous ne pouvez obtenir que l'URL avec

git config --get remote.origin.url

, Vous pouvez essayer:

git remote -v

Il imprimera toutes les URL fetch/push de vos télécommandes.

Pour obtenir la réponse:

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

C'est mieux que de lire la configuration; reportez-vous à la page de manuel pour git-ls-remote:

--obtenez de l'url-

Développez l'URL du référentiel distant donné en tenant compte tout paramètre de configuration "url.<base>.insteadOf" (Voir git-config(1)) et quittez sans parler à la télécommande.

Comme indiqué par @Jefromi, cette option a été ajoutée dans v1.7. 5 et n'a pas été documentée avant v1.7.12.2 (2012-09).

Avec Git 2.7 (sortie le 5 janvier 2015), vous avez une solution plus cohérente en utilisant git remote:

git remote get-url origin

(joli pendentif de git remote set-url origin <newurl>)

Voir commettre 96f78d3 (16 septembre 2015) par Ben Boeckel (mathstuf).
^{(Fusionné par Junio C Hamano -- gitster -- dans commettre e437cbd, 05 Oct 2015)}:

Remote: ajouter une sous-commande get-url

Expansion insteadOf est une partie de ls-remote --url et il n'existe aucun moyen pour développer pushInsteadOf comme Bien.
Ajoutez une sous-commande get-url pour pouvoir interroger les deux ainsi qu'un moyen d'obtenir toutes les URL configurées.

get-url:

Récupère les URL d'une télécommande.
Les Configurations pour insteadOf et pushInsteadOf sont développées ici.
Par défaut, seule la première URL est répertoriée.

• avec ' --push', les URL push sont interrogées plutôt que les URL fetch.
• , Avec '--all', toutes les Url de la télécommande seront répertoriés.

Avant git 2.7, vous a:

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

Pour résumer, il y a au moins quatre façons:

(ce qui suit a été essayé pour le dépôt Linux officiel)

Moins d'informations:

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

Et

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

Plus d'informations:

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

Encore plus d'informations:

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

Réponse courte:

$ git remote show -n origin

Ou, une alternative pour les scripts rapides purs:

$ git config --get remote.origin.url

Quelques informations:

1. $ git remote -v imprime toutes les télécommandes (pas ce que vous voulez). Vous voulez origine droit?
2. $ git remote show origin beaucoup mieux, ne montre que origin, mais prend trop de temps (testé sur git version 1.8.1.msysgit.1).

Je me suis retrouvé avec: $ git remote show -n origin, qui semble être le plus rapide. Avec -n, Il ne récupérera pas les têtes distantes (aka branches). Vous n'avez pas besoin de ce type d'information, droit?

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

Vous pouvez appliquer | grep -i fetch aux trois versions pour afficher uniquement l'URL de récupération.

Si vous avez besoin d'une vitesse pure, utilisez:

$ git config --get remote.origin.url

Merci à @Jefromi pour avoir signalé cela.

Je pense que vous pouvez le trouver sous .git/config et remote["origin"] si vous ne l'avez pas manipulé.

La télécommande de l'amont peut ne pas être appelée "origine", alors voici une variation:

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

Pour des variables plus utiles, il y a:

$ git config -l

Pour obtenir l'adresse IP/le nom d'hôte de origin

Pour les dépôts ssh://:

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

Pour les dépôts git://:

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

L'URL Git se trouve dans le fichier de configuration Git. La valeur correspond à la clé url:

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

Pour compléter les autres réponses: si la télécommande a été modifiée pour une raison quelconque et ne reflète donc pas l'origineoriginale , la toute première entrée du reflog (c'est-à-dire la dernière entrée affichée par la commande git reflog) doit indiquer d'où le repo a été cloné à l'origine.

Par exemple

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

(Gardez à l'esprit que le reflog peut être purgé, donc cela n'est pas garanti.)

Je ne me souviens jamais de tous les paramètres des commandes Git, donc je viens de mettre un alias dans le fichier ~/.gitconfig qui a plus de sens pour moi, donc je peux m'en souvenir, et il en résulte moins de typage:

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

Après avoir rechargé le terminal, vous pouvez simplement taper:

> git url

Voici quelques-uns de mes plus fréquemment utilisés:

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

Affiche les URL d'extraction distantes nommées arbitrairement:

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

Avec git remote show origin, vous devez être dans le répertoire des projets. Mais si vous voulez déterminer les URL de n'importe où ailleurs vous pouvez utiliser:

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

Si vous avez souvent besoin de cette commande, vous pouvez définir un alias dans votre .bashrc ou .bash_profile avec MacOS.

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

Il vous suffit donc d'appeler giturl dans le dossier racine Git afin d'obtenir simplement son URL.

Si vous étendez cet alias comme ceci

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

Vous obtenez uniquement L'URL simple sans le {[10 précédent]}

"url="

Dans

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

, Vous obtenez plus de possibilités dans son utilisation:

Exemple

Sur Mac, vous pouvez appeler open $(giturl) pour ouvrir l'URL dans le navigateur standard.

Ou chrome $(giturl) pour l'ouvrir avec le navigateur Chrome sur Linux.

Un moyen simple est d'ouvrir la .git/config fichier:

cat .git/config

Pour modifier:

vim .git/config ou

nano .git/config

, j'utilise essentiellement:

git remote get-url origin

Cela fonctionne pour la console de commande Git Bash ou la console de commande CMD sous Windows. Cela dit, il fonctionne avec la version 2.x de Git.

Si vous ne connaissez pas le nom de la télécommande amont pour une branche, vous pouvez le rechercher en premier en inspectant le nom de la branche amont sur laquelle la branche actuelle a été construite. Utilisez git rev-parse comme ceci:

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

Cela montre que la branche amont qui était la source de la branche courante. Cela peut être analysé pour obtenir le nom distant comme ceci:

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

Maintenant, prenez cela et dirigez-le vers git ls-remote et vous obtiendrez l'URL de la télécommande en amont qui est la source du courant branche:

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

Maintenant, il convient de noter que ce n'est pas nécessairement la même chose que le référentiel distant source à partir duquel a été cloné. Dans de nombreux cas, cependant, ce sera suffisant.

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

Utilisation:

# 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 git@github.com:your-username/your-repository.git
cd your-repository

git-remote-url origin

Sortie:

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