Ho estratto un progetto da GitHub qualche giorno fa. Da allora ho scoperto che ci sono diverse forcelle su GitHub e ho trascurato di notare quale ho preso in origine. Come posso determinare quale di quelle forcelle ho tirato?

Se si desidera solo l'URL remoto o se non si è connessi a una rete che può raggiungere il repository remoto:

git config --get remote.origin.url

Se è necessario un output completo e ci si trova su una rete che può raggiungere il repository remoto in cui risiede l'origine:

git remote show origin

Quando si utilizza git clone(da GitHub o qualsiasi repository di origine per quella materia) il nome predefinito per l'origine del clone è "origine". Usando git remote showverranno visualizzate le informazioni su questo nome remoto. Le prime righe dovrebbero mostrare:

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:

Se si desidera utilizzare il valore nello script, utilizzare il primo comando elencato in questa risposta.

Se lo desideri per scopi di scripting, puoi ottenere solo l'URL con

git config --get remote.origin.url

Puoi provare:

git remote -v

Stampa tutti gli URL di recupero / push dei telecomandi.

Per ottenere la risposta:

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

Questo è meglio che leggere la configurazione; fare riferimento alla pagina man pergit-ls-remote :

--get-url

Espandi l'URL del repository remoto specificato tenendo conto delle "url.<base>.insteadOf"impostazioni di configurazione (Vedi git-config(1)) ed esci senza parlare al telecomando.

Come sottolineato da @Jefromi, questa opzione è stata aggiunta in v1.7.5 e non documentata fino a v1.7.12.2 (2012-09).

Con Git 2.7 (versione 5 gennaio 2015), hai una soluzione più coerente che utilizza git remote:

git remote get-url origin

(bel ciondolo di git remote set-url origin <newurl>)

Vedi commit 96f78d3 (16 set 2015) di Ben Boeckel ( mathstuf) .
^{(Unita da Junio ​​C Hamano - gitster- in commit e437cbd , 05 ott 2015)} :

remoto: aggiungi il sottocomando get-url

L'espansione insteadOffa parte ls-remote --urle non c'è modo di espandersi pushInsteadOf.
Aggiungi un get-urlsottocomando per poter eseguire query sia per ottenere tutti gli URL configurati.

get-url:

Recupera gli URL per un telecomando.
Le configurazioni per insteadOfe pushInsteadOfvengono espanse qui.
Per impostazione predefinita, è elencato solo il primo URL.

• Con " --push", vengono interrogati gli URL push anziché recuperarli.
• Con " --all", verranno elencati tutti gli URL per il telecomando.

Prima di git 2.7, avevi:

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

Per riassumere, ci sono almeno quattro modi:

(Di seguito è stato provato per il repository Linux ufficiale)

Informazioni minime:

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

e

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

Maggiori informazioni:

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

Ancora più informazioni:

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

Penso che puoi trovarlo sotto .git/confige remote["origin"]se non lo hai manipolato.

Risposta breve:

$ git remote show -n origin

oppure, un'alternativa per gli script veloci puri:

$ git config --get remote.origin.url

Alcune informazioni:

1. $ git remote -vstamperà tutti i telecomandi (non quello che vuoi). Vuoi l'origine, giusto?
2. $ git remote show originmolto meglio, mostra solo originma richiede troppo tempo (testato sulla versione 1.8.1.msysgit.1 di git).

Ho finito con $ git remote show -n origin:, che sembra essere il più veloce. Con -nesso non recupererà le teste remote (rami AKA). Non hai bisogno di quel tipo di informazioni, giusto?

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

È possibile applicare | grep -i fetcha tutte e tre le versioni per mostrare solo l'URL di recupero.

Se hai bisogno di pura velocità, usa:

$ git config --get remote.origin.url

Grazie a @Jefromi per averlo segnalato.

Per me, questo è il modo più semplice (meno digitando):

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

