Git cheatsheet en español (recordatorio de comandos)

Podés ver el uso de git desde terminal en mi entrada del blog https://blog.cesarmansilla.com.ar/como-trabajar-con-git-desde-terminal/ o en Youtube https://www.youtube.com/watch?v=yg2yFySsUWM

---

Índice

• Configuración
• Archivos de Configuración
• Crear
• Cambios locales
• Buscar
• Historial de Commits
• Ramas & Etiquetas
• Actualizar & Publicar
• Fusionar & Rebasar
• Deshacer

---

Configuración

Mostrar la cofiguración actual:

$ git config --list

Mostrar la configuración local:

$ git config --local --list

Mostrar la configuración global:

$ git config --global --list

Mostrar la configuración del sistema:

$ git config --system --list

Establecer un nombre que es identificable de crédito cuando se revise el historial de versiones:

$ git config --global user.name "[nombre apellido]"

Establecer una dirección de email que será asociada con cada marca histórica:

$ git config --global user.email "[email-válido]"

Establecer coloreado automático de la línea de comandos de Git para una fácil revisión:

$ git config --global color.ui auto

Establecer el editor global para commits:

$ git config --global core.editor vi

---

Archivos de Configuración

Archivo de configuración específico del repositorio [--local]:

<repo>/.git/config

Archivo de configuración específico del usuario [--global]:

~/.gitconfig

Archivo de configuración del sistema [--system]:

/etc/gitconfig

---

Crear

Clonar un repositorio existente:

Existen dos maneras:

Vía SSH

$ git clone ssh://usuario@dominio.com/repo.git

Vía HTTP

$ git clone http://dominio.com/usuario/repo.git

Crea un nuevo repositorio local:

$ git init

---

Cambios Locales

Cambios en el directorio de trabajo:

$ git status

Cambios en archivos rastreados:

$ git diff

Agregar todos los cambios actuales al siguiente commit:

$ git add .

Agregar algunos cambios de <archivo> para el siguiente commit:

$ git add -p <archivo>

Realizar un commit de todos los cambios locales en los archivos rastreados:

$ git commit -a

Realizar un commit de los cambios previamente almacenados en el área de pruebas (stage area):

$ git commit

Realizar un commit con un mensaje:

$ git commit -m 'aquí el mensaje'

Realizar un commit saltándose el área de pruebas y agregando un mensaje:

$ git commit -am 'aquí el mensaje'

Realizar un commit a alguna fecha anterior:

git commit --date="`date --date='n day ago'`" -am "Mensaje del commit"

Cambiar último commit:

_{¡No modificar commits ya publicados!}

$ git commit -a --amend

Cambiar fecha del último commit:

GIT_COMMITTER_DATE="date" git commit --amend

Cambiar fecha del autor del último commit:

git commit --amend --date="date"

Mover cambios no confirmados (uncommitted changes) de la rama actual a otra rama:

git stash
git checkout branch2
git stash pop

Restaurar cambios del área de pruebas (stage area) a la rama actual:

git stash apply

Eliminar la última serie de cambios del área de pruebas (stage area):

git stash drop

---

Buscar

Un texto en todos los archivos del directorio:

$ git grep "Hola"

Un texto en cualquier versión:

$ git grep "Hola" v2.5

---

Historial de Commits

Mostrar todos los commits, empezando por los más recientes (se mostrará el hash, información sobre el autor, fecha y título del commit):

$ git log

Mostrar todos los commits (sólo se mostrará el hash y el mensaje del commit):

$ git log --oneline

Mostrar todos los commits de un usuario específico:

$ git log --author="usuario"

Mostrar los cambios a través del tiempo de un archivo específico:

$ git log -p <archivo>

Mostrar commmits que están presentes sólamente en remote/branch al lado derecho:

$ git log --oneline <origin/master>..<remote/master> --left-right

Quién cambió, qué y cuándo en <archivo>:

$ git blame <archivo>

Mostrar reference log:

$ git reflog show

