¿Cómo confirmo solo algunos archivos?

Tengo dos proyectos Uno es el proyecto "oficial" y el segundo es una modificación ligera (se agregaron algunos archivos). Creé una nueva sucursal y les puse nuevos archivos. Pero durante el desarrollo se modifican algunos archivos comunes a ambas ramas.

¿Cómo confirmo solo estos archivos?

Supongo que desea confirmar los cambios en una rama y luego hacer que esos cambios sean visibles en la otra rama. En git no debería haber cambios en la parte superior de HEAD al cambiar de rama.

Confirma solo los archivos modificados por:

git commit [some files]

O si está seguro de que tiene un área de preparación limpia, puede

git add [some files]       # add [some files] to staging area
git add [some more files]  # add [some more files] to staging area
git commit                 # commit [some files] and [some more files]

Si desea que ese compromiso esté disponible en ambas ramas, lo hace

git stash                     # remove all changes from HEAD and save them somewhere else
git checkout <other-project>  # change branches
git cherry-pick <commit-id>   # pick a commit from ANY branch and apply it to the current
git checkout <first-project>  # change to the other branch
git stash pop                 # restore all changes again

Obtenga una lista de los archivos que desea comprometer

$ git status

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

modified:   file1
modified:   file2
modified:   file3
modified:   file4

Agregar los archivos a la puesta en escena

$ git add file1 file2

Revisa para ver qué estás cometiendo

$ git status

Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    modified:   file1
    modified:   file2

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   file3
    modified:   file4

Confirmar los archivos con un mensaje de confirmación

$ git commit -m "Fixed files 1 and 2"

Si accidentalmente comete los archivos incorrectos

$ git reset --soft HEAD~1

Si desea desestabilizar los archivos y comenzar de nuevo

$ git reset

Unstaged changes after reset:
M file1
M file2
M file3
M file4

Puede confirmar algunos archivos actualizados, como este:

git commit file1 file2 file5 -m "commit message"

Algo de esto parece "incompleto"

Los grupos de personas NO sabrán si deben usar comillas, etc.

Agregue 1 archivo específico que muestre las rutas de ubicación también

git add JobManager/Controllers/APIs/ProfileApiController.cs

Commit (recuerde, commit es solo local, no afecta a ningún otro sistema)

git commit -m "your message"  

Presione para repositorio remoto

git push  (this is after the commit and this attempts to Merge INTO the remote location you have instructed it to merge into)

Otras respuestas muestran el alijo, etc., que a veces querrás hacer

Si ya ha almacenado archivos, simplemente elimínelos:

git reset HEAD [file-name-A.ext] [file-name-B.ext]

Luego agréguelos poco a poco nuevamente.

Suponga que realizó cambios en varios archivos, como:

• Archivo1
• File2
• File3
• File4
• File5

Pero solo desea confirmar los cambios de File1 y File3.

Hay dos formas de hacerlo:

1.Estacione solo estos dos archivos, usando:

git add file1 file2

entonces, cometer

git commit -m "your message"

luego empujar,

git push

2.Compromiso directo

git commit file1 file3 -m "my message"

luego empujar,

git push

En realidad, el primer método es útil en caso de que estemos modificando archivos regularmente y organizándolos -> Proyectos grandes, generalmente proyectos en vivo.
Pero si estamos modificando archivos y no organizándolos, entonces podemos hacer una confirmación directa -> Proyectos pequeños

Este es un enfoque simple si no tiene muchos cambios de código:

1. git stash
2. git stash apply
3. remove the files/code you don't want to commit
4. commit the remaining files/code you do want

Luego, si desea el código que eliminó (bits que no confirmó) en una confirmación separada u otra rama, entonces, mientras esté en esta rama, haga lo siguiente:

5. git stash apply
6. git stash

Con el paso 5, ya que aplicó el alijo y confirmó el código que deseaba en el paso 4, la diferencia y sin seguimiento en el alijo recién aplicado es solo el código que eliminó en el paso 3 antes de comprometerse en el paso 4.

Como tal, el paso 6 es un alijo del código que no [deseaba] confirmar, ya que probablemente no quiera perder esos cambios, ¿verdad? Por lo tanto, el nuevo alijo del paso 6 ahora se puede comprometer con esta o cualquier otra rama haciendo que git stash aplique en la rama correcta y confirmando.

Obviamente, esto supone que realiza los pasos en un flujo, si se oculta en cualquier otro punto de estos pasos, deberá anotar la referencia de ocultación para cada paso anterior (en lugar de solo la ocultación básica y aplicar la ocultación más reciente).