in realtà, l'ho inserito in una aliaschiamata sche fa:

git remote -v
git status

Puoi aggiungere al tuo profilo con: alias s='git remote -v && git status'

Non riesco mai a ricordare tutti i parametri dei comandi Git, quindi ho appena messo un alias nel ~/.gitconfigfile che ha più senso per me, quindi posso ricordare, e si traduce in meno battitura:

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

Dopo aver ricaricato il terminale, puoi semplicemente digitare:

> git url

Ecco alcuni dei miei più usati:

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

Consiglio vivamente git-extra che ha un git info comando che fornisce informazioni molto più dettagliate sui rami remoti e locali.

L'URL Git sarà all'interno del file di configurazione di Git. Il valore corrisponde alla chiave url.

Per Mac e Linux usa i comandi seguenti:

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

Per Windows, apri il file seguente in qualsiasi editor di testo e trova il valore per chiave url.

project_dir/.git/config

Nota: funzionerà anche se sei offline o il server git remoto è stato rimosso.

Fondamentalmente uso:

git remote get-url origin

Funziona con la console di comando Git Bash o la console di comando CMD in Windows. Detto questo, funziona con la versione 2.x di Git.

git config --list

Questo comando fornirà tutte le informazioni relative al tuo repository.

Il telecomando dell'upstream non può essere chiamato "origine", quindi ecco una variante:

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

O:

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

Per variabili più utili c'è:

$ git config -l

Per ottenere l'indirizzo IP / nome host di origin

Per i ssh://repository:

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

Per i git://repository:

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

Per integrare le altre risposte: se per qualche motivo il telecomando è stato modificato e quindi non riflette l' origine originale , la primissima voce nel reflog (ovvero l'ultima voce visualizzata dal comando git reflog) dovrebbe indicare dove il repository è stato originariamente clonato a partire dal.

per esempio

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

(Tieni presente che il reflog può essere eliminato, quindi non è garantito che funzioni.)

Con git remote show originte devi essere nella directory dei progetti. Ma se vuoi determinare gli URL da qualsiasi altra parte puoi usare:

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

Se hai bisogno spesso di questo comando, puoi definire un alias nel tuo .bashrco .bash_profilecon MacOS.

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

Quindi devi solo chiamare giturlnella cartella principale di Git per ottenere semplicemente il suo URL.

Se estendi questo alias in questo modo

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

ottieni solo l'URL normale senza il precedente

"Url ="

in

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

ottieni più possibilità nel suo utilizzo:

Esempio

Su Mac puoi chiamare open $(giturl)per aprire l'URL nel browser standard.

O chrome $(giturl)per aprirlo con il browser Chrome su Linux.

Un modo semplice è aprire il .git/configfile:

cat .git/config

Modificare:

vim .git/config o

nano .git/config

Stampa URL di recupero remoto con nome arbitrario:

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

Se non si conosce il nome del telecomando a monte per un ramo, è possibile cercarlo prima controllando il nome del ramo a monte su cui è stato costruito il ramo corrente. Usa git rev-parsecosì:

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

Ciò mostra quel ramo a monte che era l'origine per il ramo corrente. Questo può essere analizzato per ottenere il nome remoto in questo modo:

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

Ora prendilo e instradalo git ls-remotee otterrai l'URL del telecomando upstream che è l'origine del ramo corrente:

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

Ora va notato che questo non è necessariamente uguale al repository remoto di origine da cui è stato clonato. In molti casi, tuttavia, sarà sufficiente.

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

git-remote-url origin

Produzione:

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

Preferisco questo in quanto è più facile da ricordare:

git config -l

Elencherà tutte le informazioni utili come:

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

facile basta usare questo comando dove è posizionata la cartella .git

git config --get remote.origin.url

se sei connesso alla rete

git remote show origin

ti mostrerà l'URL da cui è stato originariamente clonato un repository Git locale.

spero che questo aiuto