Borrar reference log:

$ git reflog delete

---

Ramas & Etiquetas

Listar todas las ramas locales:

$ git branch

Listar todas las ramas remotas:

$ git branch -r

Cambiar rama HEAD:

$ git checkout <rama>

Crear nueva rama y cambiar a esta:

$ git checkout -b <rama>

Crear nueva rama basada en la rama HEAD actual:

$ git branch <nueva-rama>

Crear nueva rama de seguimiento basada en una rama remota:

$ git branch --track <nueva-rama> <rama-remota>

Eliminar una rama local:

$ git branch -d <rama>

Forzar eliminación de una rama local:

_{¡Perderás los cambios sin fusionar!}

$ git branch -D <branch>

Marcar el commit actual con una etiqueta:

$ git tag <tag-name>

Marcar el commit actual con una etiqueta que incluye un mensaje:

$ git tag -a <etiqueta>

---

Actualizar & Publicar

Listar todos los remotos configurados actuales:

$ git remote -v

Mostrar información sobre un remoto:

$ git remote show <remoto>

Agregar un nuevo repositorio, nombrado <remoto>:

$ git remote add <remoto> <url>

Descargar todos los cambios de <remoto>, pero no integrarlos al HEAD:

$ git fetch <remoto>

Descargar cambios y fusionarlos/integrarlos directamente al HEAD:

$ git remote pull <remote> <url>

Obtener todos los cambios del HEAD al repositorio local:

$ git pull origin master

Obtener todos los cambios del HEAD al repositorio local sin fusionar:

git pull --rebase <remote> <branch>

Publicar cambios locales en un remoto:

$ git push remote <remoto> <rama>

Eliminar una rama en el remoto:

$ git push <remoto> :<rama> (desde Git v1.5.0) ó $ git push <remoto> --delete <rama> (desde Git v1.7.0)

Publicar tus etiquetas:

$ git push --tags

---

Fusionar y Rebasar

Fusionar en tu HEAD actual:

$ git merge <rama>

Rabasar tu actual HEAD sobre <rama>:

_{¡No rebasar commits ya publicados!}

$ git rebase <rama>

Aborta un rebase:

$ git rebase --abort

Continuar un rebase después de resolver conflictos:

$ git rebase --continue

Usar tu herramienta de fusión configurada para resolver conflictos:

$ git mergetool

Usar tu editor para manualmente resolver conflictos y (después de resueltos) marcar el archivo como resuelto:

$ git add <archivo-resuelto>

$ git rm <archivo-resuelto>

Aplastando commits (squashing):

$ git rebase -i <commit-just-before-first>

Ahora reemplazando esto,

pick <commit_id>
pick <commit_id2>
pick <commit_id3>

con esto,

pick <commit_id>
squash <commit_id2>
squash <commit_id3>

---

Deshacer

Descartar todos los cambios locales en tu directorio de trabajo:

$ git reset --hard HEAD

Sacar todos los archivos del área de pruebas (es decir, deshacer el último git add):

$ git reset HEAD

Descartar cambios locales de un archivo específico:

$ git checkout HEAD <archivo>

Revertir un commit (produciendo un nuevo commit con los cambios contrarios):

$ git revert <commit>

Reestablecer tu puntero HEAD a un commit anterior y descartar todos los cambios desde entonces:

$ git reset --hard <commit>

Reestablecer tu putero HEAD al estado actual de una rama remota.

$ git reset --hard <remote/branch> es decir, upstream/master, origin/my-feature

Reestablecer tu puntero HEAD a un commit anterior y preservar todos los cambios en el área de pruebas (stage area):

$ git reset <commit>

Reestablecer tu puntero HEAD a un commit anterior y preservar los cambios locales sin confirmar (uncommitted changes):

$ git reset --keep <commit>

Remover los archivos que fueron accidentalmente agregados al commit antes de ser añadidos al .gitignore:

$ git rm -r --cached .
$ git add .
$ git commit -m "remove xyz file"