git add

Instantáneas básicas

Añadir el contenido de los archivos al índice (área de preparación)

El comando 'git add' actualiza el índice con el contenido actual del árbol de trabajo, para preparar el contenido del próximo commit. El índice, también llamado área de preparación, es lo que usas para preparar el contenido del próximo commit. Cuando ejecutas 'git commit' sin otros argumentos, solo se incluyen los cambios preparados. Este comando puede ejecutarse varias veces antes de un commit para ir añadiendo cambios poco a poco.

Sinopsis

git add [--verbose | -v] [--dry-run | -n] [--force | -f] [--interactive | -i] [--patch | -p] [--all | -A] [--update | -u] [--] [<pathspec>...]
[ ] opcional| o<arg> valor a sustituir... repetible--flag opción

Opciones

Haz clic en una opción para desplegarla

Principiante (4)

Preparar todo de una vez: todos los archivos nuevos, modificaciones y borrados de todo tu proyecto.

Cuando haga faltaLo prepara todo, eliminaciones incluidas: revisa antes git status para que no se cuele nada que no quieras

Ejemplo

git add -A

Preparar solo cambios de archivos que Git ya conoce. Los archivos nuevos sin seguimiento se ignoran.

Cuando haga faltaPrepara solo los cambios de archivos con seguimiento: útil cuando los archivos nuevos aún no están listos

Ejemplo

git add -u

Ver exactamente qué archivos se preparan mientras se ejecuta el comando. Muestra cada nombre de archivo a medida que se añade.

Cuando haga faltaMuestra cada archivo según se prepara; útil en add grandes

Ejemplo

git add -v .

Ver lo que se prepararía sin preparar nada. Ideal para comprobarlo antes del commit.

RecomendadoVista previa inofensiva de lo que prepararía un add amplio

Ejemplo

git add -n .

Intermedio (5)

Elegir de forma interactiva qué partes de un archivo preparar. Perfecto para dividir cambios grandes en commits enfocados.

RecomendadoRevisa y prepara exactamente los hunks que pertenecen a este commit

Ejemplo

git add -p

Abrir una interfaz completa con menús para gestionar la preparación. Permite preparar, quitar de la preparación y revisar cambios de forma interactiva.

Cuando haga faltaPreparación por menú; -p cubre casi todo de forma más directa

Ejemplo

git add -i

Preparar un archivo que .gitignore normalmente ignora. Úsalo cuando necesites saltarte las reglas de exclusión.

Cuando haga faltaPrepara archivos ignorados: asegúrate de que el archivo pertenece de verdad al repositorio

Ejemplo

git add -f dist/bundle.js

Anotar que un archivo se añadirá más adelante, sin preparar su contenido. Útil para ver los archivos nuevos en 'git diff'.

Cuando haga faltaHace visibles los archivos nuevos para git diff y add -p antes de prepararlos

Ejemplo

git add -N newfile.js

Silenciar el aviso al añadir un repositorio anidado (una carpeta con su propio .git) al índice. Úsalo cuando de verdad quieras añadir un repositorio git anidado.

No recomendadoNormalmente lo que quieres es git submodule add, no un repositorio anidado sin más

Ejemplo

git add --no-warn-embedded-repo vendor/library

Avanzado (6)

Abrir el diff en tu editor antes de preparar. Puedes elegir a mano qué cambios incluir.

Cuando haga faltaEditar el diff a mano antes de preparar; es fácil producir un patch que no se pueda aplicar

Ejemplo

git add -e app.js

No añadir archivos, solo refrescar su información stat() en el índice. Necesita un pathspec. Útil tras cambios que solo afectan a las marcas de tiempo.

Cuando haga faltaSolo refresca la información de archivos del índice; git status ya lo hace

Ejemplo

git add --refresh .

Seguir añadiendo archivos aunque algunos fallen por errores. El comando igualmente termina con un código distinto de cero.

Cuando haga faltaSalta los archivos que no se pueden añadir; el comando igualmente termina con un código distinto de cero

Ejemplo

git add --ignore-errors .

Comprobar si unos archivos se ignorarían, aunque todavía no existan. Solo funciona con --dry-run.

Cuando haga faltaSolo con --dry-run: comprueba las reglas de exclusión incluso con rutas que no existen

