Diferencia entre "git add -A" y "git add".

El comando git add [--all|-A]parece ser idéntico a git add .. ¿Es esto correcto? Si no, ¿en qué se diferencian?

Esta respuesta sólo se aplica a Git versión 1.x . Para Git versión 2.x, vea otras respuestas.

Resumen:

• git add -Aetapas todos los cambios

• git add .organiza nuevos archivos y modificaciones, sin eliminaciones

• git add -urealiza modificaciones y eliminaciones, sin archivos nuevos

Detalle:

git add -Aes equivalente a git add .; git add -u.

El punto importante git add .es que mira el árbol de trabajo y agrega todas esas rutas a los cambios organizados si se cambian o son nuevos y no se ignoran, no realiza ninguna acción 'rm'.

git add -umira todos los archivos ya rastreados y organiza los cambios en esos archivos si son diferentes o si se han eliminado. No agrega ningún archivo nuevo, solo realiza cambios en los archivos ya rastreados.

git add -A es un atajo útil para hacer ambas cosas.

Puede probar las diferencias con algo como esto (tenga en cuenta que para Git versión 2.x su salida git add . git status será diferente):

git init
echo Change me > change-me
echo Delete me > delete-me
git add change-me delete-me
git commit -m initial

echo OK >> change-me
rm delete-me
echo Add me > add-me

git status
# Changed but not updated:
#   modified:   change-me
#   deleted:    delete-me
# Untracked files:
#   add-me

git add .
git status

# Changes to be committed:
#   new file:   add-me
#   modified:   change-me
# Changed but not updated:
#   deleted:    delete-me

git reset

git add -u
git status

# Changes to be committed:
#   modified:   change-me
#   deleted:    delete-me
# Untracked files:
#   add-me

git reset

git add -A
git status

# Changes to be committed:
#   new file:   add-me
#   modified:   change-me
#   deleted:    delete-me

Aquí hay una tabla para una comprensión rápida:

Git Versión 1.x :

Git Versión 2.x :

Banderas de forma larga:

• git add -A es equivalente a git add --all
• git add -u es equivalente a git add --update

Otras lecturas:

• Git para principiantes: la guía práctica definitiva
• ¿Tienes 15 minutos y quieres aprender Git? (de forma interactiva)
• Aprenda la ramificación de Git
• Explicar Git con D3

Con Git 2.0, git add -Aes predeterminado: git add .igualgit add -A . .

git add <path>es lo mismo que " git add -A <path>" ahora, de modo que " git add dir/" notará las rutas que eliminó del directorio y registrará la eliminación.
En versiones anteriores de Git, " git add <path>" ignoraba las eliminaciones.

Puede decir " git add --ignore-removal <path>" para agregar solo rutas agregadas o modificadas <path>, si realmente lo desea.

git add -Aes como git add :/( agregar todo desde la carpeta superior de repositorio de git ).
¡Tenga en cuenta que git 2.7 (noviembre de 2015) le permitirá agregar una carpeta llamada " :"!
Ver commit 29abb33 (25 oct 2015) por Junio ​​C Hamano ( gitster) .

Tenga en cuenta que al iniciar git 2.0 (Q1 o Q2 2014) , cuando se habla de git add .(ruta actual dentro del árbol de trabajo), también debe usar ' .' en los otros git addcomandos.

Eso significa:

" git add -A ." es equivalente a " git add .; git add -u ."

(Tenga en cuenta el extra ' .' para git add -Ay git add -u)

Porque git add -Ao git add -ufuncionaría (comenzando solo git 2.0) en todo el árbol de trabajo , y no solo en la ruta actual.

Esos comandos funcionarán en todo el árbol en Git 2.0 para mantener la coherencia con " git commit -a" y otros comandos . Debido a que no habrá ningún mecanismo para hacer que " git add -u" se comporte como si " git add -u .", es importante para aquellos que están acostumbrados a " git add -u" (sin especificación de ruta) actualizar el índice solo para las rutas en el subdirectorio actual para comenzar a entrenar sus dedos para decir explícitamente " git add -u ."cuando lo dicen en serio antes de que llegue Git 2.0.

Se emite una advertencia cuando estos comandos se ejecutan sin una especificación de ruta y cuando tiene cambios locales fuera del directorio actual , porque el comportamiento en Git 2.0 será diferente de la versión actual en tal situación.

Según las instrucciones de Charles , después de probar mi comprensión propuesta sería la siguiente:

# For the next commit
$ git add .   # Add only files created/modified to the index and not those deleted
$ git add -u  # Add only files deleted/modified to the index and not those created
$ git add -A  # Do both operations at once, add to all files to the index

Esta publicación de blog también puede ser útil para comprender en qué situación se pueden aplicar esos comandos: Eliminar archivos eliminados de su directorio de trabajo de Git .

Las cosas cambiaron con Git 2.0 ( 28/05/2014 ):

• -A ahora es el predeterminado
• El comportamiento anterior ahora está disponible con --ignore-removal.
• git add -uy git add -Aen un subdirectorio sin caminos en la línea de comando operan en todo el árbol.

Entonces, para Git 2, la respuesta es:

• git add .y git add -A .agregue archivos nuevos / modificados / eliminados en el directorio actual
• git add --ignore-removal . agrega archivos nuevos / modificados en el directorio actual
• git add -u . agrega archivos modificados / eliminados en el directorio actual
• Sin el punto, agregue todos los archivos en el proyecto independientemente del directorio actual.

