Saqué un proyecto de GitHub hace unos días. Desde entonces descubrí que hay varias bifurcaciones en GitHub, y descuidé notar cuál tomé originalmente. ¿Cómo puedo determinar cuál de esos tenedores saqué?

Si solo desea la URL remota, o si no está conectado a una red que puede alcanzar el repositorio remoto:

git config --get remote.origin.url

Si necesita una salida completa y está en una red que puede alcanzar el repositorio remoto donde reside el origen:

git remote show origin

Cuando se utiliza git clone(desde GitHub, o cualquier repositorio de origen para el caso) el nombre predeterminado para el origen del clon es "origen". El uso git remote showmostrará la información sobre este nombre remoto. Las primeras líneas deberían 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:

Si desea usar el valor en la secuencia de comandos, usaría el primer comando que figura en esta respuesta.

Si desea esto para fines de secuencias de comandos, solo puede obtener la URL con

git config --get remote.origin.url

Puedes probar:

git remote -v

Imprimirá todas las URL de búsqueda / inserción de sus controles remotos.

Para obtener la respuesta:

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

Esto es mejor que leer la configuración; consulte la página de manual paragit-ls-remote :

--get-url

Expanda la URL del repositorio remoto dado teniendo en cuenta cualquier "url.<base>.insteadOf"configuración de configuración (Ver git-config(1)) y salga sin hablar con el control remoto.

Como señaló @Jefromi, esta opción se agregó en v1.7.5 y no se documentó hasta v1.7.12.2 (2012-09).

Con Git 2.7 (lanzamiento el 5 de enero de 2015), tiene una solución más coherente usando git remote:

git remote get-url origin

(bonito colgante de git remote set-url origin <newurl>)

Ver commit 96f78d3 (16 de septiembre de 2015) por Ben Boeckel ( mathstuf) .
^{(Fusionada por Junio ​​C Hamano - gitster- en commit e437cbd , 05 oct 2015)} :

remoto: agregar el subcomando get-url

La expansión insteadOfforma parte ls-remote --urly tampoco hay forma de expandirse pushInsteadOf.
Agregue un get-urlsubcomando para poder consultar tanto como una forma de obtener todas las URL configuradas.

get-url:

Recupera las URL de un control remoto.
Las configuraciones para insteadOfy pushInsteadOfse expanden aquí.
Por defecto, solo se enumera la primera URL.

• Con ' --push', se consultan las URL de inserción en lugar de buscar las URL.
• Con ' --all', se enumerarán todas las URL del control remoto.

Antes de git 2.7, tenías:

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

Para resumir, hay al menos cuatro formas:

(Se intentó lo siguiente para el repositorio oficial de Linux)

Menos información:

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

y

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

Más información:

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

Aún más información:

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

Creo que puedes encontrarlo debajo .git/configy remote["origin"]si no lo manipulaste.

Respuesta corta:

$ git remote show -n origin

o, una alternativa para scripts rápidos puros:

$ git config --get remote.origin.url

Alguna información:

1. $ git remote -vimprimirá todos los controles remotos (no lo que desea). ¿Quieres origen verdad?
2. $ git remote show originmucho mejor, muestra solo originpero lleva demasiado tiempo (probado en git versión 1.8.1.msysgit.1).

Terminé con:, $ git remote show -n originque parece ser el más rápido. Con -nél no se buscarán cabezales remotos (ramas AKA). No necesitas ese tipo de información, ¿verdad?

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

Puede aplicar | grep -i fetcha las tres versiones para mostrar solo la URL de búsqueda.

Si necesita velocidad pura, use:

$ git config --get remote.origin.url

Gracias a @Jefromi por señalar eso.

Para mí, esta es la forma más fácil (menos escribir):

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

en realidad, tengo eso en una aliasllamada sque hace:

git remote -v
git status

Puede agregar a su perfil con: alias s='git remote -v && git status'

Nunca puedo recordar todos los parámetros de los comandos de Git, así que solo pongo un alias en el ~/.gitconfigarchivo que tiene más sentido para mí, para poder recordarlo y resulta en menos tipeo:

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

Después de volver a cargar la terminal, puede simplemente escribir:

> git url

Aquí hay algunos más de mis más utilizados:

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

También recomiendo git-extras que tiene un git info comando que proporciona información mucho más detallada sobre las sucursales locales y remotas.

La URL de Git estará dentro del archivo de configuración de Git. El valor corresponde a la clave url.

Para Mac y Linux, use los siguientes comandos:

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

Para Windows, abra el archivo a continuación en cualquier editor de texto y encuentre el valor de la clave url.

project_dir/.git/config

Nota: Esto funcionará incluso si está fuera de línea o si el servidor git remoto ha sido desconectado.

Básicamente uso:

git remote get-url origin

Funciona para la consola de comando Git Bash o la consola de comando CMD en Windows. Dicho esto, funciona con la versión 2.x de Git.

git config --list

Este comando le dará toda la información relacionada con su repositorio.

Es posible que el control remoto de la cadena ascendente no se llame "origen", así que aquí hay una variación:

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

Para variables más útiles hay:

$ git config -l

Para obtener la dirección IP / nombre de host de origin

Para ssh://repositorios:

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

Para git://repositorios:

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

Para complementar las otras respuestas: si por alguna razón el control remoto ha cambiado y no refleja el origen original , la primera entrada en el registro (es decir, la última entrada mostrada por el comandogit reflog ) debe indicar dónde se clonó originalmente el repositorio. desde.

p.ej

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

(Tenga en cuenta que el reflog puede ser purgado, por lo que no se garantiza que funcione).

Con git remote show originusted tiene que estar en el directorio de proyectos. Pero si desea determinar las URL desde cualquier otro lugar, puede usar:

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

Si necesita este comando con frecuencia, puede definir un alias en su .bashrco .bash_profilecon MacOS.

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

Por lo tanto, solo debe llamar giturla la carpeta raíz de Git para obtener simplemente su URL.

Si extiende este alias así

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

obtienes solo la URL sin el precedente

"url ="

en

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

obtienes más posibilidades en su uso:

Ejemplo

En Mac, puede llamar open $(giturl)para abrir la URL en el navegador estándar.

O chrome $(giturl)para abrirlo con el navegador Chrome en Linux.

Una forma simple es abrir el .git/configarchivo:

cat .git/config

Para editar:

vim .git/config o

nano .git/config

Imprima URL de búsqueda remota con nombres arbitrarios:

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

Si no conoce el nombre del control remoto ascendente para una sucursal, puede buscarlo primero inspeccionando el nombre de la sucursal ascendente sobre el que se construyó la sucursal actual. Usar git rev-parseasí:

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

Esto muestra esa rama ascendente que fue la fuente de la rama actual. Esto se puede analizar para obtener el nombre remoto de esta manera:

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

Ahora tome eso y canalícelo hasta git ls-remoteobtener la URL del control remoto ascendente que es la fuente de la rama actual:

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

Ahora debe tenerse en cuenta que esto no es necesariamente lo mismo que el repositorio remoto de origen desde el que se clonó. Sin embargo, en muchos casos 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

Salida:

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

Prefiero este ya que es más fácil de recordar:

git config -l

Enumerará toda la información útil, 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 solo use este comando donde colocó la carpeta .git

git config --get remote.origin.url

si estás conectado a la red

git remote show origin

le mostrará la URL desde la que se clonó originalmente un repositorio local de Git.

espero que esto ayude