Ejemplo

git add -n --ignore-missing *.tmp

Preparar archivos nuevos y modificados, pero ignorar los archivos eliminados del árbol de trabajo. Alias: --ignore-removal. Solo tiene efecto junto con un pathspec (p. ej. git add --no-all .).

No recomendadoComportamiento antiguo, anterior a 2.0, que deja las eliminaciones sin preparar sin avisar

Ejemplo

git add --no-all .

Generar los fragmentos que muestran -p/-i con <n> líneas de contexto en lugar de las 3 por defecto (o diff.context). Requiere Git 2.51 o posterior; las versiones anteriores lo rechazan con "unknown switch `U'".

Cuando haga faltaMás líneas de contexto en los hunks de add -p: requiere Git 2.51 o posterior

Ejemplo

git add -p -U5 app.js

Experto (6)

Sustituir el bit de ejecución de los archivos añadidos. Usa +x para hacerlos ejecutables y -x para quitarlo.

Cuando haga faltaActiva el bit de ejecución en el índice: útil en Windows

Ejemplo

git add --chmod=+x script.sh

Volver a aplicar el filtro 'clean' a todos los archivos con seguimiento. Útil tras cambiar la configuración de finales de línea.

Cuando haga faltaEjecútalo una vez tras cambiar las reglas de final de línea de .gitattributes

Ejemplo

git add --renormalize .

Permitir actualizar entradas del índice fuera del cono del sparse checkout. Solo para sparse checkouts avanzados.

Cuando haga faltaSolo para repositorios con sparse checkout que editan rutas fuera del cono

Ejemplo

git add --sparse path/outside/cone

Leer las rutas de archivo desde un archivo en lugar de la línea de comandos. Usa '-' para leer de stdin.

Cuando haga faltaPara scripts con muchas rutas; evita los límites de longitud de la línea de comandos

Ejemplo

git add --pathspec-from-file=files.txt

En -p/-i, mostrar el contexto entre fragmentos hasta el número de líneas indicado, fusionando en uno los fragmentos cercanos (0 por defecto, o diff.interHunkContext). Requiere Git 2.51 o posterior.

Cuando haga faltaFusiona hunks cercanos en add -p: requiere Git 2.51 o posterior

Ejemplo

git add -p --inter-hunk-context=5

Se usa con --pathspec-from-file. Los elementos del pathspec se separan con el carácter NUL en lugar de saltos de línea. Admite nombres de archivo con caracteres especiales.

Cuando haga faltaComplemento de --pathspec-from-file para nombres con saltos de línea o caracteres raros

Ejemplo

git add --pathspec-from-file=files.txt --pathspec-file-nul

Elegir la opción adecuada

Comandos de preparación

Qué archivos se preparan con cada comando

ComandoArchivos nuevosArchivos modificadosArchivos borradosAlcance
git add <file>✓✓✓Solo el archivo indicado
git add .✓✓✓Directorio actual y subdirectorios
git add -A✓✓✓Todo el repositorio
git add -u✗✓✓Solo archivos con seguimiento
git add --no-all✓✓✗Ignora los borrados

Opciones interactivas

Opciones para controlar al detalle lo que se prepara

ComandoModoGranularidadCaso de uso
git add -pPatchFragmento a fragmentoPreparar cambios concretos de un archivo
git add -eEditorLínea a líneaEditar el diff a mano antes de preparar
git add -iMenúArchivo a archivoMenú de preparación interactivo completo

Opciones de vista previa y salida

Opciones que muestran información sin modificar el área de preparación

ComandoAcciónModifica el índicePropósito
git add -nDry-run✗Previsualizar lo que se prepararía
git add -vDetallado✓Mostrar los archivos a medida que se preparan
git add --refreshRefrescar✗Actualizar solo la información stat

Archivos especiales

Opciones para archivos que necesitan un trato especial

ComandoGestionaComportamientoUso típico
git add -fArchivos ignoradosSaltarse .gitignoreAñadir un archivo que normalmente se ignora
git add -NArchivos nuevosIntención de añadir (vacío)Seguir un archivo para git diff sin prepararlo
git add --chmod=+xEjecutablesFijar el modo del archivoHacer ejecutables los scripts
git add --sparseArchivos sparseFuera del conoPreparar archivos fuera del sparse checkout

