J'ai retiré un projet de GitHub il y a quelques jours. J'ai depuis découvert qu'il y avait plusieurs fourches sur GitHub, et j'ai négligé de noter celle que j'avais prise à l'origine. Comment puis-je déterminer laquelle de ces fourches j'ai tirée?

Si vous souhaitez uniquement l'URL distante ou si vous n'êtes pas connecté à un réseau pouvant atteindre le référentiel distant:

git config --get remote.origin.url

Si vous avez besoin d'une sortie complète et que vous êtes sur un réseau pouvant atteindre le référentiel distant où réside l'origine:

git remote show origin

Lors de l'utilisation git clone(depuis GitHub, ou tout autre référentiel source d'ailleurs) le nom par défaut de la source du clone est "origine". L'utilisation git remote showaffichera les informations sur ce nom distant. Les premières lignes devraient montrer:

C:\Users\jaredpar\VsVim> git remote show origin
* remote origin
  Fetch URL: git@github.com:jaredpar/VsVim.git
  Push  URL: git@github.com:jaredpar/VsVim.git
  HEAD branch: master
  Remote branches:

Si vous souhaitez utiliser la valeur dans le script, vous utiliserez la première commande répertoriée dans cette réponse.

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

git config --get remote.origin.url

Tu peux 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 pourgit-ls-remote :

--get-url

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

Comme souligné par @Jefromi, cette option a été ajoutée dans la v1.7.5 et n'est pas documentée avant la v1.7.12.2 (2012-09).

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

git remote get-url origin

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

Voir commit 96f78d3 (16 sept. 2015) de Ben Boeckel ( mathstuf) .
^{(Fusionné par Junio ​​C Hamano - gitster- en commit e437cbd , 05 oct.2015 )} :

à distance: ajouter la sous-commande get-url

L'expansion insteadOffait partie de ls-remote --urlet il n'y a aucun moyen de se développer pushInsteadOfégalement.
Ajoutez une get-urlsous - commande 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 insteadOfet pushInsteadOfsont 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ées.

Avant git 2.7, vous aviez:

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

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

(Ce qui suit a été essayé pour le référentiel 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'information:

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

Je pense que vous pouvez le trouver sous .git/configet remote["origin"]si vous n'avez pas manipulé cela.

Réponse courte:

$ git remote show -n origin

ou, une alternative aux scripts rapides purs:

$ git config --get remote.origin.url

Quelques informations:

1. $ git remote -vimprimera toutes les télécommandes (pas ce que vous voulez). Vous voulez de l'origine, non?
2. $ git remote show originbeaucoup mieux, ne s'affiche que originmais prend trop de temps (testé sur la version 1.8.1.msysgit.1 de git).

Je me suis retrouvé avec:, $ git remote show -n originqui semble être le plus rapide. Avec -nelle ne récupérera pas les têtes distantes (branches AKA). Vous n'avez pas besoin de ce type d'informations, non?

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

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

Si vous avez besoin de vitesse pure, utilisez:

$ git config --get remote.origin.url

Merci à @Jefromi de l' avoir signalé.

Pour moi, c'est le moyen le plus simple (moins de frappe):

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

en fait, je l'ai dans un aliasappelé squi fait:

git remote -v
git status

Vous pouvez ajouter à votre profil avec: alias s='git remote -v && git status'

Je ne me souviens jamais de tous les paramètres des commandes Git, donc je mets juste un alias dans le ~/.gitconfigfichier qui a plus de sens pour moi, donc je peux m'en souvenir, et cela se traduit par moins de frappe:

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

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

> git url

Voici quelques-unes de mes plus fréquemment utilisées:

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

Je recommande également fortement git-extras qui a une git info commande qui fournit des informations beaucoup plus détaillées sur les branches distantes et locales.

L'URL Git sera à l'intérieur du fichier de configuration Git. La valeur correspond à la clé url.

Pour Mac et Linux, utilisez les commandes ci-dessous:

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

Pour Windows, ouvrez le fichier ci-dessous dans n'importe quel éditeur de texte et recherchez la valeur de la clé url.

project_dir/.git/config

Remarque: Cela fonctionnera même si vous êtes hors ligne ou si le serveur git distant a été arrêté.

J'utilise essentiellement:

git remote get-url origin

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

git config --list

Cette commande donnera toutes les informations relatives à votre référentiel.

La télécommande en amont ne peut pas être appelée "origine", voici donc une variante:

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 ssh://référentiels:

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

Pour les git://référentiels:

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

Pour compléter les autres réponses: Si la télécommande a pour une raison quelconque été modifiée et ne reflète donc pas l' origine origine, la première entrée dans le reflog (la dernière entrée affichée par la commande git reflog) doit indiquer où le repo a été cloné de.

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é, il n'est donc pas garanti que cela fonctionne.)

Avec git remote show originvous devez être dans le répertoire des projets. Mais si vous souhaitez 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 .bashrcou .bash_profileavec MacOS.

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

Il vous suffit donc d'appeler giturldans 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 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 sous Linux.

Une manière simple consiste à ouvrir le .git/configfichier:

cat .git/config

Éditer:

vim .git/config ou

nano .git/config

Imprimez des URL de récupération à distance arbitrairement nommées:

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

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

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

Cela montre cette branche en amont qui était la source de la branche actuelle. 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-remoteet vous obtiendrez l'URL de la télécommande en amont qui est la source de la branche actuelle:

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

Il convient maintenant de noter que ce n'est pas nécessairement le même que le référentiel distant source à partir duquel le clonage a été effectué. 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"
}

Usage:

# 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

Production:

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

Je préfère celui-ci car il est plus facile à retenir:

git config -l

Il répertorie toutes les informations utiles telles que:

user.name=Your Name
user.email=your.name@notexisting.com
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

il suffit d'utiliser cette commande où votre dossier .git placé

git config --get remote.origin.url

si vous êtes connecté au réseau

git remote show origin

il vous montrera l'URL à partir de laquelle un référentiel Git local a été initialement cloné.

j'espère que cette aide