Git: 100 Comandos para el Día a Día

Git es la herramienta que todo desarrollador usa y que casi nadie domina por completo. La buena noticia: unos 20 comandos cubren el 95% del trabajo — los otros 80 son los que te salvan el día en que algo sale mal.

Estos 100 comandos están en el orden en que aparecen en la vida real: configurar, crear, hacer commit, ramificar, integrar, publicar, deshacer e investigar.

Regla de oro: mientras no hayas hecho push, casi todo es reversible. Después del push, prefiere los comandos que añaden historia (como revert) frente a los que la reescriben (como rebase y --force).

Índice

• 1–10 · Configuración inicial
• 11–18 · Crear y clonar repositorios
• 19–32 · El flujo del día a día
• 33–46 · Ramas
• 47–58 · Merge, rebase y conflictos
• 59–70 · Trabajar con remotos
• 71–84 · Deshacer (el capítulo que te salva el pellejo)
• 85–94 · Historial e investigación
• 95–100 · Stash, etiquetas y submódulos

Configuración inicial

Se hace una vez por máquina — y es lo que evita un commit con el autor equivocado.

1. Definir nombre y correo

Es lo que aparece en la autoría de cada commit. Sin eso, Git protesta en el primer commit.

git config --global user.name "Jhonatan Pinheiro"
git config --global user.email "voce@email.com"

2. Ver la configuración actual

Lista todo lo que está en vigor y de dónde vino cada valor.

git config --list --show-origin

3. Configuración por repositorio

Sin --global, vale solo en el proyecto actual. Útil para separar el correo personal del corporativo.

git config user.email "voce@empresa.com"

4. Editor por defecto

Define quién abre el mensaje de commit y el rebase interactivo.

git config --global core.editor "code --wait"

5. Rama inicial por defecto

Hace que todo repositorio nuevo nazca con main en lugar de master.

git config --global init.defaultBranch main

6. Fin de línea (CRLF vs LF)

Evita el clásico diff gigante entre Windows y Linux.

git config --global core.autocrlf true    # Windows
git config --global core.autocrlf input   # Linux y macOS

7. Atajos (alias)

Los comandos largos que repites cada día merecen un apodo.

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.lg "log --oneline --graph --decorate --all"

8. Caché de credenciales

Te evita escribir el token en cada push.

git config --global credential.helper store     # guarda en disco
git config --global credential.helper manager   # Windows (gestor del SO)

9. Firmar commits con GPG

Prueba criptográfica de autoría — el sello Verified en GitHub.

git config --global user.signingkey SEU_ID_GPG
git config --global commit.gpgsign true

10. Pull sin merge automático

Hace que git pull proteste en lugar de crear un merge por su cuenta. Evita un historial enredado.

git config --global pull.rebase false
git config --global pull.ff only

Crear y clonar repositorios

El punto de partida: convertir una carpeta en repositorio o traer uno existente.

11. git init — crear un repositorio

Convierte la carpeta actual en un repositorio Git (crea el directorio .git).

git init

12. git clone — copiar un repositorio

Descarga el proyecto con todo el historial y ya configura el remoto origin.

git clone https://github.com/usuario/projeto.git

13. Clonar en otra carpeta

Define el nombre del directorio de destino.

git clone https://github.com/usuario/projeto.git minha-pasta

14. Clon superficial (shallow)

Trae solo los commits más recientes. Mucho más rápido en un repositorio grande — ideal en CI.

git clone --depth 1 https://github.com/usuario/projeto.git

15. Clonar una rama concreta

Descarga solo la rama que interesa.

git clone --branch desenvolvimento --single-branch https://github.com/usuario/projeto.git

16. Clonar por SSH

Sin escribir contraseña ni token, siempre que tu clave esté registrada.

git clone git@github.com:usuario/projeto.git

17. .gitignore

Lista lo que Git debe ignorar. Pon aquí las dependencias, la build y los secretos.

# .gitignore
node_modules/
.env
.env.local
dist/
*.log

18. Dejar de rastrear un archivo ya subido

Añadirlo al .gitignore no quita lo que ya está versionado.

git rm --cached .env
git commit -m "chore: remove .env do versionamento"

El flujo del día a día

Ver qué cambió, elegir qué entra y registrarlo. El noventa por ciento del uso de Git.

19. git status

Muestra qué cambió, qué está preparado y en qué rama estás. Ejecútalo siempre antes de hacer commit.