Opciones avanzadas

Opciones de nivel experto para casos concretos

ComandoPropósitoCuándo usarla
git add --renormalizeVolver a aplicar los filtros cleanTras cambiar los finales de línea en .gitattributes
git add --pathspec-from-fileLeer rutas desde un archivoPreparar muchos archivos a partir de una lista
git add --ignore-errorsSeguir pese a los erroresPrepara lo que puedas y salta los fallos
git add --no-warn-embedded-repoSilenciar el aviso de submóduloAñadir repositorios anidados a propósito

Ejemplos de flujos de trabajo

1
git status

Revisar primero todos los cambios

2
git add -A

Preparar todos los archivos nuevos, modificados y borrados

3
git commit -m "Your message"

Hacer commit de todos los cambios preparados

1
git add -p

Elegir de forma interactiva solo los cambios del arreglo (pulsa 'y' en los fragmentos del arreglo y 'n' en los de la funcionalidad)

2
git commit -m "Fix login validation bug"

Hacer commit solo del arreglo

3
git add -A

Preparar ahora los cambios restantes de la funcionalidad

4
git commit -m "Add dark mode toggle"

Hacer commit de la funcionalidad por separado

1
git status

Ver qué está modificado y qué no tiene seguimiento

2
git add -u

Preparar solo las modificaciones de archivos con seguimiento

3
git status

Comprobar que los archivos nuevos siguen sin seguimiento

4
git commit -m "Update existing files"

Hacer commit sin los archivos nuevos

1
git add -n .

El dry-run muestra lo que se añadiría

2
git diff

Revisar en detalle los cambios reales

3
git add .

Si todo está bien, preparar de verdad

1
git add dist/bundle.js

Esto falla: el archivo está ignorado

2
git add -f dist/bundle.js

Forzar el añadido se salta .gitignore

3
git commit -m "Add build for deployment"

Hacer commit del archivo que normalmente se ignora

Teclas del modo interactivo

Atajos de teclado de los modos interactivos de git add. Funcionan en el modo patch (-p) y en el modo interactivo (-i).

Modo patch

-p
yPreparar este fragmento
nNo preparar este fragmento
qSalir; no preparar este fragmento ni los restantes
aPreparar este fragmento y todos los siguientes del archivo
dNo preparar este fragmento ni los siguientes del archivo
sDividir el fragmento actual en fragmentos más pequeños
eEditar a mano el fragmento actual
?Mostrar la ayuda

Modo interactivo

-i
1 / sStatus - mostrar el estado actual de la preparación
2 / uUpdate - elegir los archivos que preparar
3 / rRevert - quitar de la preparación los archivos elegidos
4 / aAdd untracked - añadir archivos nuevos
5 / pPatch - entrar en modo patch con los archivos elegidos
6 / dDiff - mostrar el diff de los cambios preparados
7 / qSalir
8 / hAyuda

Solución de problemas

El archivo no se añade (está ignorado)

Causa: El archivo coincide con un patrón de .gitignore

Busca el patrón que coincide en .gitignore. Usa -f para forzar el añadido si es intencionado.

git add -f <file>

Error «Permission denied»

Causa: El archivo está bloqueado por otro proceso o no tienes permiso de lectura

Cierra las aplicaciones que usan el archivo o revisa sus permisos. Usa --ignore-errors para seguir con los demás archivos.

git add --ignore-errors .

No pasa nada al ejecutar git add

Causa: Puede que los archivos ya estén preparados o que no haya cambios que añadir

Ejecuta git status para ver el estado actual. Los archivos ya preparados no se vuelven a añadir.

git status

Los archivos nuevos no aparecen en git diff

Causa: Los archivos sin seguimiento no aparecen en git diff por defecto

Usa git add -N para marcar la intención de añadir; entonces git diff mostrará el contenido.

git add -N <file> && git diff

Aviso sobre un repositorio git anidado

Causa: Estás añadiendo una carpeta que contiene su propio directorio .git (un repositorio anidado)

Borra la carpeta .git anidada, usa submódulos de git o silencia el aviso.

git add --no-warn-embedded-repo <folder>

Los finales de línea siguen apareciendo como cambios

