Come posso eseguire il commit di solo alcuni file?

Ho due progetti. Uno è il progetto "ufficiale" e il secondo è una leggera modifica (alcuni file aggiunti). Ho creato un nuovo ramo e ho inserito nuovi file. Ma durante lo sviluppo vengono modificati alcuni file comuni ad entrambi i rami.

Come posso impegnare solo questi file?

Suppongo che tu voglia impegnare le modifiche in un ramo e renderle visibili nell'altro ramo. In git non dovresti avere cambiamenti sopra HEAD quando cambi i rami.

Impegni solo i file modificati mediante:

git commit [some files]

O se sei sicuro di avere un'area di stadiazione pulita, puoi farlo

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]

Se vuoi rendere quel commit disponibile su entrambi i rami che fai

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

Ottieni un elenco di file che desideri impegnare

$ 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

Aggiungi i file alla stadiazione

$ git add file1 file2

Controlla per vedere cosa stai commettendo

$ 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

Effettua il commit dei file con un messaggio di commit

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

Se si commettono accidentalmente i file sbagliati

$ git reset --soft HEAD~1

Se si desidera disinstallare i file e ricominciare

$ git reset

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

Puoi eseguire il commit di alcuni file aggiornati, in questo modo:

git commit file1 file2 file5 -m "commit message"

Alcuni di questi sembrano "incompleti"

Gruppi di persone NON sapranno se devono usare le virgolette ecc.

Aggiungi 1 file specifico che mostra anche i percorsi di posizione

git add JobManager/Controllers/APIs/ProfileApiController.cs

Commit (ricorda, il commit è solo locale, non influisce su nessun altro sistema)

git commit -m "your message"  

Premere sul repository remoto

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

Altre risposte mostrano la scorta ecc. Che a volte vorresti fare

Se hai già messo in scena file, è sufficiente disinstallarli:

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

Quindi aggiungerli poco a poco.

Supponiamo di aver apportato modifiche a più file, come:

• file1
• file2
• file3
• file4
• file5

Ma vuoi impegnare solo le modifiche di File1 e File3.

Esistono due modi per farlo:

1. Metti in scena solo questi due file, usando:

git add file1 file2

quindi, commetti

git commit -m "your message"

quindi spingere,

git push

2.Commissione diretta

git commit file1 file3 -m "my message"

quindi spingere,

git push

In realtà il primo metodo è utile nel caso in cui modifichiamo i file regolarmente e li mettiamo in scena -> Grandi progetti, generalmente progetti live.
Ma se stiamo modificando i file e non li stiamo mettendo in scena, allora possiamo fare il commit diretto -> Piccoli progetti

Questo è un approccio semplice se non hai molte modifiche al codice:

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

Quindi se vuoi il codice che hai rimosso (bit che non hai eseguito il commit) in un commit separato o in un altro ramo, mentre sei ancora su questo ramo fai:

5. git stash apply
6. git stash

Con il passaggio 5 poiché hai già applicato lo stash e hai eseguito il commit del codice desiderato nel passaggio 4, il diff e non tracciato nello stash appena applicato è solo il codice rimosso nel passaggio 3 prima di eseguire il commit nel passaggio 4.

In quanto tale passaggio 6 è una scorta del codice che non [si desidera] commettere, poiché probabilmente non si vuole davvero perdere quelle modifiche, giusto? Quindi la nuova scorta del passaggio 6 ora può essere impegnata in questo o in qualsiasi altro ramo facendo applicare git stash sul ramo corretto e impegnandosi.

Ovviamente questo presuppone che tu esegua i passaggi in un flusso, se riponi in qualsiasi altro punto in questi passaggi dovrai annotare lo stash ref per ogni passaggio sopra (piuttosto che solo lo stash di base e applicare lo stash più recente).