Reimposta o ripristina un file specifico per una revisione specifica usando Git?




git revert file (20)

git-alias, awk e shell-funzioni in soccorso!

git prevision <N> <filename>

dove <N> è il numero di revisioni del file da ripristinare per il file <filename> .
Ad esempio, per eseguire il checkout della revisione precedente immediata di un singolo file x/y/zc , eseguire

git prevision -1 x/y/z.c

Come funziona la previsione di git?

Aggiungi quanto segue al tuo gitconfig

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

Il comando fondamentalmente

  • esegue un git log sul file specificato e
  • seleziona il commit-id appropriato nella cronologia del file e
  • esegue un git checkout commit per il file specificato.

In sostanza, tutto ciò che si farebbe manualmente in questa situazione,
avvolto in un git-alias bello ed efficiente - git-prevision

Ho apportato alcune modifiche a un file che è stato impegnato alcune volte come parte di un gruppo di file, ma ora voglio ripristinare / ripristinare le modifiche su di esso su una versione precedente.

Ho fatto un git log insieme a un git diff per trovare la revisione di cui ho bisogno, ma non ho idea di come riportare il file al suo stato precedente in passato.


È possibile rivedere rapidamente le modifiche apportate a un file utilizzando il comando diff:

git diff <commit hash> <filename>

Quindi per ripristinare un file specifico su quel commit usa il comando reset:

git reset <commit hash> <filename>

Potrebbe essere necessario utilizzare l'opzione --hard se si hanno modifiche locali.

Un buon flusso di lavoro per gestire i waypoint consiste nell'utilizzare i tag per contrassegnare in modo pulito i punti nella timeline. Non riesco a capire la tua ultima frase, ma quello che potresti volere è divergere un ramo da un punto precedente nel tempo. Per fare ciò, usa il pratico comando checkout:

git checkout <commit hash>
git checkout -b <new branch name>

Puoi quindi rebase contro la tua linea principale quando sei pronto per unire le modifiche:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

E per ripristinare l'ultima versione confermata, che è più frequentemente necessaria, è possibile utilizzare questo comando più semplice.

git checkout HEAD file/to/restore

Ecco come funziona rebase :

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Supponi di avere

---o----o----o----o  master
    \---A----B       <my branch>

I primi due comandi ... commit git checkout git rebase master

... controlla il ramo delle modifiche che desideri applicare al ramo master . Il comando rebase prende i commit da <my branch> (che non si trovano nel master ) e li riapplica al capo del master . In altre parole, il genitore del primo commit in <my branch> non è più un commit precedente nella cronologia master , ma l'attuale head of master . I due comandi sono gli stessi di:

git rebase master <my branch>

Potrebbe essere più facile ricordare questo comando poiché i rami "base" e "modifica" sono espliciti.

. Il risultato finale della cronologia è:

---o----o----o----o   master
                   \----A'----B'  <my branch>

Gli ultimi due comandi ...

git checkout master
git merge <my branch>

... fai una fusione rapida per applicare tutte <my branch> modifiche <my branch> al master . Senza questo passaggio, il commit di rebase non viene aggiunto al master . Il risultato finale è:

---o----o----o----o----A'----B'  master, <my branch>

master e <my branch> entrambi i riferimenti B' . Inoltre, da questo punto è possibile cancellare il riferimento <my branch> .

git branch -d <my branch>

Ho avuto lo stesso problema solo ora e ho trovato questa risposta più facile da capire ( commit-ref è il valore SHA della modifica nel log in cui vuoi tornare):

git checkout [commit-ref] [filename]

Questo metterà quella vecchia versione nella tua directory di lavoro e da lì puoi impegnarla se vuoi.


In modo divertente, 'git checkout foo' non funzionerà se la copia di lavoro si trova in una directory chiamata foo; tuttavia, sia "git checkout HEAD foo" che "git checkout ./foo":

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Molti suggerimenti qui, la maggior parte sulla git checkout $revision -- $file di git checkout $revision -- $file . Un paio di alternative oscure:

git show $revision:$file > $file

E inoltre, lo uso molto solo per vedere temporaneamente una versione particolare:

git show $revision:$file

o