git status
git status -s        # versión corta

20. git add — preparar un archivo

Mueve el cambio al staging area — la antesala del commit.

git add arquivo.ts
git add src/

21. git add . — preparar todo

Añade todo lo que cambió. Compruébalo con status antes, para no llevarte un archivo indeseado.

git add .

22. git add -p — preparar por partes

Elige trozo a trozo dentro del mismo archivo. El mejor amigo del commit pequeño.

git add -p

23. git diff — qué cambió

La diferencia entre lo que está en disco y el último commit (sin contar lo que ya está preparado).

git diff

24. git diff --staged

Muestra exactamente lo que va a entrar en el próximo commit.

git diff --staged

25. git diff entre ramas

Compara dos puntos cualesquiera de la historia.

git diff main..minha-feature
git diff main..minha-feature -- src/app

26. git commit

Registra lo que está preparado. El mensaje es documentación: escribe el porqué.

git commit -m "feat: adiciona filtro por assunto no blog"

27. Commit con cuerpo

Título corto, línea en blanco y el contexto debajo.

git commit -m "fix: corrige contraste do tema claro" -m "O primary ficava em 3,2:1 sobre o fundo, abaixo do minimo AA."

28. git commit -a

Prepara y hace commit de los archivos ya rastreados de una vez. No recoge archivos nuevos.

git commit -am "refactor: extrai helper de datas"

29. Conventional Commits

Convención que deja el historial legible y permite generar un changelog automático.

# feat, fix, docs, style, refactor, perf, test, chore
git commit -m "perf(db): indexa pedidos por cliente_id"

30. git commit --amend

Corrige el último commit (mensaje o contenido). Solo antes del push.

git commit --amend -m "mensagem corrigida"
git commit --amend --no-edit   # solo añade lo que está preparado

31. Commit vacío

Sin ningún cambio — útil para disparar un pipeline de CI.

git commit --allow-empty -m "chore: dispara build"

32. git mv y git rm

Renombrar y eliminar manteniendo el rastro en el historial.

git mv antigo.ts novo.ts
git rm obsoleto.ts

Ramas

Ramificar es barato en Git. Una rama por tarea es el patrón que evita dolores de cabeza.

33. Listar ramas

Muestra las locales; con -a, también las remotas.

git branch
git branch -a
git branch -vv   # con el último commit y el remoto de cada una

34. Crear una rama

La crea a partir del commit actual, sin cambiarte a ella.

git branch minha-feature

35. Cambiar de rama

switch es el comando moderno; checkout sigue funcionando.

git switch minha-feature
git checkout minha-feature

36. Crear y cambiar a la vez

El atajo más usado del día a día.

git switch -c minha-feature
git checkout -b minha-feature

37. Crear una rama a partir de otra

Parte de un punto concreto en lugar del commit actual.

git switch -c hotfix main

38. Renombrar una rama

Renombra la actual (-m) o una concreta.

git branch -m novo-nome
git branch -m nome-antigo novo-nome

39. Borrar una rama local

-d se niega si hay algún commit sin integrar; -D lo fuerza.

git branch -d minha-feature
git branch -D minha-feature

40. Borrar una rama remota

Elimina la rama del servidor después del merge.

git push origin --delete minha-feature

41. Volver a la rama anterior

El - funciona igual que en cd.

git switch -

42. Ramas ya integradas

Lista lo que ya se fusionó — candidatas seguras a borrar.

git branch --merged main
git branch --no-merged main

43. Rastrear una rama remota

Vincula la rama local con la del servidor, para hacer push/pull sin argumentos.

git branch --set-upstream-to=origin/minha-feature

44. Limpiar referencias muertas

Quita de tu clon las ramas que ya no existen en el servidor.

git fetch --prune

45. git worktree

Dos ramas abiertas en carpetas distintas al mismo tiempo, sin volver a clonar.

git worktree add ../projeto-hotfix hotfix
git worktree list
git worktree remove ../projeto-hotfix

46. Averiguar la rama actual

Útil dentro de un script y en el prompt del terminal.

git branch --show-current

Merge, rebase y conflictos

Dos formas de integrar el trabajo — y cómo salir del conflicto sin perder nada.

47. git merge

Trae la rama indicada a la actual, creando un commit de merge cuando hace falta.

git switch main
git merge minha-feature

48. Merge fast-forward

Sin divergencia, Git solo adelanta el puntero — historia lineal, sin commit extra.

