Trovare e ripristinare un file eliminato in un repository Git

Dire che mi trovo in un repository Git. Elimina un file e impegnarsi che cambia. Io continuare a lavorare e fare un commit. Poi io trovo che ho bisogno di ripristinare il file.

So che posso checkout di un file utilizzando git checkout HEAD^ foo.bar, ma io non so davvero se il file è stato eliminato.

  1. Quale sarebbe il modo più rapido per trovare il commit che ha cancellato un nome di file specificato?
  2. Quale sarebbe il modo più semplice per ottenere il file nella mia copia di lavoro?

Spero che non devo selezionare manualmente i miei log, checkout l’intero progetto per un dato SHA e quindi copiare manualmente il file nel mio progetto originale di checkout.

  • nota che il commento precedente, la risposta alla domanda nel titolo, non nel corpo, che comprende la ricerca di quando il file è stato eliminato.
  • Per trovare il commit di un file è stato eliminato in: git log --diff-filter=D -- path/to/file
  • Correlate: Come si fa a scartare unstaged modifiche in git?.
  • Correlate: Come individuare un file eliminato nel commit storia
  • Correlate: come ripristinare tutti i file cancellati in una sola volta
  • non funziona, ottengo errore: pathspec ‘./src/main/resources/file’ non corrisponde con nessun file(s) conosciuto per git.
  • git checkout deletedFile sarà undelete deletedFile se è stato cancellato, ma che la cancellazione non è ancora stato messo in scena o commesso. Che non è quello il problema qui è che chiede; questa domanda è su come ripristinare un file, la cui eliminazione è stato commesso molti si impegna fa.

InformationsquelleAutor avdgaag | 2009-06-04