git show $revision:$file | vim -R -

(OBS: $file deve essere preceduto da ./ se è un percorso relativo per git show $revision:$file to work)

E ancora più strano:

git archive $revision $file | tar -x0 > $file

Nel caso in cui si desideri ripristinare un file con un commit precedente (e il file che si desidera ripristinare già eseguito) è possibile utilizzare

git checkout HEAD^1 path/to/file

o

git checkout HEAD~1 path/to/file

Quindi, basta mettere in scena e impegnare la "nuova" versione.

Armato con la consapevolezza che un commit può avere due genitori in caso di unione, dovresti sapere che HEAD ^ 1 è il primo genitore e HEAD ~ 1 è il secondo genitore.

O funzionerà se c'è un solo genitore nell'albero.


Penso di averlo trovato .... da http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

A volte vuoi solo tornare indietro e dimenticare ogni cambiamento oltre un certo punto perché sono tutti sbagliati.

Iniziare con:

$ git log

che mostra un elenco di commit recenti e i loro hash SHA1.

Quindi, digita:

$ git reset --hard SHA1_HASH

per ripristinare lo stato su un dato commit e cancellare definitivamente tutti i nuovi commit dal record.


Per andare a una precedente versione di commit del file, prendi il numero di commit, ad esempio eb917a1

git checkout eb917a1 YourFileName

Se hai solo bisogno di tornare all'ultima versione impegnata

git reset HEAD YourFileName
git checkout YourFileName

Questo ti porterà semplicemente all'ultimo stato impegnato del file


Primo reset testa per file di destinazione

git reset HEAD path_to_file

Secondo Checkout That File

git checkout -- path_to_file

Puoi usare qualsiasi riferimento a un commit git, incluso SHA-1 se è il più conveniente. Il punto è che il comando si presenta così:

git checkout [commit-ref] -- [filename]



Se sai quanti commit hai bisogno di tornare indietro, puoi usare:

git checkout master~5 image.png

Ciò presuppone che tu sia nel ramo master e che la versione che desideri venga restituita a 5.


Si noti, tuttavia, che git checkout ./foo e git checkout HEAD ./foo non sono esattamente la stessa cosa; esempio:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

(Il secondo add il file nell'indice, ma non viene eseguito il commit).

Git checkout ./foo significa ripristinare il percorso ./foo dall'indice ; aggiungendo HEAD ordina a Git di ripristinare quel percorso nell'indice alla sua revisione HEAD prima di farlo.


Supponendo che l'hash del commit desiderato sia c5f567 :

git checkout c5f567 -- file1/to/restore file2/to/restore

La pagina man di git check dà più informazioni.

Se si desidera ripristinare il commit prima di c5f567 , aggiungere ~1 (funziona con qualsiasi numero):

git checkout c5f567~1 -- file1/to/restore file2/to/restore

Come nota a margine, sono sempre stato a disagio con questo comando perché è usato sia per cose ordinarie (cambiando tra i rami) sia per cose insolite e distruttive (scartando le modifiche nella directory di lavoro).


git checkout ref | commitHash - filePath

per esempio

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

se commetti un file sbagliato nei tuoi ultimi commit segui le istruzioni:

  1. albero open source, passare a questo commit

  1. cambia le linee e trova il tuo commit che il file sbagliato inviato come commit

  1. puoi vedere l'elenco delle tue modifiche in quel commit
  2. selezionalo e quindi fai clic su ... pulsanti a destra ... fai clic su file inverso
  3. quindi puoi vederlo sulla scheda dello stato del file in basso a sinistra, quindi fare clic su nonstage:

  1. apri il codice dello studio visivo e ripristina i file rimossi
  2. dopo di essi, è possibile vedere i risultati nell'ultimo commit nell'albero dei sorgenti


git checkout -- foo

Questo resetterà foo a HEAD. Puoi anche:

git checkout HEAD^ foo

per una revisione indietro, ecc.


git revert <hash>

Ripristina un determinato commit. Sembra che tu pensi che git revert effetto solo sul commit più recente.

Questo non risolve il tuo problema, se vuoi annullare una modifica in un file specifico e che il commit è cambiato più di quel file.







version-control