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

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.

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 le cose ordinarie (che cambiano tra i rami) sia per cose insolite e distruttive (scartando le modifiche nella directory di lavoro).

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

 git diff   

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

 git reset   

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

Un buon stream 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  git checkout -b  

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

 git checkout  git rebase master git checkout master git merge  

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]

 git checkout -- foo 

Questo resetterà foo a HEAD. Puoi anche:

 git checkout HEAD^ foo 

per una revisione indietro, ecc.

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

 git checkout HEAD file/to/restore 

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.

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.

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.

Questo ha funzionato per me:

 git checkout  file 

Quindi commetti la modifica:

 git commit -a 

Devi stare attento quando dici “rollback”. Se avevi una versione di un file in commit $ A, e successivamente apportai due modifiche in due commit separati $ B e $ C (quindi quello che stai vedendo è la terza iterazione del file), e se dici ” Voglio tornare indietro al primo “, lo intendi davvero?

Se vuoi eliminare le modifiche sia della seconda che della terza iterazione, è molto semplice:

 $ git checkout $A file 

e poi tu commetti il ​​risultato. Il comando chiede “Voglio controllare il file dallo stato registrato dal commit $ A”.

D’altra parte, ciò che intendevi è eliminare la modifica della seconda iterazione (es. Commit $ B), mantenendo ciò che commit $ C ha fatto al file, vorrai ripristinare $ B

 $ git revert $B 

Nota che chiunque abbia creato commit $ B potrebbe non essere stato molto disciplinato e potrebbe aver commesso cambiamenti totalmente indipendenti nella stessa commit, e questo ripristino potrebbe toccare file diversi da quelli che vedi modifiche offensive, quindi potresti voler controllare attentamente il risultato dopo averlo fatto così.

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 

Ecco come funziona rebase :

 git checkout  git rebase master git checkout master git merge  

Supponi di avere

 ---o----o----o----o master \---A----B  

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 (che non si trovano nel master ) e li riapplica al capo del master . In altre parole, il genitore del primo commit in non è più un commit precedente nella cronologia master , ma l’attuale head of master . I due comandi sono gli stessi di:

 git rebase master  

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'  

Gli ultimi due comandi …

 git checkout master git merge  

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

 ---o----o----o----o----A'----B' master,  

master e entrambi i riferimenti B' . Inoltre, da questo punto è ansible cancellare il riferimento .

 git branch -d  

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

 git prevision   

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

 git prevision -1 x/y/zc 

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

Qui devo colbind EasyGit , che è un wrapper per rendere il git più accessibile ai novizi senza confondere gli utenti esperti. Una delle cose che fa è dare più significati a git revert . In questo caso, diresti semplicemente:

eg revert foo/bar foo/baz

Nel caso in cui si desideri ripristinare un file con un commit precedente (e il file che si desidera ripristinare già eseguito) è ansible 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.

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.

Primo reset testa per file di destinazione

 git reset HEAD path_to_file 

Secondo Checkout That File

 git checkout -- path_to_file 

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 

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

git checkout ref | commitHash – filePath

per esempio

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

Per me nessuna delle risposte mi è sembrata molto chiara e quindi vorrei aggiungere la mia che sembra super facile.

Ho un commit abc1 e dopo di esso ho fatto diversi (o una modifica) in un file file.txt .

Ora dì che ho incasinato qualcosa nel file file.txt e voglio tornare a un commit precedente abc1 .

1. git checkout file.txt : rimuoverà le modifiche locali, se non ne hai bisogno

2. git checkout abc1 file.txt : questo porterà il tuo file alla versione desiderata

3. git commit -m "Restored file.txt to version abc1" : questo invierà il tuo ritorno.

  1. git push : questo spingerà tutto sul repository remoto

Tra i passaggi 2 e 3 ovviamente puoi fare lo git status per capire cosa sta succedendo. Di solito dovresti vedere il file.txt già aggiunto ed è per questo che non è necessario git add un git add .

Utilizzare git log per ottenere la chiave hash per la versione specifica e quindi utilizzare git checkout

Nota: non dimenticare di digitare l’hash prima dell’ultimo. L’ultimo hash indica la posizione corrente (HEAD) e non modifica nulla.

Ovviamente qualcuno ha bisogno di scrivere un libro comprensibile su git, o git deve essere spiegato meglio nella documentazione. Di fronte a questo stesso problema l’ho intuito

 cd  git revert master 

annullerebbe l’ultimo commit che è sembrato fare.

Ian

Molte risposte qui affermano di usare git reset ... o git checkout ... ma, così facendo, perderai tutte le modifiche su impegnate dopo il commit che vuoi ripristinare.

Se vuoi annullare le modifiche da un solo commit su un solo file, come farebbe git revert ma solo per un file (o dici un sottoinsieme dei file di commit), ti suggerisco di usare entrambi git diff e git apply come quello ( con = l’hash del commit che vuoi ripristinare):

 git diff ^  path/to/file.ext | git apply -R 

Fondamentalmente, prima genererà una patch corrispondente alle modifiche che si desidera ripristinare e quindi applicherà la patch in modo inverso per eliminare tali modifiche.

Ovviamente, non funzionerà se le righe ripristinate sono state modificate da qualsiasi commit tra e HEAD (conflitto).

 git revert  

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.

Puoi farlo in 4 passaggi:

  1. ripristina l’intero commit con il file che vuoi ripristinare in modo specifico – creerà un nuovo commit sul tuo ramo
  2. soft reset che commit – rimuove il commit e sposta le modifiche nell’area di lavoro
  3. selezionare manualmente i file per ripristinarli e confermarli
  4. rilascia tutti gli altri file nell’area di lavoro

Cosa devi digitare nel tuo terminale :

  1. git revert
  2. git reset HEAD~1
  3. git add && git commit -m 'reverting file'
  4. git checkout .

in bocca al lupo

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

  1. albero open source, passare a questo commit

albero open source

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

inserisci la descrizione dell'immagine qui

  1. puoi vedere l’elenco delle tue modifiche in quel commit elenco di file nell'albero dei sorgenti
  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:

scheda dello stato del file

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

inserisci la descrizione dell'immagine qui

Ecco la mia strada.

a) In Android Studio, aprire il file.

b) git -> Mostra cronologia, trova il commit precedente che voglio ripristinare. Ottieni il commit_id (es. Commit hash).

c) git checkout commit_id file_path

Se utilizzi Git Extensions e vuoi solo ripristinare il commit parent per il file, puoi selezionare il commit contenente le modifiche che desideri ripristinare, quindi selezionare la scheda “Diff” nel riquadro dei dettagli, quindi fare clic con il pulsante destro del mouse il file che vuoi ripristinare, quindi ‘Ripristina file su’ …., quindi ‘A’ (il genitore)