git merge --ff-only minha-feature

49. Merge siempre con commit

Fuerza el commit de merge, preservando la existencia de la rama en la historia.

git merge --no-ff minha-feature

50. Abortar un merge

Devuelve todo al estado anterior al merge.

git merge --abort

51. Resolver un conflicto

Edita los archivos marcados, quita los marcadores, añádelos y termina.

git status                 # lista los conflictos
# edita los archivos y quita <<<<<<< ======= >>>>>>>
git add arquivo-resolvido.ts
git commit

52. Elegir un lado en el conflicto

Acepta tu versión o la que viene, sin edición manual.

git checkout --ours arquivo.ts    # la versión de la rama actual
git checkout --theirs arquivo.ts  # la versión que está entrando

53. Herramienta visual de merge

Abre el conflicto en una herramienta gráfica configurada.

git mergetool

54. git rebase

Reaplica tus commits encima de otra rama. Deja la historia lineal.

git switch minha-feature
git rebase main

55. Rebase interactivo

Reordena, junta (squash), edita y elimina commits antes de abrir el PR.

git rebase -i HEAD~5

56. Continuar o abortar el rebase

¿Resolviste el conflicto? Continúa. ¿Se complicó? Aborta.

git rebase --continue
git rebase --skip
git rebase --abort

57. git cherry-pick

Lleva un commit concreto a la rama actual — el clásico del hotfix.

git cherry-pick a1b2c3d
git cherry-pick a1b2c3d..e4f5g6h

58. Merge vs rebase: cuándo usar cada uno

Rebase en tu rama antes del PR; merge para integrar en main. Nunca hagas rebase de una rama compartida.

# Bien: actualizar tu feature
git switch minha-feature && git rebase main

# Bien: integrar en la principal
git switch main && git merge --no-ff minha-feature

Trabajar con remotos

Sincronizar tu clon con el servidor — y entender la diferencia entre fetch y pull.

59. Listar remotos

Muestra las direcciones configuradas para descargar y enviar.

git remote -v

60. Añadir un remoto

Conecta el repositorio local con un servidor.

git remote add origin git@github.com:usuario/projeto.git

61. Cambiar la URL del remoto

Se usa al migrar de HTTPS a SSH o al cambiar de organización.

git remote set-url origin git@github.com:usuario/projeto.git

62. git fetch

Descarga las novedades sin tocar tu trabajo. El comando más seguro de Git.

git fetch origin

63. git pull

Es fetch + merge en un solo paso. Trae los cambios y ya los integra en tu rama.

git pull origin main

64. Pull con rebase

Integra reaplicando tus commits por encima — sin un commit de merge por el camino.

git pull --rebase origin main

65. git push

Envía tus commits al servidor.

git push origin main

66. Push la primera vez

-u vincula la rama local con la remota; después basta con git push.

git push -u origin minha-feature

67. Push forzado con seguridad

--force-with-lease se niega si alguien publicó algo que aún no has visto. Prefiérelo siempre a --force.

git push --force-with-lease origin minha-feature

68. Enviar etiquetas

Las etiquetas no suben con un push normal.

git push origin v1.2.0
git push origin --tags

69. Comparar con el remoto

Cuántos commits llevas por delante o por detrás.

git fetch
git status -sb
git log --oneline origin/main..HEAD   # lo que tienes de más

70. Trabajar con un fork (upstream)

Mantiene tu fork al día con el proyecto original.

git remote add upstream https://github.com/original/projeto.git
git fetch upstream
git merge upstream/main

Deshacer (el capítulo que te salva el pellejo)

Casi todo en Git es reversible. La diferencia está en lo que ya se publicó.

71. Descartar los cambios de un archivo

Devuelve el archivo al último commit. Pierdes lo que no se guardó.

git restore arquivo.ts
git checkout -- arquivo.ts   # la forma antigua

72. Descartar todo lo no confirmado

Deja a cero el directorio de trabajo. Úsalo con conciencia.

git restore .

73. Sacar del staging area

Lo quita de lo preparado, pero mantiene el cambio en el archivo.

git restore --staged arquivo.ts
git reset arquivo.ts         # la forma antigua

74. git reset --soft

Deshace el commit y mantiene todo preparado. Ideal para rehacer el mensaje o juntar commits.

git reset --soft HEAD~1

75. git reset --mixed

Deshace el commit y lo saca del staging, preservando los archivos. Es el valor por defecto.