23 Replies
  1. 3001

    Trovare l’ultimo commit che ha interessato il percorso. Il file non è nella TESTA di commit, questo commit deve avere eliminato.

    git rev-list -n 1 HEAD -- <file_path>
    

    Estrazione quindi la versione a impegnarsi prima, con l’accento circonflesso (^) simbolo:

    git checkout <deleting_commit>^ -- <file_path>
    

    O in un comando, se $file è il file in questione.

    git checkout $(git rev-list -n 1 HEAD -- "$file")^ -- "$file"
    

    Se si utilizza zsh e hanno il EXTENDED_GLOB opzione è attivata, il simbolo di accento circonflesso non funziona. È possibile utilizzare ~1 invece.

    git checkout $(git rev-list -n 1 HEAD -- "$file")~1 -- "$file"
    
    • Il difficile bit è a pagamento il commit PRIMA, tramite ^ suffisso. Grazie.
    • Per qualche ragione, questo non funziona in zsh. ± git checkout $(git rev-list -n 1 HEAD "spec/Sporkfile_example.rb")^ -- "spec/Sporkfile_example.rb" zsh: no matches found: b71c152d8f38dcd23ad7600a93f261a7252c59e9^ Ho acceso la bash & ha funzionato bene.
    • Ho dovuto usare git checkout <deleting_commit>^^ — <file_path> per qualche motivo-forse una riga di comando di windows cosa
    • Da riga di comando di windows ho ottenuto un errore. error: pathspec <filename> did not match any file(s) known to git.. La soluzione era quella di usare git bash.
    • zsh ha la propria espansione sul ‘^’ io credo, ma è possibile utilizzare la sintassi alternativa di ‘~1’: git checkout <deleting-commit>~1 -- <file-path> ~X consente di specificare X impegna prima specificato commettere, così ~1 è il commit prima, ~2 è due commit prima, ecc
    • Si può anche sfuggire l’ ^ con \^
    • BTW, se si utilizza il pesce, il comando viene interrotto e deve sfugge, o solo il fuoco di una shell bash.
    • La finestra di github comando cliente sulla base di Powershell risposto con fatale: ambiguo argomento <file_path>: unknown revisione o di un percorso e non la directory di lavoro. Utilizzare ‘–‘ per separare i percorsi di revisioni, come questo: ‘git <comando> [<revisione>…] — [<file>…]” La risposta di @Robert Munteanu ha funzionato per me.
    • Luxton grazie. per qualche motivo il carato notazione non ha funzionato per me, mentre su una piattaforma win7, ma tilde fatto.
    • Vale la pena notare che la sintassi della riga non funziona sotto Windows. Dal momento che questo è un molto popolare Q&A (e la prima voce in Google), si suggerisce di aggiornare la risposta per dire questo (+ i ^ sostituito con ~1 di cui sopra).
    • Quali sono i doppi trattini, --, per?
    • Su windows cmd prompt, il ^ è il carattere di escape! Pertanto, su comando, digitare ^^ dire cmd si desidera un unico letterale ^ e che non è il tuo sfuggire a qualcosa d’altro dopo di esso. Che cosa succede a molte persone è che la ^ è seguita da uno spazio. Così cmd crede che tu stia scappando spazio — che produce semplicemente un carattere di spazio. Così, per il momento git ottiene il cli argomenti, si vede SHA1 e non SHA1^. È davvero fastidioso. ~ non è un carattere di escape, così che funziona ancora. (PS. se pensi che googler vogliamo queste info, per favore vota questo commento)
    • grazie mille, ancora non riusciva a capire perché stiamo verificando il padre di commettere? che cosa significa essere un genitore di un commesso?
    • se ci sono più file eliminati nel commit, e voglio farli tutti? basta ripetere il comando più volte?
    • Il padre del commit di eliminare il file desiderato è l’ultimo commit contenente il file, così garantita l’ultima versione del file. Il “padre” della nomenclatura deriva dal git strutturazione di commit in un albero, in cui si impegna sono i nodi e il commit precedente altro commit è il nodo padre del nodo figlio. (Compsci 101, mi sorprende ancora.)
    • Per chiunque altro chiedendo circa il doppio trattino, --, è quello di separare i nomi dei file da git opzioni. Non è strettamente necessaria, se non si specificano i nomi di file che effettivamente fare un aspetto, come git opzioni.
    • 3a comando è la chiave. Grazie!
    • Attenzione che si dovrebbe eseguire da root del vostro repository, perché altrimenti percorso del file non verrà riconosciuta. Ho trascorrere diversi minuti fino a quando ho capito che in realtà io sono in una sottocartella, quindi questo è il motivo per cui non funziona.
    • Secondo comando mi butta un assurdo errore “impossibile creare il file www/index.php: Permesso negato” anche se ho eseguito console come Amministratore.
    • Ho “nessuna corrispondenza trovata: COMMITHASH^”. La risposta qui sotto funziona per me.

  2. 821
    1. Utilizzare git log --diff-filter=D --summary per ottenere tutti i commit che hanno eliminato i file e i file cancellati;
    2. Utilizzare git checkout $commit~1 path/to/file.ext per ripristinare il file eliminato.

    Dove $commit è il valore del commit che hai trovato nel passaggio 1, ad esempio, e4cf499627

    • curioso, che cosa fa l’ ~1 riferimento?
    • la tilde spec vi darà l’ennesimo nipote del nome di commit . Vedere book.git-scm.com/4_git_treeishes.html per maggiori dettagli .
    • questo è il più semplice e intuitivo. git log -- *PartOfMyFileName*. Grazie per la $commit~1
    • Non so cosa $commit, ho usato HEAD invece. Tuttavia ha funzionato per me.
    • il git checkout $commit~1 filename opere sintassi perfetta per i singoli file, e funziona anche per tutta la directory. vale a dire: per ripristinare le immagini cancellate in ./immagini da sha 12345: git checkout 12345~1 images. grazie per questa risposta!
    • significa che si deve aggiungere il nome del commit. Qualcosa di simile 1d0c9ef6eb4e39488490543570c31c2ff594426c dove $commit è.
    • Non l’id della commit essere quello di prima il file è stato eliminato? Sembra che se metti l’id della commit che il file è stato eliminato in git non riesco a trovarlo.
    • Se avete solo bisogno di controllare il contenuto del file: git show $commit~1:$path
    • Questa è una grande risposta, ma “$commit” è super-confusione. 🙁
    • Ho aggiornato la domanda per spiegare che cosa “$commit” è. Fa che aiutare?
    • è il “$commit” valore impostato automaticamente il primo passo (git log…) o che è solo un posto di titolare a segnare il punto in cui si dovrebbe modificare il comando?

  3. 310

    Per ripristinare tutti i file cancellati in una cartella, immettere il comando seguente.

    git ls-files -d | xargs git checkout --
    
    • Dove il file di ottenere reindirizzato a? Non vedo nessun cambiamento.
    • Questo è probabilmente il metodo più semplice. La sua perversa quanto sia difficile git ha fatto i compiti più semplici.
    • cosa significa — ?
    • git checkout — [file] e ripristinare le modifiche nel menu [file]. Il tubo andrà a sostituire [file] con il nome del file eliminati.
    • Il ls-files sub-comando è a portata di mano, ma non sembra funzionare per i file che erano stati rimossi con git rm cioè la messa in scena, figuriamoci commesso, che è quello che l’OP ha chiesto.
    • Questo ha funzionato per il ripristino di file eliminati, ma come posso aggiornare i file che modificate e vedi come M myChangedFile dopo git checkout?
    • dopo un git checkout di un file, esso non mostra, come modificato. Si passa all’ultimo stato commesso. Non è possibile ripristinare le modifiche che non sono ancora impegnati.

  4. 119

    Sono venuto a questa domanda cercando di ripristinare un file che ho eliminato, ma non avevo ancora fatto il commit dei cambiamenti. Solo nel caso in cui vi trovate in questa situazione, tutto quello che dovete fare è la seguente:

    git checkout HEAD -- path/to/file.ext

  5. 89

    Se tu sei pazzo, utilizzare git bisect. Ecco cosa fare:

    git bisect start
    git bisect bad
    git bisect good <some commit where you know the file existed>
    

    Ora è il momento di eseguire il test automatico. Il comando di shell '[ -e foo.bar ]' restituisce 0 se foo.bar esiste, e 1 contrario. Il comando “esegui” di git-bisect utilizzare binario di ricerca per trovare automaticamente il primo commit in cui il test ha esito negativo. Si inizia a metà strada attraverso l’intervallo di date (da buono a cattivo) e la tagli a metà, in base al risultato del test specificata.

    git bisect run '[ -e foo.bar ]'
    

    Ora sei a commettere, che ha eliminato. Da qui, si può saltare ritorno al futuro e utilizzare git-revert per annullare la modifica,

    git bisect reset
    git revert <the offending commit>
    

    o si potrebbe andare indietro di un commit e controllare manualmente i danni:

    git checkout HEAD^
    cp foo.bar /tmp
    git bisect reset
    cp /tmp/foo.bar .
    
    • Puoi spiegarti meglio git bisect run '[ -e foo.bar ]'?
    • È inoltre possibile utilizzare il bene e il male manualmente, se si tratta di qualcosa che non può essere controllata automaticamente. Vedere la bisecare pagina man.
    • il git bisect run dice a Git per automatizzare bisezione eseguendo il comando seguente parola ‘eseguire’, dove il comando deve restituire 0 per un good versione (vedi git help bisect per i dettagli). Il '[ -e foo.bar ]' è una espressione standard per il test, se il file foo.bar non esiste (l’implementazione di solito è nel file /usr/bin/[ che di solito è un collegamento fisico a /usr/bin/test) e il singolo quation marchi sono utilizzati per mettere il tutto come un unico argomento della riga di comando.
    • Grande idea. Ho provato questo approccio e ha identificato un commit prima dell’eliminazione, ma non la conferma che effettivamente eliminato il file. E in un altro test ha individuato 2 si impegna prima della cancellazione.
  6. 71

    Il mio nuovo preferito alias, basato su bonyiii‘s risposta (con voto positivo), e la mia risposta è “Il passaggio di un argomento per un Git alias di comando“:

    git config alias.restore '!f() { git checkout $(git rev-list -n 1 HEAD -- $1)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- $1)~1 | grep '^D' | cut -f 2); }; f'
    

    Ho perso un file cancellato per errore un paio di commit fa?

    Veloce:

    git restore my_deleted_file
    

    Crisi scongiurata.


    Robert Dailey propone nei commenti i seguenti alias:

    restore-file = !git checkout $(git rev-list -n 1 HEAD -- "$1")^ -- "$1"
    

    E jegan aggiunge nei commenti:

    Per impostare l’alias da riga di comando, ho usato questo comando:

    git config --global alias.restore "\!git checkout \$(git rev-list -n 1 HEAD -- \"\$1\")^ -- \"\$1\"" 
    
    • Questo consente di ripristinare l’intero impegnarsi, non solo il file richiesto.
    • Qui è il mio alias, funziona a meraviglia: restore-file = !git checkout $(git rev-list -n 1 HEAD -- "$1")^ -- "$1"
    • Che sembra grande! Ho inserito il tuo alias la risposta per una maggiore visibilità.
    • git: “ripristinare” non è un comando git.
    • se è stato impostato il git config alias.restore prima.
    • Per impostare l’alias da riga di comando, ho usato questo comando: git config --global alias.restore "\!git checkout \$(git rev-list -n 1 HEAD -- \"\$1\")^ -- \"\$1\""
    • Grazie. Ho inserito il tuo commento in risposta per una maggiore visibilità.
    • Expansion of alias 'restore' failed; '!git' is not a git command
    • Che OS/shell digita questo?
    • Mac (Bash)! Ifyou basta mettere qualche info in più in modo che questa è una soluzione linux, sarebbe bello^^
    • Non sono sicuro, ma si può almeno modificare il git di configurazione globale (git config –global –edit) e mettete la linea restore = !git checkout $(git rev-list -n 1 HEAD -- "$1")^ -- "$1"
    • Questo è grande. Per la GUI posso fare Github Desktop fare clic destro sulla impegnarmi e fare “ripristinare questo commit”

  7. 48

    Se si conosce il nome, questo è un modo semplice con i comandi di base:

    Elenco di tutti i commit del file.

    git log -- path/to/file
    

    L’ultimo commit (superiore) è quella che ha cancellato il file. Quindi, è necessario ripristinare il secondo e ultimo commit.

    git checkout {second to last commit} -- path/to/file
    
    • Appena usato questa soluzione e non c’era nessun impegnarsi per l’eliminazione. Sono stato in grado di ripristinare i file utilizzando la più recente commettere id però.
    • +10 per il second to last commit il chiarimento!
    • Non l’ultimo commit (precedente impegnarsi per l’eliminazione) contengono la versione più recente del file cancellato? Secondo-a-ultima (il commit prima di commit precedente per l’eliminazione) potrebbe essere irrimediabilmente obsoleto.
    • Questa è la prima soluzione ho visto che è abbastanza semplice che non devo venire qui per trovare di volta in volta. Forse.
    • per ultimo” significa “commit precedente alla cancellazione”, la stessa della “penultima”. en.wiktionary.org/wiki/penultimate#Synonyms
  8. 29

    Per ripristinare un eliminato e riuscita del file:

    git reset HEAD some/path
    git checkout -- some/path
    

    È stato testato sulla versione Git 1.7.5.4.

    • Che non ha funzionato per me. Dopo il checkout, ho avuto error: pathspec 'foo' did not match any file(s) known to git. ho fatto in modo che il nome del file corretto. Git versione 2.7.0
    • -1; questo è sbagliato. Questi comandi si annulla un’eliminazione che non è ancora stata impegnata (la prima unstages la cancellazione, se è in scena, e la seconda rigetti unstaged modifiche al file), ma stai sostenendo qui che il ripristino di un commit eliminazione del file, che semplicemente non è vero e non riesce con un errore come quello di @wisbucky il commento di sopra.
    • Infatti, credo che questo comando ha funzionato bene per gli sviluppatori, che non hanno fatto esplicita di gestione temporanea per commettere per i file rimossi con git add -A, ma in modo che il file ripristinato era ancora non impegnati fase.
  9. 25

    Se hai solo modificato e cancellato un file, ma non l’ha commesso, e ora che hai rotto con le tue modifiche

    git checkout -- .
    

    ma i file eliminati non ritorno, è sufficiente eseguire il seguente comando:

    git checkout <file_path>
    

    E presto, il file è tornato.

  10. 23

    Ho questa soluzione.

    1. Ottenere l’id di commettere in cui il file è stato eliminato utilizzando uno dei modi di seguito.

      • git log --grep=*word*
      • git log -Sword
      • git log | grep --context=5 *word*
      • git log --stat | grep --context=5 *word* # raccomandato se è poco
        ricordare nulla
    2. Si dovrebbe ottenere qualcosa di simile:

    commettere bfe68bd117e1091c96d2976c99b3bcc8310bebe7 Autore: Alexander
    Orlov Data: Thu May 12 23:44:27 2011
    +0200

    replaced deprecated GWT class
    - gwtI18nKeySync.sh, an outdated (?, replaced by a Maven goal) I18n generation script
    

    commettere 3ea4e3af253ac6fd1691ff6bb89c964f54802302 Autore: Alexander
    Orlov Data: Thu May 12 22:10:22 2011
    +0200

    3. Ora, usando il commit id bfe68bd117e1091c96d2976c99b3bcc8310bebe7 fare:

    git checkout bfe68bd117e1091c96d2976c99b3bcc8310bebe7^1 yourDeletedFile.java
    

    Come commit id riferimenti commit in cui il file è stato già eliminato, è necessario fare riferimento al commit poco prima bfe68b che si può fare aggiungendo ^1. Questo significa: dammi il commit poco prima bfe68b.

    • Questo è lo stesso approccio accettato di rispondere, ma con alcuni altri modi per trovare l’eliminazione di commettere. Mi piace ancora l’approccio adottato nella accettato risposta, ma queste sono buone alternative. Grazie!
    • Presumo che prima di verificare che il file cancellato e quindi (senza modificarlo) commettere è non creare un copia del file. Giusto? (Ho bisogno di fare questo con le immagini, e una copia renderebbe il più grande repository)
  11. 15
    git checkout /path/to/deleted.file
    
    • Non funziona, dal momento che la cancellazione è stata commessa.
    • Questo per la mia situazione (rimosso involontariamente) era la soluzione più semplice.
  12. 12

    git undelete path/to/file.ext

    1. Mettere questo nel .bash_profile (o qualunque altro tipo di file che viene caricato quando si apre una shell di comando):

      git config --global alias.undelete '!sh -c "git checkout $(git rev-list -n 1 HEAD -- $1)^ -- $1" -'
      
    2. Quindi utilizzare:

      git undelete path/to/file.ext
      

    Questo alias controlla prima di trovare l’ultimo commit dove questo file esiste, allora, un git checkout di percorso del file da ultimo commit dove questo file esiste. fonte

    • Wow. Solo wow. Questo è un risparmiatore di vita
  13. 11

    In molti casi, può essere utile l’uso di coreutils (grep, sed, etc.) in collaborazione con Git. So già questi strumenti abbastanza bene, ma Git meno. Se ho voluto fare una ricerca per un file eliminato, vorrei fare la seguente:

    git log --raw | grep -B 30 $'D\t.*deleted_file.c'
    

    Quando trovo la revisione/commit:

    git checkout <rev>^ -- path/to/refound/deleted_file.c
    

    Proprio come altri hanno detto prima di me.

    Il file sarà ora ripristinato allo stato in cui era prima della rimozione. Ricordarsi di ri-commettere l’albero di lavoro, se si desidera mantenere intorno.

  14. 7

    Così ho dovuto ripristinare un mucchio di file cancellati da un commit e mi è riuscito con due comandi:

    git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git checkout <rev>^ -- 
    git show <rev> --diff-filter=D --summary --name-only --no-commit-id | xargs git reset HEAD 
    

    (Nota lo spazio finale alla fine di ogni comando.)

    I file erano stati aggiunti alla .gitignore file e poi cancellato con git rm, avevo bisogno di ripristinare i file, ma poi unstage loro. Ho avuto centinaia di file per il ripristino, digitando le cose manualmente per ogni file, come in altri esempi stava per essere troppo lento.

  15. 6

    In realtà, questa domanda è direttamente Git, ma qualcuno, come me, lavora con gli strumenti grafici come WebStorm VCS oltre a sapere git cli comandi.

    Fare il percorso che contiene il file eliminato, poi vai a Git e quindi fare clic su Show History.

    Trovare e ripristinare un file eliminato in un repository Git

    VCS strumenti mostra tutte le revisioni treno e posso vedere tutti i commit e modifiche di ciascuno di essi.

    Trovare e ripristinare un file eliminato in un repository Git

    Quindi il commit che il mio amico eliminare il PostAd.js file. ora vedi di seguito:

    Trovare e ripristinare un file eliminato in un repository Git

    E ora, posso vedere il mio desiderio di file cancellati. Mi basta fare doppio clic sul nome del file e non recupera.

    Trovare e ripristinare un file eliminato in un repository Git

    So che la mia risposta non è Git dei comandi, ma è veloce, affidabile e facile per i principianti che per gli sviluppatori professionali. Webstorm VCS strumenti sono impressionanti e perfetto per lavorare con Git e non ha bisogno di alcun plugin o strumenti di.

    • Ciò è impressionante! Grazie. Definitivamente una soluzione facile per coloro che utilizzano uno qualsiasi di JetBrains’ Idi.
    • Come facciamo a ripristinare il file immagine?
  16. 5
    [email protected]:~/work/git$ rm slides.tex
    [email protected]:~/work/git$ git pull 
    Already up-to-date.
    [email protected]:~/work/git$ ls slides.tex
    ls: slides.tex: No such file or directory
    

    Ripristinare il file eliminato:

    [email protected]:~/work/git$ git checkout
    D       .slides.tex.swp
    D       slides.tex
    [email protected]:~/work/git$ git checkout slides.tex 
    [email protected]:~/work/git$ ls slides.tex
    slides.tex
    
    • La domanda riguardava il ripristino di un file dopo che è stato eliminato e il cambiamento è stato commesso. Questa risposta è di circa il ripristino di un file che è stato rimosso solo nella directory di lavoro.
    • Questo è vero, e che era quello che stavo cercando.
  17. 5

    Ho avuto la stessa domanda. Senza saperlo, avevo creato una penzoloni commettere.

    Elenco penzoloni impegna

    git fsck --lost-found

    Ispezionare ogni penzoloni commettere

    git reset --hard <commit id>

    Mio file è ricomparso quando mi sono trasferito a penzoloni commit.

    git status il motivo:

    “HEAD detached from <commit id where it detached>”

  18. 4

    Nel nostro caso abbiamo i file eliminati accidentalmente in un commit e alcuni commesso successivamente ci siamo resi conto di un nostro errore e voleva ottenere indietro tutti i file che sono stati eliminati, ma non quelle che sono state modificate.

    Basato su Charles Bailey eccellente risposta qui è il mio one liner:

    git co $(git rev-list -n 1 HEAD -- <file_path>)~1 -- $(git diff --name-status $(git rev-list -n 1 HEAD -- <file_path>)~1 head | grep '^D' | cut -f 2)
    
  19. 4

    Se si conosce il commit che ha cancellato il file(s), eseguire questo comando, dove <SHA1_deletion> è l’impegno che ha eliminato i file:

    git diff --diff-filter=D --name-only <SHA1_deletion>~1 <SHA1_deletion> | xargs git checkout <SHA1_deletion>~1 --
    

    Parte prima il tubo elenca tutti i file che sono stati eliminati nel commit; sono tutti checkout dal precedente impegnarsi per il ripristino.

  20. 2

    Semplice e preciso-

    Prima di tutto, ottenere un più recente stabile di commit in cui si dispone che il file –

    git log 
    

    Dire trovare $commitid 1234567…, quindi

    git checkout <$commitid> $fileName
    

    Questo consentirà di ripristinare la versione del file che era in quel commit.

  21. -1

    So che questo è un vecchio thread, ma si può sempre git revert di commit, che ha eliminato il file. (Questo presuppone che la cancellazione è stata l’unica modifica nel commit.)

    > git log 
    commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3
    Author: Dave <[email protected]>
    Date:   Thu May 9 11:11:06 2019 -0700
    
        deleted readme.md
    

    E se abbiamo continuato a lavorare, e poi capì che non vogliono impegnarsi, che la cancellazione di commit, si potrebbe tornare di utilizzo.

    > git revert 2994bd
    

    Ora git log mostra:

    > git log
    Author: Dave <[email protected]>
    Date:   Thu May 9 11:17:41 2019 -0700
    
        Revert "deleted readme"
    
        This reverts commit 2994bda49cd97ce49099953fc3f76f7d3c35d1d3.
    

    E readme.md è stato restaurato nel repository.

    • Poiché la domanda suppone che un numero di commit che sono state fatte dopo che il file è stato eliminato e, poiché non vi è alcuna indicazione che la successiva commette indesiderate, questo non sembra in grado di aiutarlo nella situazione descritta.
    • Yep! È possibile effettuare la successiva commette, e ancora ripristinare l’eliminazione di commit. Quindi, se commettono 111 elimina il file, e di impegnarsi 222, 333, 444, aggiunge/modifica le cose, è ancora possibile ripristinare il commit 111 per annullare l’eliminazione, e che diventerà una commit 555
  22. -1

    Anche io ho questo problema con sotto il codice di recuperare il precedente file in una directory locale

    git checkout <file path with name>
    

    di seguito esempio il lavoro per me

    git checkout resources/views/usaSchools.blade.php

    Grazie

    • Si prega di indicare qual è il problema

Lascia un commento