Una respuesta rápida más destilada:

¿Ambos a continuación (igual que git agrega --todos )

git add -A

Etapas de archivos nuevos + modificados

git add .

Etapas modificadas + archivos eliminados

git add -u

En Git 2.x :

• Si está ubicado directamente en el directorio de trabajo , entonces git add -Ay git add .trabaje sin la diferencia.

• Si está en algún subdirectorio del directorio de trabajo , git add -Aagregará todos los archivos de todo el directorio de trabajo y git add .agregará archivos de su directorio actual .

Y eso es todo.

Espero que esto pueda agregar más claridad.

!The syntax is
git add <limiters> <pathspec>
! Aka
git add (nil/-u/-A) (nil/./pathspec)

Los limitadores pueden ser -u o -A o nulo.

Pathspec puede ser una ruta de archivo o punto, '.' para indicar el directorio actual.

Conocimientos previos importantes sobre cómo Git 'agrega':

• Los archivos invisibles, aquellos prefijados con un punto, (dotfiles) nunca son reconocidos automáticamente por Git. Ni siquiera se enumeran como "sin seguimiento".
• Git nunca agrega carpetas vacías. Ni siquiera se enumeran como "sin seguimiento". (Una solución alternativa es agregar un archivo en blanco, posiblemente invisible, a los archivos rastreados).
• El estado de Git no mostrará información de subcarpetas, es decir, archivos sin seguimiento, a menos que se rastree al menos un archivo en esa subcarpeta. Antes de ese momento, Git considera que la carpeta completa está fuera de alcance, a la 'vacía'. Está vacío de elementos rastreados.
• Especificando una especificación de archivo = '.' (punto), o el directorio actual, no es recursivo a menos -Aque también se especifique. El punto se refiere estrictamente al directorio actual: omite las rutas que se encuentran arriba y abajo.

Ahora, dado ese conocimiento, podemos aplicar las respuestas anteriores.

Los limitadores son los siguientes.

• -u= --update= subconjunto a archivos rastreados => Agregar = No; Cambio = Sí; Eliminar = Sí => si se rastrea el artículo.
• -A= --all(no existe -a, lo que da un error de sintaxis) = superconjunto de todos los archivos no rastreados / rastreados, a menos que en Git antes de 2.0, en el que si se proporciona la especificación de archivos de puntos, solo se considera esa carpeta en particular. => si se reconoce el elemento, git add -Alo encontrará y lo agregará.

La ruta de acceso es la siguiente.

• En Git antes de 2.0, para los dos limitadores (actualización y todo), el nuevo valor predeterminado es operar en todo el árbol de trabajo, en lugar de la ruta actual (Git 1.9 o anterior),
• Sin embargo, en v2.0, la operación puede limitarse a la ruta actual: simplemente agregue el sufijo de punto explícito (que también es válido en Git 1.9 o anterior);

git add -A .

git add -u .

En conclusión, mi política es:

1. Asegúrese de que se tengan en cuenta los trozos / archivos que se agregarán git status.
2. Si falta algún elemento, debido a archivos / carpetas invisibles, agréguelos por separado.
3. Tenga un buen .gitignorearchivo para que normalmente solo los archivos de interés no sean rastreados y / o no reconocidos.
4. Desde el nivel superior del repositorio, "git add -A" para agregar todos los elementos. Esto funciona en todas las versiones de Git.
5. Elimine los elementos deseados del índice si lo desea.
6. Si hay un gran error, haga 'git reset' para borrar el índice por completo.

git add . es igual git add -A . agrega archivos al índice solo de las carpetas actuales y secundarias.

git add -A agrega archivos al índice de todas las carpetas en el árbol de trabajo.

PD: la información se relaciona con Git 2.0 (2014-05-28).

Ambos git add .y git add -Apresentarán todos los archivos nuevos, modificados y eliminados en las versiones más nuevas de Git.

La diferencia es que git add -Acoloca los archivos en "subdirectorios superiores, actuales y" que pertenecen a su repositorio Git de trabajo. Pero hacer git add .solo las etapas de los archivos en el directorio actual y los subdirectorios que lo siguen ( no los archivos que se encuentran fuera, es decir, los directorios superiores).

Aquí hay un ejemplo:

/my-repo
  .git/
  subfolder/
    nested-file.txt
  rootfile.txt

Si el directorio de trabajo actual es /my-repo, y usted rm rootfile.txt, a continuación cd subfolder, seguido por git add ., entonces no stage El archivo borrado. Pero hacerlo git add -Aciertamente organizará este cambio sin importar desde dónde ejecute el comando.

La -Aopción agrega, modifica y elimina entradas de índice para que coincidan con el árbol de trabajo.

En Git 2, la -Aopción ahora es la predeterminada.

Cuando .se agrega una que limita el alcance de la actualización al directorio en el que se encuentra actualmente, según la documentación de Git

Si no <pathspec>se da cuando se usa la opción -A, todos los archivos en todo el árbol de trabajo se actualizan (las versiones anteriores de Git se usan para limitar la actualización al directorio actual y sus subdirectorios).

Una cosa que agregaría es que si se usa el modo --interactiveo -p, entonces git addse comportará como si -use usara el indicador update ( ) y no se agreguen nuevos archivos.