git reset HEAD~1

76. git reset --hard

Deshace el commit y borra los cambios. No tiene deshacer — salvo por el reflog.

git reset --hard HEAD~1

77. git revert

Crea un commit nuevo que deshace otro. Es la forma correcta de revertir algo ya publicado.

git revert a1b2c3d

78. Revertir un merge

Hay que indicar cuál es el lado principal (-m 1).

git revert -m 1 a1b2c3d

79. git reflog — la red de seguridad

Registra todo por donde pasó el HEAD, incluidos los commits perdidos por un reset. Salva casi cualquier situación.

git reflog
git reset --hard HEAD@{2}

80. Recuperar un archivo borrado

Trae de vuelta la versión de un commit concreto.

git restore --source=HEAD~3 arquivo.ts

81. Recuperar una rama borrada

Busca el commit en el reflog y vuelve a crear la rama en él.

git reflog
git branch minha-feature-recuperada a1b2c3d

82. git clean

Borra los archivos no rastreados. Ejecútalo con -n antes para ver qué se iría.

git clean -n        # simula
git clean -fd       # borra archivos y directorios
git clean -fdx      # incluye lo que está en .gitignore

83. Devolver un archivo a un commit antiguo

Solo ese archivo viaja en el tiempo; el resto se queda como está.

git checkout a1b2c3d -- caminho/arquivo.ts

84. Quitar un secreto del historial

Un .env subido sigue en el historial hasta que se reescriba — y el token hay que cambiarlo de todas formas.

git filter-repo --path .env --invert-paths
# después: git push --force-with-lease (acuérdalo antes con el equipo)

Historial e investigación

Descubrir cuándo, por qué y por culpa de qué commit se rompió aquello.

85. git log

El historial. Por sí solo es demasiado verboso — las variaciones de abajo valen más.

git log
git log -5

86. Log en una línea con grafo

La vista más útil: compacta, con las ramificaciones dibujadas.

git log --oneline --graph --decorate --all

87. Filtrar por autor y fecha

Recorta el historial por quién y cuándo.

git log --author="Jhonatan" --since="2 weeks ago"

88. Buscar texto en el código

Encuentra el commit que introdujo (o quitó) un fragmento determinado.

git log -S "getThemeSelection" --oneline

89. Historial de un archivo

Solo los commits que tocaron esa ruta; --follow sigue los renombrados.

git log --follow -p -- src/lib/theme/presets.ts

90. git show

Muestra un commit entero: mensaje, autor y diff.

git show a1b2c3d

91. git blame

Dice quién escribió cada línea y en qué commit. Úsalo para entender, no para culpar.

git blame src/app/page.tsx
git blame -L 40,60 src/app/page.tsx

92. git bisect

Búsqueda binaria en el historial: encuentra en pocos pasos el commit que rompió algo.

git bisect start
git bisect bad                 # el actual está roto
git bisect good v1.0.0         # aquí funcionaba
# prueba, marca good/bad, repite
git bisect reset

93. Quién contribuyó más

Resumen por autor.

git shortlog -sn --all

94. Ver un archivo de otro commit

Sin cambiar de rama ni tocar el directorio.

git show a1b2c3d:src/app/page.tsx

Stash, etiquetas y submódulos

Guardar el trabajo a medias, marcar versiones y reunir repositorios.

95. git stash

Guarda los cambios y limpia el directorio — para cambiar de contexto a toda prisa.

git stash
git stash push -m "meio da refatoração"

96. Recuperar el stash

pop lo aplica y lo quita de la pila; apply lo mantiene guardado.

git stash list
git stash pop
git stash apply stash@{1}

97. Stash incluyendo archivos nuevos

Por defecto el stash ignora lo que no está rastreado.

git stash -u

98. Crear una etiqueta anotada

Marca una versión con autor, fecha y mensaje. Prefiérela a la etiqueta simple.

git tag -a v1.2.0 -m "Release 1.2.0"
git push origin v1.2.0

99. Listar y borrar etiquetas

Borrar exige quitarla local y remotamente.

git tag -l "v1.*"
git tag -d v1.2.0
git push origin --delete v1.2.0

100. Submódulos

Un repositorio dentro de otro, fijado a un commit concreto.

git submodule add https://github.com/usuario/lib.git libs/lib
git submodule update --init --recursive
git clone --recurse-submodules https://github.com/usuario/projeto.git