Causa: Finales de línea incoherentes (CRLF frente a LF) entre tu sistema y el repositorio

Configura .gitattributes con 'text=auto' y renormaliza todos los archivos.

git add --renormalize .

Algunos scripts (p. ej. git diff-files) marcan archivos como modificados aunque el contenido no cambió

Causa: Cambiaron las marcas de tiempo de los archivos, así que la información stat guardada en el índice está desfasada

Refresca el índice para actualizar la información stat sin preparar nada. (git status lo refresca automáticamente.)

git add --refresh .

Consejos y trampas

Buenas prácticas

  • ✓Revisa los cambios antes de prepararlos: usa 'git diff' para ver lo que vas a preparar, o 'git add -p' para revisarlo de forma interactiva.
  • ✓Prepara juntos los cambios relacionados: agrupa en un solo commit los cambios que tienen relación lógica. No mezcles arreglos de bugs con funcionalidades nuevas.
  • ✓Usa 'git add -p' para cambios grandes: si hiciste varios cambios sin relación en un archivo, usa el modo patch para prepararlos por separado.
  • ✓Consulta git status a menudo: ejecuta siempre 'git status' antes y después de preparar para comprobar qué entrará en el commit.
  • ✓Cuidado con 'git add .': prepara todo lo que hay en el directorio actual. Considera indicar nombres de archivo concretos o usar 'git add -p' para tener más control.
  • ✓Configura .gitignore primero: antes de tu primer 'git add', asegúrate de que .gitignore excluye los artefactos de build, las dependencias y los archivos sensibles.
  • ✓Usa dry-run para comprobar: si tienes dudas, usa 'git add -n .' para ver lo que se prepararía sin preparar nada.
  • ✓Prepara los borrados de forma explícita: borrar un archivo en local no prepara el borrado. Usa 'git add -u' o 'git add -A' para incluir los borrados.

Errores comunes

  • ✗'git add .' frente a 'git add -A': los dos preparan archivos nuevos, modificados y borrados, pero '.' solo abarca el directorio actual hacia abajo, mientras que '-A' abarca todo el árbol de trabajo.
  • ✗Olvidar que 'git add' no hace commit. Los archivos solo quedan preparados y necesitan 'git commit' para registrarse.
  • ✗Añadir archivos que deberían ignorarse. Revisa siempre tu .gitignore antes de ejecutar 'git add -A' o 'git add .'
  • ✗No revisar los cambios antes de prepararlos. Usa 'git add -p' para revisar con más cuidado lo que preparas.
  • ✗Confundir 'git add -u' con 'git add -A': '-u' solo prepara modificaciones y borrados de archivos con seguimiento, no archivos nuevos sin seguimiento.

Preguntas frecuentes

A:

Desde Git 2.0 los dos preparan archivos nuevos, modificados y borrados. La diferencia es el alcance: 'git add .' solo abarca el directorio actual y sus subdirectorios, mientras que 'git add -A' abarca todo el repositorio, estés en el directorio que estés.

A:

Probablemente el archivo aparece en .gitignore. Compruébalo con 'git check-ignore <file>'. Si necesitas añadirlo de todos modos, fuérzalo con 'git add -f <file>'.

A:

¡Sí! Usa 'git restore --staged <file>' (o 'git reset HEAD <file>' en versiones antiguas de Git) para quitar un archivo del área de preparación sin perder tus cambios.

A:

Usa 'git add -p <file>' para entrar en el modo patch interactivo. Git te muestra cada cambio (hunk) y te deja elegir cuáles preparar con y/n.

A:

Suele deberse a cambios de final de línea (CRLF/LF) o de permisos. Mira 'git diff' para ver qué cambió. Configura .gitattributes para gestionar los finales de línea.

A:

Añade primero a .gitignore los archivos que quieras excluir y luego usa 'git add .'. Otra opción es añadir los archivos uno a uno o usar patrones como 'git add *.js'.

A:

Le dice a Git que piensas añadir el archivo más adelante. El archivo pasa a tener seguimiento (aparece en git diff), pero su contenido aún no se prepara. Útil para revisar archivos nuevos antes del commit.

A:

No, Git solo sigue archivos, no directorios. El truco habitual es añadir un archivo .gitkeep o .gitignore dentro del directorio vacío.