Spiegò Git Pull

Riepilogo:

Git Pull è un comando comunemente usato in Git che viene utilizzato per recuperare e unire le modifiche da un repository remoto al repository locale. Aggiorna il tuo repository locale con le ultime modifiche dal repository remoto.

Punti chiave:

1. Git Pull combina i comandi Git Fetch e Git Merge in un comando conveniente.
2. Viene utilizzato per recuperare le ultime modifiche dal repository remoto e unirle con la tua filiale locale.
3. Git Pull può essere utilizzato per aggiornare più filiali nel repository locale.
4. Quando si esegue Git Pull, controlla se ci sono nuove modifiche nel repository remoto dal momento dell’ultimo tiro o recupero.
5. Se ci sono nuove modifiche, Git pull download e applica tali modifiche al repository locale.
6. Git Pull unisce automaticamente le modifiche con la filiale locale.
7. Se ci sono conflitti durante il processo di unione, è necessario risolverli manualmente.
8. Puoi usare l’origine Git Pull comando per aggiornare una filiale specifica.
9. Git Pull è un comando utile per mantenere aggiornato il repository locale con il repository remoto.
10. Si consiglia di eseguire regolarmente Git Pull per assicurarti le ultime modifiche.

Domande:

1. Gira tira tutti i rami?

Quando si esegue Git Pull, aggiorna la filiale corrente nel repository locale con le modifiche dal repository remoto. Non aggiorna automaticamente tutte le filiali nel repository locale.

2. Come funziona Git Pull?

Git Pull combina i comandi Git Fetch e Git Merge. Prima prende le ultime modifiche dal repository remoto e quindi unisce tali modifiche con la tua filiale locale. Se ci sono conflitti durante il processo di unione, è necessario risolverli manualmente.

3. Può git pull aggiornare un ramo specifico?

Sì, puoi usare l’origine Git Pull Comando per aggiornare una filiale specifica nel repository locale con le modifiche dal repository remoto.

4. Quante volte dovrei eseguire git pull?

Si consiglia di eseguire regolarmente Git Pull, soprattutto prima di iniziare qualsiasi lavoro o di spingere le modifiche al repository remoto. Ciò ti assicura di avere le ultime modifiche e riduce le possibilità di conflitti.

5. Cosa succede se ci sono conflitti durante Git Pull?

Se ci sono conflitti durante il processo di unione, Git Pull si ferma e ti spinge a risolvere manualmente i conflitti. È necessario modificare i file in conflitto, risolvere i conflitti e quindi commettere le modifiche.

6. Posso annullare una trazione git?

Scattare una trazione git può essere un po ‘complicato. Una volta che hai estratto le modifiche dal repository remoto e le hai unite nella tua filiale locale, diventa parte della tua cronologia di commit. È possibile utilizzare GIT RIPORT per ripristinare le modifiche, ma si consiglia di creare un backup o consultare il tuo team prima di eseguire eventuali operazioni.

7. Può git trainare sovrascrivere i cambiamenti locali?

Se hai apportato modifiche locali a un file che è stato anche modificato nel repository remoto, Git Pull cerca di unire automaticamente tali modifiche. Se ci sono conflitti, ti spinge a risolverli manualmente. Per impostazione predefinita, Git Pull non sovrascrive con forza le modifiche locali senza il permesso.

8. Come posso verificare se la mia filiale locale è aggiornata con la filiale remota?

È possibile utilizzare il comando Git Branch per verificare se la tua filiale locale è aggiornata con la filiale remota. Dopo aver eseguito Git Pull, è possibile utilizzare Git Branch -Vv per mostrare informazioni più dettagliate sui tuoi rami locali e remoti.

9. Posso usare git pull per aggiornare più rami?

Sì, Git Pull può essere utilizzato per aggiornare più filiali nel repository locale. È possibile passare a un ramo specifico ed eseguire Git Pull per aggiornare quel ramo con le ultime modifiche dal repository remoto.

10. È git tira lo stesso di git fetch?

No, git tip non è uguale a git prese. Git Fetch scarica solo le ultime modifiche dal repository remoto ma non le unisce con la tua filiale locale. Git tip, d’altra parte, prende le modifiche e li unisce con la tua filiale locale.

11. Può essere utilizzato per aggiornare un ramo da un diverso repository remoto?

Sì, è possibile specificare il repository remoto quando si esegue il comando Git Pull. Ad esempio, git pull Aggiorna il ramo specificato dal repository remoto specificato.

12. Posso eseguire git pull senza specificare un ramo?

Se si esegue Git Pull senza specificare un ramo, aggiorna la filiale corrente nel repository locale con le modifiche dal repository remoto.

13. Posso usare git pull per aggiornare una filiale a un commit specifico?

No, Git Pull viene utilizzato principalmente per aggiornare un ramo con le ultime modifiche dal repository remoto. Se si desidera aggiornare una filiale a un commit specifico, è possibile utilizzare il comando Git Reset.

14. Come posso evitare i conflitti durante il tiro git?

Per evitare i conflitti durante il tiro Git, si consiglia di aggiornare regolarmente il repository locale con le ultime modifiche dal repository remoto eseguendo Git Pull. Questo aiuta a mantenere in sintonia i tuoi rami locali e remoti. È anche una buona pratica comunicare e coordinarsi con il tuo team per ridurre al minimo le possibilità di cambiamenti contrastanti.

15. Può git pull elimina i file nel mio repository locale?

No, Git Pull non elimina i file nel repository locale a meno che non siano stati eliminati nel repository remoto. Anche in quel caso, Git Pull cerca di unire le modifiche e preserva le modifiche locali, se possibile,. Tuttavia, è sempre una buona pratica eseguire il backup del repository locale prima di eseguire eventuali operazioni di unione.

Spiegò Git Pull

Correre GIT Branch Ancora una volta e controlla se i rami esistono localmente:

Gira tira tutti i rami

Cambiamenti nel git-pull Manuale

1. 2.40.1 Nessun cambiamento
2. 2.40.0 03/12/23
3. 2.36.1 → 2.39.3 Nessun cambiamento
4. 2.36.0 18/04/22
5. 2.35.1 → 2.35.8 Nessun cambiamento
6. 2.35.0 24/01/22
7. 2.34.1 → 2.34.8 Nessun cambiamento
8. 2.34.0 15/11/21
9. 2.33.2 → 2.33.8 Nessun cambiamento
10. 2.33.1 10/12/21
11. 2.33.0 16/08/21
12. 2.32.1 → 2.32.7 Nessun cambiamento
13. 2.32.0 06/06/21
14. 2.31.1 → 2.31.8 Nessun cambiamento
15. 2.31.0 15/03/21
16. 2.30.1 → 2.30.9 Nessun cambiamento
17. 2.30.0 27/12/20
18. 2.29.1 → 2.29.3 Nessun cambiamento
19. 2.29.0 19/10/20
20. 2.27.1 → 2.28.1 Nessun cambiamento
21. 2.27.0 06/01/20
22. 2.25.2 → 2.26.3 Nessun cambiamento
23. 2.25.1 17/02/20
24. 2.25.0 13/01/20

Controlla la tua versione di Git eseguendo

NOME

git -pull – prendi e integra con un altro repository o una filiale locale

SINOSSI

git tira [] [[…]]

DESCRIZIONE

Incorpora le modifiche da un repository remoto nel ramo corrente. Se il ramo corrente è dietro il telecomando, per impostazione predefinita, percorre rapidamente il ramo corrente per abbinare il telecomando. Se il ramo corrente e il telecomando sono divergenti, l’utente deve specificare come riconciliare i rami divergenti con –rebase o –no-rebase (o l’opzione di configurazione corrispondente in pull.rebase).

Più precisamente, Git Pull esegue Git Fetch con i parametri indicati e quindi a seconda delle opzioni di configurazione o dei flag della riga di comando, chiamerà Git Rebase o Git unire per riconciliare i rami divergenti.

dovrebbe essere il nome di un repository remoto passato a git-fetch [1]. può nominare un ref remoto arbitrario (ad esempio, il nome di un tag) o persino una raccolta di refs con corrispondenti rami di tracciamento remoto (E.G., Rif.

Valori predefiniti per e vengono letti dalla configurazione “remoto” e “unisci” per il ramo corrente come set da Git-ranch [1]-Track .

Supponiamo che esista la seguente storia e che il ramo attuale sia “maestro”:

A --- b --- C Master su Origin / D --- e --- f --- G Master ^ Origine / Master nel tuo repository

Quindi “git pull” prenderà e riprodurrà le modifiche dal ramo principale remoto poiché si è discostata dal maestro locale (i.e., E) fino al suo attuale commit (c) in cima a Master e registrare il risultato in un nuovo commit insieme ai nomi dei due principali commit e un messaggio di registro dell’utente che descrive le modifiche.

A --- b --- c origine / master / \ d --- e --- f --- g --- H Master

Vedi Git-Merge [1] per i dettagli, incluso il modo in cui i conflitti vengono presentati e gestiti.

In Git 1.7.0 o successivamente, per annullare un’iscrizione in conflitto, usa Git reset -Merge . Avvertimento: Nelle versioni precedenti di Git, correre git tira Con i cambiamenti non impegnati sono scoraggiati: anche se possibile, ti lascia in uno stato che potrebbe essere difficile ritirarti nel caso di un conflitto.

Se una qualsiasi delle modifiche remote si sovrappongono alle modifiche locali non impegnate, l’iscrizione verrà automaticamente annullata e l’albero di lavoro non toccato. È generalmente meglio ottenere eventuali cambiamenti locali nell’ordine di lavoro prima di tirarli via con Git-Stash [1].

OPZIONI

Questo viene passato sia a Git-Fetch sottostante a Squalch Reporting durante il trasferimento, sia Git-Merge sottostante per squillare l’output durante la fusione.

Pass -verbose a git-fetch e git-merge.

Questa opzione controlla se devono essere recuperati nuovi commit di sottomoduli popolati e se gli alberi di lavoro dei sottomoduli attivi devono essere aggiornati anche (vedi Git-Fetch [1], Git-Config [1] e Gitmoduli [5]).

Se il checkout viene eseguito tramite Rebase, anche i commit del sottomodulo locale vengono ripristinati.

Se l’aggiornamento viene eseguito tramite unione, i conflitti del sottomodulo vengono risolti e verificati.

Opzioni relative alla fusione

–commit –no-commit

Esegui l’iscrizione e commetti il ​​risultato. Questa opzione può essere utilizzata per sovrascrivere –No-commit. Utile solo quando si fonde.

Con –No-commit eseguire l’unione e fermarsi appena prima di creare un commit di unione, per dare all’utente la possibilità di ispezionare e modificare ulteriormente il risultato di unione prima di impegnarsi.

Si noti che gli aggiornamenti a tempo rapido non creano un commit di unione e quindi non c’è modo di fermare le fusioni con –No-impegna. Pertanto, se si desidera assicurarsi che il tuo ramo non sia modificato o aggiornato dal comando unione, usa –No-FIF con –No-commit.

–EDIT -E –No -Edit

Invoca un editore prima di commettere unione meccanica riuscita per modificare ulteriormente il messaggio di unione generato automaticamente, in modo che l’utente possa spiegare e giustificare l’accusa. L’opzione –No-Edit può essere utilizzata per accettare il messaggio generato automaticamente (questo è generalmente scoraggiato).

Gli script più vecchi possono dipendere dal comportamento storico di non consentire all’utente di modificare il messaggio di unione. Vedranno un editore aperto quando eseguiranno Git unire . Per semplificare la regolazione di tali script al comportamento aggiornato, la variabile di ambiente git_merge_autoedit può essere impostata su no all’inizio di essi.

Questa opzione determina come verrà ripulito il messaggio di unione prima di impegnarsi. Vedi Git-commit [1] per maggiori dettagli. Inoltre, se viene dato un valore di forbici, le forbici verranno aggiunte a Merge_MSG prima di essere trasmesse ai macchinari di commit in caso di un conflitto di unione.

Aggiorna alla nuova storia solo se non esiste una cronologia locale divergente. Questo è il valore predefinito quando non viene fornito alcun metodo per riconciliare storie divergenti (tramite –Rebase =* Flags).

Quando si uniscono piuttosto che ribelli, specifica come viene gestita un’iscrizione quando la storia unita è già un discendente della storia attuale. Se si richiede la fusione,-FFF è l’impostazione predefinita a meno che non si fonda un tag annotato (e possibilmente firmato) che non è memorizzato nel suo posto naturale nel Refs/ Tags/ Gerarchy, nel qual caso-NO-FF si assume.

Con –ff, quando possibile, risolvi l’accusa come avanzamento rapido (aggiorna solo il puntatore della filiale per abbinare il ramo unito; non creare un commit di unione). Quando non è possibile (quando la storia unita non è un discendente della storia attuale), crea un commit di unione.

Con –No-FF, crea un commit di unione in tutti i casi, anche quando l’iscrizione potrebbe invece essere risolta come un avanzamento rapido.

-S [] –gpg-SIGN [=] –NO-GPG-SIGN

GPG-SIGN il commit di unione risultante. L’argomento KeyID è facoltativo e predefinito è l’identità committer; Se specificato, deve essere attaccato all’opzione senza spazio. –Il segnale no-gpg è utile per contrastare entrambi.Variabile di configurazione GPGSIGN e precedente-GPG-SIGN .

Oltre ai nomi delle filiali, popola il messaggio di registro con descrizioni di una riga da commit effettivi che vengono uniti. Vedi anche Git-FMT-Merge-MSG [1]. Utile solo quando si fonde.

Con –No-log non elenca le descrizioni di una riga dagli commit effettivi che vengono uniti.

–firma –no-Signoloff

Aggiungi un trailer firmato dal committer alla fine del messaggio di registro di commit. Il significato di un firma dipende dal progetto a cui tu’si impegna. Ad esempio, può certificare che il committer abbia i diritti di presentare il lavoro nell’ambito del progetto’la licenza o accetta di una rappresentanza del collaboratore, come un certificato di origine sviluppatore. (Vedi http: // svilupperCertificate.Org per quello utilizzato dai progetti del kernel Linux e GIT.) Consultare la documentazione o la leadership del progetto a cui si è’contribuendo a capire come vengono utilizzate le firme in quel progetto.

L’opzione –No-Signoloff può essere utilizzata per contrastare un’opzione precedente–SIGNOFF sulla riga di comando.

–STAT -N –No -Stat

Mostra un diffstat alla fine della fusione. Il diffstat è inoltre controllato dall’opzione di configurazione.statistica.

Con -n o –nos -stat non mostrano un diffstat alla fine della fusione.

–Squash-No-Squash

Produrre l’albero di lavoro e lo stato indice come se fosse avvenuta una vera unione (ad eccezione delle informazioni di unione), ma in realtà non fare un commit, spostare la testa o registrare $ git_dir/Merge_head (per causare il prossimo comando di commit git per creare un commit di unione). Ciò ti consente di creare un singolo commit in cima all’attuale ramo il cui effetto è lo stesso della fusione di un altro ramo (o più in caso di polpo).

Con-No-Squash Esegui l’iscrizione e commetti il ​​risultato. Questa opzione può essere utilizzata per sovrascrivere -Squadra.

Con – -Squash, -Commit non è consentito e fallirà.

Utile solo quando si fonde.

Per impostazione predefinita, vengono eseguiti i ganci pre-merge e commit-MSG. Quando viene fornito-Non-verify, questi sono bypassati. Vedi anche Githooks [5]. Utile solo quando si fonde.

Utilizzare la strategia di unione data; può essere fornito più di una volta per specificarli nell’ordine, dovrebbero essere provati. Se non esiste un’opzione -s, viene utilizzato un elenco integrato di strategie (ORT quando si uniscono una singola testa, Octopus altrimenti).

Passa l’opzione specifica di unione della strategia attraverso la strategia di unione.

Verificare che il commit della punta del ramo laterale si unisca sia firmato con una chiave valida, i.e. Una chiave che ha un UID valido: nel modello di fiducia predefinito, ciò significa che la chiave di firma è stata firmata da una chiave di fiducia. Se il commit della punta del ramo laterale non è firmato con una chiave valida, l’iscrizione viene interrotta.

Utile solo quando si fonde.

–Riepilogo-No-Summary

Sinonimi a –stat e –nos-stat; Questi sono deprecati e saranno rimossi in futuro.

Crea automaticamente una voce di scorta temporanea prima dell’inizio dell’operazione, registrarla nello Special Ref Merge_Autostash e applicarla al termine dell’operazione. Ciò significa che è possibile eseguire l’operazione su un worktree sporco. Tuttavia, l’uso con la cura: l’applicazione di scorta finale dopo un’iscrizione di successo potrebbe comportare conflitti non banali.

Per impostazione predefinita, il comando Git Merge rifiuta di unire storie che non condividono un antenato comune. Questa opzione può essere utilizzata per scavalcare questa sicurezza quando si uniscono le storie di due progetti che hanno iniziato la propria vita in modo indipendente. Poiché questa è un’occasione molto rara, nessuna variabile di configurazione per abilitarlo per impostazione predefinita e non verrà aggiunta.

Utile solo quando si fonde.

-R –Rebase [= FALSE | TRUE | MERGES | interattivo]

Quando è vero, ribella il ramo attuale in cima al ramo a monte dopo aver recuperato. Se esiste un ramo di tracciamento remoto corrispondente al ramo a monte e il ramo a monte è stato ribattezzata dall’ultimo recupero, la Rebase usa tali informazioni per evitare di ribellarsi a cambiamenti non locali.

Se impostato su una fusione, Rebase usando Git Rebase-Rebase-Merges in modo che le commissioni di unione locale siano incluse nella Rebase (vedere Git-Rebase [1] per i dettagli).

Quando falso, unire il ramo a monte nel ramo corrente.

Se interattivo, abilita la modalità interattiva di Rebase.

Vedi Pull.Rebase, Branch..Rebase e Branch.AutoseTuPrebase in git-config [1] se si desidera fare sempre utilizzare git pull.

Questo è stenografia per –rebase = false.

Opzioni relative al recupero

Recuperare tutti i telecomandi.

Aggerisci i nomi dei ref e gli oggetti dei ref di recupero al contenuto esistente di .git/fetch_head . Senza questa opzione vecchi dati in .Git/fetch_head verrà sovrascritto.

Utilizzare una transazione atomica per aggiornare gli arbitri locali. O tutti gli riferimenti vengono aggiornati o, in caso di errore, nessun ref viene aggiornato.

Limite di recupero al numero specificato di commit dalla punta di ciascuna cronologia del ramo remoto. Se si ottiene a un poco profondo Repository creato da Git Clone con-Depth = Option (vedi git-clone [1]), approfondisci o accorcia la cronologia al numero specificato di commit. I tag per i commit approfonditi non sono recuperati.

Simile a -profondi, tranne che specifica il numero di commit dal confine superficiale corrente anziché dalla punta di ciascuna cronologia del ramo remoto.

Approfondire o accorciare la storia di un repository superficiale per includere tutti i commit raggiungibili dopo .

Approfondire o accorciare la storia di un repository poco profondo per escludere commessi raggiungibili da un ramo o tag remoto specificato. Questa opzione può essere specificata più volte.

Se il repository di origine è completato, converti un repository superficiale in un completo, rimuovendo tutte le limitazioni imposte da repository superficiali.

Se il repository di origine è superficiale, prendi il più possibile in modo che il repository corrente abbia la stessa cronologia del repository di origine.

–Aggiornamento-shallow

Per impostazione predefinita quando si ottiene da un repository poco profondo, Git Fetch rifiuta i ref che richiedono l’aggiornamento .git/superficiale. Questa opzione si aggiorna .git/superficiale e accetta tali refs.

Per impostazione predefinita, Git riferirà, al server, impegni raggiungibili da tutti gli arbitri locali per trovare commit comuni nel tentativo di ridurre le dimensioni del pacchetto di fuga. Se specificato, Git riferirà solo impegni raggiungibili dai suggerimenti indicati. Ciò è utile per accelerare il recupero quando l’utente sa quale arbitro locale è probabile che abbia commit in comune con il recupero a monte.

Questa opzione può essere specificata più di una volta; In tal caso, Git riferirà impegni raggiungibili da uno dei commit indicati.

L’argomento a questa opzione può essere un globo sui nomi di riferimento, un ref o il (possibilmente abbreviato) sha-1 di un commit. Specificare un globo equivale a specificare questa opzione più volte, una per ogni nome di riferimento corrispondente.

Vedi anche il recupero.Negoziazione e spinta.negoziare le variabili di configurazione documentate in Git-config [1] e l’opzione-solo negoziata di seguito.

–negoziare solo

Non prendere nulla dal server, e stampare invece gli antenati degli argomenti-negoziazione di negoziazione =* che abbiamo in comune con il server.

Questo è incompatibile con–RECURSE-SUBMODULES = [Sì | on-demand] . Internamente questo viene utilizzato per implementare la spinta.Opzione negozia, vedi git-config [1].

Mostra cosa sarebbe stato fatto, senza apportare modifiche.

Quando Git Fetch viene utilizzato con: RefSpec può rifiutare di aggiornare la filiale locale come discusso nella parte della documentazione Git-Fetch [1]. Questa opzione prevalga quel controllo.

Mantieni il pacchetto scaricato.

Modifica il RefSpec configurato per inserire tutti gli AFF in Refs/ Prefetch/ Namespace. Vedere l’attività prefetch in Git-manutenzione [1].

Prima di recuperare, rimuovere eventuali riferimenti a remoto che non esistono più sul telecomando. I tag non sono soggetti a potatura se sono recuperati solo a causa del tag predefinito che seguono automatico o a causa di un’opzione-tags. Tuttavia, se i tag vengono recuperati a causa di un refspec esplicito (sulla riga di comando o nella configurazione remota, ad esempio se il telecomando è stato clonato con l’opzione -mirror), allora sono anche soggetti a potatura. Fornitura-PRUNE-TAGS è una scorciatoia per fornire il refspec tag.

Per impostazione predefinita, i tag che indicano gli oggetti che vengono scaricati dal repository remoto vengono recuperati e memorizzati a livello locale. Questa opzione disabilita questo tag automatico seguente. Il comportamento predefinito per un telecomando può essere specificato con il telecomando..Impostazione Tagopt. Vedi Git-Config [1].

Quando si prendono i refs elencati nella riga di comando, utilizzare il refSpec specificato (può essere dato più di una volta) per mappare gli arbitri a rami di tracciamento di telecomandi, anziché i valori del telecomando.*.Fetch Variabili di configurazione per il repository remoto. Fornire un’opzione vuota all’opzione –RefMap fa sì che Git ignori i RefSpec configurati e si basino interamente sugli REFSpec forniti come argomenti della riga di comando. Vedere la sezione su “Filiali di remoto configurati” per i dettagli.

Prendi tutti i tag dal telecomando (i.e., recuperare i tag remoti rif/tag/* in tag locali con lo stesso nome), oltre a qualsiasi altra cosa sarebbe altrimenti recuperata. L’uso di questa opzione da sola non soggetto a tag alla potatura, anche se viene utilizzato -sebbene i tag possano essere potati comunque se sono anche la destinazione di un refspec esplicito; vedi –prune).

Numero di bambini paralleli da utilizzare per tutte le forme di recupero.

Se è stata specificata l’opzione -multiplo, i diversi telecomandi verranno recuperati in parallelo. Se vengono recuperati più sottomoduli, saranno recuperati in parallelo. Per controllarli in modo indipendente, utilizzare le impostazioni di configurazione.parallelo e sottomodulo.fetchjobs (vedi git-config [1]).

Tipicamente, i recuperi ricorsivi e multi-remoti paralleli saranno più veloci. Per impostazione predefinita, i recuperi vengono eseguiti in sequenza, non in parallelo.

–set-upstream

Se il telecomando viene recuperato correttamente, aggiungi il riferimento a monte (monitoraggio), utilizzato da Git-Pull senza argomento [1] e altri comandi. Per ulteriori informazioni, vedere Branch..unire e ramo..remoto in git-config [1].

Quando viene dato, e il repository da cui recuperare viene gestito da Git Fetch-pack, –Exec = viene passato al comando per specificare il percorso non default per l’esecuzione del comando sull’altra estremità.

Lo stato di avanzamento è riportato nel flusso di errore standard per impostazione predefinita quando è allegato a un terminale, a meno che -Q non sia specificato. Questo flag forza lo stato di avanzamento anche se il flusso di errore standard non è diretto a un terminale.

Trasmettere la stringa data al server quando si comunica usando il protocollo versione 2. La stringa data non deve contenere un carattere NUL o LF. Il server’La gestione delle opzioni del server, comprese quelle sconosciute, è specifica del server. Quando vengono forniti più-server-option =, vengono tutti inviati dall’altra parte nell’ordine elencato nella riga di comando.

Per impostazione predefinita, Git controlla se un ramo viene aggiornato durante il recupero. Questo può essere disabilitato attraverso il recupero.ShowForcedUpdates, ma l’opzione-Show-Forced Aptdates garantisce questo controllo si verifica. Vedi Git-Config [1].

Per impostazione predefinita, Git controlla se un ramo viene aggiornato durante il recupero. Pass-No-show-forced aggiornati o set recupero.ShowforcedUpdates to False per saltare questo controllo per motivi di prestazione. Se usato durante git-pull L’opzione –ff-sola controllerà comunque gli aggiornamenti forzati prima di tentare un aggiornamento rapido. Vedi Git-Config [1].

Utilizzare solo gli indirizzi IPv4, ignorando gli indirizzi IPv6.

Utilizzare solo gli indirizzi IPv6, ignorando gli indirizzi IPv4.

Il repository “remoto” che è la fonte di un’operazione di recupero o pull. Questo parametro può essere un URL (vedere gli URL GIT della sezione di seguito) o il nome di un telecomando (vedere i telecomandi della sezione di seguito).

Specifica quali RIF si recano e quali arbitri locali aggiornano. Quando non viene visualizzato la riga di comando, gli arbitri da recuperare vengono letti dal telecomando..Variabili di recupero invece (vedere la sezione “rami di remoto configurati” in git-fetch [1]).

Il formato di un parametro è un plus opzionale +, seguito dalla fonte, seguito da un colon:, seguito dal Ref di destinazione . Il colon può essere omesso quando è vuoto. è in genere un ref, ma può anche essere un nome di oggetto esadecimale completamente scritto.

A può contenere un * nella sua per indicare una semplice corrispondenza. Tale refspec funziona come un globo che corrisponde a qualsiasi ref con lo stesso prefisso. Uno schema deve avere un * in entrambi i . Mappurerà i ref a destinazione sostituendo il * con il contenuto abbinato alla sorgente.

Se un refspec è prefisso da ^, verrà interpretato come un refspec negativo. Invece di specificare quali riferimenti a prendere o quali arbitri locali aggiornano, tale refspec specificherà invece gli arbitri per escludere. Verrà considerato un ref corrispondente se corrisponde ad almeno un refspec positivo e non corrisponde a nessun refspec negativo. I refspec negativi possono essere utili per limitare l’ambito di un riferimento a pattern in modo che non includa riferimenti specifici. I refspec negativi possono essere stessi RefSpecs. Tuttavia, possono contenere solo un e non specificare un . Anche i nomi degli oggetti esadecimali completamente spiegati non sono supportati.

Tag indica lo stesso di Refs/Tags/: Refs/Tags/; Richiede di recuperare tutto al tag dato.

L’arbitro remoto che corrisponde è recuperato e se non è una stringa vuota, viene fatto un tentativo di aggiornare l’arbitro locale che lo corrisponde.

Se quell’aggiornamento è consentito senza: la forza dipende dallo spazio dei nomi’essere recuperato, il tipo di oggetto da recuperare e se l’aggiornamento è considerato un rapido avanzamento. Generalmente, le stesse regole si applicano per il recupero di quando si spinge, vedere il . sezione di git-push [1] per quello che sono quelli. Eccezioni a tali regole in particolare a Git Fetch sono annotati di seguito.

Fino a Git versione 2.20, e a differenza di quando si spinge con git-push [1], eventuali aggiornamenti a Refs/Tags/* sarebbero accettati senza + nel RefSpec (o–Force). Durante il recupero, abbiamo considerato promiscuo tutti gli aggiornamenti dei tag da un telecomando da recuperare. Dalla versione 2 Git.20, recuperare per aggiornare i ref/tag/* funziona allo stesso modo di spingere. IO.e. Eventuali aggiornamenti verranno respinti senza + nel refspec (o – -force).

A differenza di quando si spinge con git-push [1], qualsiasi aggiornamento al di fuori di Refs //* sarà accettato senza + nel RefSpec (o–Force), se quello’s scambiarsi e.G. un oggetto albero per una chiazza o un commit per un altro commit che’s non’t Avere il precedente commit come antenato ecc.

A differenza di quando si spinge con Git-push [1], non esiste una configurazione che’Modifica queste regole e niente come un gancio pre-fetch analogo al gancio pre-ricezione.

Come per spingere con git-push [1], tutte le regole sopra descritte su cosa’S non consentito come aggiornamento può essere sovrascritto aggiungendo un’opzione Opzionale di Leading + a un RefSpec (o utilizzando -Opzione riga di comando -forza). L’unica eccezione a ciò è che nessuna quantità di forzatura farà accettare un oggetto Ref/Heads/* Names.

Spiegò Git Pull

Git Pull è un comando git utilizzato per aggiornare la versione locale di un repository da un telecomando.

È uno dei quattro comandi che richiede l’interazione di rete da parte di GIT. Per impostazione predefinita, Git Pull fa due cose.

1. Aggiorna l’attuale filiale di lavoro locale (attualmente la filiale del check out)
2. Aggiorna i rami di tracciamento remoto per tutte le altre filiali.

git pull prendendo (git pretch) il nuovo commette e unisce (git unisce) nella tua filiale locale.

Questo comando’La sintassi S è la seguente:

# Formato generale git pull options repository refspec # pull dal ramo specifico git pull-remote name name

• OPZIONI sono le opzioni di comando, come –quiet o -verbose . Puoi leggere di più sulle diverse opzioni nella documentazione GIT
• Repository è l’URL del tuo repository. Esempio: https: // github.com/freecodecamp/freecodecamp.idiota
• Refspec Specifica quali RIF si recano e quali arbitri locali aggiornano
• Nome remoto è il nome del tuo repository remoto. Per esempio: origine.
• Branch-name è il nome della tua filiale. Per esempio: sviluppare.

Nota

Se hai modifiche non impegnate, la parte di unione del comando Git Pull fallirà e la tua filiale locale non sarà toccata.

Quindi, dovresti commetti sempre le tue modifiche in un ramo prima di tirare Nuovi commit da un repository remoto.

Sommario

• Usando Git Pull
• Controllo della versione distribuita
• git fetch + git unire
• git tip in ides

Usando Git Pull

Usa Git Pull per aggiornare un repository locale dal corrispondente repository remoto. Ex: Mentre si lavora localmente su Master, esegui Git Pull per aggiornare la copia locale di Master e aggiornare le altre filiali di tracciamento remoto. (Ulteriori informazioni sui rami di monitoraggio remoto nella sezione successiva.)

Ma ci sono alcune cose da tenere a mente perché quell’esempio sia vero:

Il repository locale ha un repository remoto collegato

• Controlla questo eseguendo Git Remote -V
• Se ci sono più telecomandi, Git pull potrebbe non essere abbastanza informazioni. Potrebbe essere necessario inserire Git Pull Origin o Git Pull a monte .

La filiale a cui è attualmente verificato ha una filiale di monitoraggio remoto corrispondente

• Controlla questo eseguendo lo stato GIT . Se non esiste un ramo di tracciamento remoto, git lo fa’t so dove tirare le informazioni da.

Controllo della versione distribuita

Git è a Sistema di controllo della versione distribuita (DVC). Con i DVC, gli sviluppatori possono lavorare sullo stesso file contemporaneamente in ambienti separati. Dopo spingendo Codice fino al repository remoto condiviso, altri sviluppatori possono tiro Codice modificato.

Interazioni di rete in GIT

Ci sono solo quattro comandi che richiedono le interazioni di rete in GIT. Un repository locale non ha consapevolezza delle modifiche apportate al repository remoto fino a quando non vi è una richiesta di informazioni. E, un repository remoto non ha consapevolezza dei cambiamenti locali fino a quando non vengono spinti.

I quattro comandi di rete sono:

• clone git
• Git Fetch
• git tira
• Git Push

Rami in DVCS

Quando si lavora con Git, può sembrare che ci siano molte copie dello stesso codice che galleggiano dappertutto. Esistono diverse versioni dello stesso file su ogni ramo. E, diverse copie delle stesse filiali su ogni sviluppatore’S computer e sul telecomando. Per tenerne traccia di questo, Git usa qualcosa chiamato rami di tracciamento remoto.

Se si esegue il ramo GIT, tutto all’interno di un repository Git, i rami di tracciamento remoto vengono visualizzati in rosso. Queste sono copie di sola lettura del codice come appare sul telecomando. (Quando è stata l’ultima interazione di rete che avrebbe portato informazioni a livello locale? Ricorda quando queste informazioni sono state aggiornate l’ultima volta. Le informazioni nei rami di monitoraggio remoto riflettono le informazioni da tale interazione.)

Con rami di tracciamento remoto, Puoi lavorare in Git su più filiali senza interazione di rete. Ogni volta che esegui i comandi Git Pull o Git Fetch, si aggiorna rami di tracciamento remoto.

Git Fetch Plus Git Merge

Git Pull è un comando di combinazione, pari a Git Fetch + Git Merge .

Git Fetch

Di per sé, Git Fetch aggiorna tutte le filiali di monitoraggio remoto nel repository locale. Nessun cambiamento si riflette effettivamente su nessuna delle filiali di lavoro locali.

Git unire

Senza alcun argomento, Git Merge unirerà la corrispondente filiale di monitoraggio remoto alla filiale di lavoro locale.

git tira

Git Fetch aggiorna le filiali di tracciamento remoto. GIT Merge aggiorna il ramo corrente con il ramo di tracciamento remoto corrispondente. Usando Git Pull, ottieni entrambe le parti di questi aggiornamenti. Ma ciò significa che se sei il check out per funzionare Branch e si esegue Git Pull, quando fai il checkout per padroneggiare, eventuali nuovi aggiornamenti non saranno inclusi. Ogni volta che fai il checkout a un altro ramo che potrebbe avere nuove modifiche, esso’è sempre una buona idea eseguire git pull .

git tip in ides

Il linguaggio comune in altri ides potrebbe non includere la parola tiro . Se cerchi le parole git tip ma don’VETRO, cerca invece la sincronizzazione della parola.

recuperare un PR remoto (richiesta di tiro) in Repo locale

Ai fini della revisione e tali, le PR in telecomando dovrebbero essere recuperate al repository locale. È possibile utilizzare il comando Git Fetch come segue per raggiungere questo obiettivo.

Git Fetch Origin Pull/ID/Head: BranchName

ID è l’ID richiesta e il nome di filiale è il nome del ramo che si desidera creare. Una volta che il ramo è stato creato, è possibile utilizzare il checkout Git per passare a quel Brach.

Altre risorse su Git che ti potrebbe piacere:

• Git Merge e Git Rebase
• Checkout Git
• Commit git
• Git Stash
• GIT Branch

Come tirare tutti i rami in git

Git è un sistema di controllo della versione che consente agli utenti di mantenere più linee di sviluppo, i.e., Filiali, in un singolo progetto. Quando inizi a lavorare su un progetto e si desidera clonare il repository su una macchina locale, Git ti consente di recuperare contemporaneamente singoli rami o tutti i rami remoti.

In questo tutorial, imparerai come tirare tutti i rami in Git.

• Git installato (vedi come installare Git su Ubuntu, macOS, Windows, CentOS 7 o CentOS 8).
• Un repository Git.

Tirare tutti i rami in Git

Le filiali Git possono essere archiviate in un repository remoto o locale. Quando si desidera lavorare su una funzione da una filiale memorizzata in un repository remoto, è necessario scaricarlo prima nel repository locale.

I due comandi GIT utilizzati per scaricare il contenuto da un repository remoto sono git pull e Git Fetch :

• Git Fetch è la versione più sicura di git tira . Scarica il contenuto remoto senza aggiornare lo stato di lavoro del repository locale, il che significa che il tuo lavoro rimane intatto.
• git tira è più aggressivo perché scarica il contenuto dal repository remoto ed esegue Git unione sul ramo attivo locale. L’unione crea un nuovo commit di unione e integra i contenuti con il tuo lavoro. Tuttavia, unire contenuti del genere può causare conflitti con il lavoro in corso e potrebbe richiedere una risoluzione manuale.

Le sezioni seguenti mostrano come attirare tutte le filiali git in un repository locale usando i due comandi.

Metodo Git Fetch

Con Git Fetch , Puoi scaricare metadati dal repository remoto senza influire sul lavoro locale. È un’opzione utile quando si desidera verificare se un altro sviluppatore ha apportato modifiche al repository remoto. Git Fetch viene utilizzato anche quando si clona un repository e il download dei dati su una macchina locale.

IL Git Fetch Il comando recupera gli ultimi aggiornamenti dal repository remoto. A seconda che tu voglia scaricare metadati per singoli filiali o tutti i rami, il comando ha le seguenti variazioni:

Git Fetch

• Il comando recupera solo il ramo specificato dal repository remoto.

Git Fetch -All

• Un comando è considerato una mossa di potenza poiché recupera tutti i telecomandi registrati e i loro rami.

Per questo tutorial, cloneremo un nuovo repository e prendiamo tutti i rami associati. Seguire i passaggi seguenti:

1. Apri un prompt dei comandi Git Bash su Windows o apri una nuova finestra terminale in Linux (Ctrl+Al+T) o macos.

2. Passare alla directory in cui si desidera archiviare i file del repository. Utilizzare il comando CD per modificare la directory.

3. Su GitHub, individuare il repository remoto che si desidera clonare e fare clic sul <> Codice pulsante. Ad esempio, cloneremo il repository Kit Kit Kit di sviluppo software Bare Metal Cloud di PhoenixNap. La piattaforma BMC GitHub Actions consente di automatizzare le attività nel tuo repository Git.

4. Dal menu a discesa, selezionare l’opzione di sicurezza che si desidera utilizzare per Git e Copia l’URL. In questo tutorial, useremo HTTPS poiché è il più semplice da configurare. Se vuoi un’opzione più sicura, vai con SSH.

5. In Git Bash, clona il repository remoto usando il clone git comando e l’URL che hai copiato. La sintassi è:

clone git

6. Dopo aver clonoso il repository, controllare le filiali disponibili nei repository locali e remoti. Per controllare le filiali locali, eseguire:

GIT Branch

Controlla le filiali disponibili in remoto eseguendo:

Git Branch -r

Solo il sviluppare Branch è disponibile nel repository locale, il che significa che dobbiamo recuperare quelli rimanenti.

7. Prendi i metadati per rami remoti e inizia a rintracciarli. Correre:

Git Fetch -All

IL –Tutto La bandiera dice a Git di recuperare i metadati per tutti i rami nel repository.

8. Dopo aver recuperato i metadati, inizia a monitorare i rami con questo comando:

Git Branch -r | grep -v '\ ->' | Sed "S, \ x1b \ [[0-9;]*[a-za-z] ,, g" | mentre leggi remoto; do git branch --rack "$" "$ remote"; Fatto

Il comando imposta le filiali nel repository locale e li fa tenere traccia delle loro controparti nel repository remoto.

Correre GIT Branch Ancora una volta e controlla se i rami esistono localmente:

Nell’esempio sopra, vediamo che tutti i rami del repository remoto ora esistono anche in quello locale.

Nota: Leggi il nostro confronto tra SSH e HTTPS per GIT.

Metodo Git Pull

IL git tira Il metodo è una combinazione di Git Fetch E Git unire . Il comando recupera i metadati della filiale dal repository remoto e aggiorna la copia di lavoro locale per riflettere le modifiche.

Nota: IL git tira Il metodo funziona meglio in un repository esistente in cui si desidera che le modifiche implementate da altri sviluppatori si riflettano nel repository locale. Clonazione di un repository e poi in esecuzione git tira non cederebbe alcun risultato, poiché tutto è già aggiornato.

Seguire i passaggi seguenti per tirare tutti i rami remoti:

1. Apri una finestra Git Bash e cambia la posizione nel repository locale.

2. Esegui il seguente comando per assicurarti che Git inizi a monitorare tutte le filiali remote, comprese quelle che non esistono nella copia locale:

Git Branch -r | grep -v '\ ->' | Sed "S, \ x1b \ [[0-9;]*[a-za-z] ,, g" | mentre leggi remoto; do git branch --rack "$" "$ remote"; Fatto

7. Estrarre tutti i rami dal repository Git remoto:

Git Pull -All

L’output mostra che tutti i rami remoti sono stati estratti correttamente e visualizza le modifiche.

Questo tutorial ha mostrato come estrarre tutte le filiali da un repository remoto alla copia di lavoro locale. Ci sono due metodi disponibili – Git Fetch E git tira , ciascuno adatto al proprio caso d’uso.

Scopri di più su Git nella nostra guida per principianti GIT o scarica un comando di Cheat Sheet Git e salvalo per un uso futuro.

Git: tira tutti i rami

Git consente di mantenere più linee di sviluppo separate per un progetto. Queste linee di sviluppo sono chiamate filiali. È possibile recuperare l’ultima versione di una filiale da un repository remoto in modo indipendente o puoi recuperare l’ultima versione di tutte le filiali contemporaneamente.

In questa guida, parliamo di come utilizzare il comando git e tutto git – tutti per recuperare le modifiche da un repository remoto.

Cosa è ramificante?

Permettere&rsquo;s dire che stiamo lavorando su un sito web del blog. Noi&rsquo;Aggiungerò una funzione al blog che consente agli utenti di commentare. Noi non&rsquo;voglio che questa funzione faccia parte della versione principale del nostro progetto perché ci stiamo ancora lavorando.

Trova la tua partita di bootcamp

• Il karma di carriera ti abbina con i bootcamp dei migliori tecnologie
• Accedi a borse di studio esclusive e corsi di preparazione

Seleziona il tuo interesse
Nome di battesimo

Cognome

E-mail

Numero di telefono

Continuandoti accettate i nostri termini di servizio e politica sulla privacy e acconsenti a ricevere offerte e opportunità dal Karma di carriera per telefono, messaggio di testo ed e -mail.

Possiamo usare un ramo Git per questo. Possiamo creare un ramo chiamato &ldquo;Commenti&rdquo; Per archiviare tutto il codice per la nostra funzione di commento. Questo ci consentirà di lavorare sulla nostra funzione di commento senza modificare la versione principale della nostra base di codice distribuita su un sito Web.

I rami possono essere archiviati a livello locale o remoto. Se stai lavorando su una versione locale di un progetto, una filiale sarà locale. I rami remoti sono archiviati con la versione principale di un progetto.

Git: prendi tutti i rami

Noi&rsquo;Regli lavorando su un progetto chiamato Blog Site. Questo progetto contiene due filiali: Origin Master e Origin Dev.

Il ramo Dev contiene tutte le caratteristiche sperimentali con cui stiamo lavorando. Pensiamo che un altro collaboratore abbia spinto le modifiche ad entrambi i rami. Vogliamo assicurarci e recuperare i metadati per eventuali modifiche se sono stati apportati.

Possiamo farlo usando il comando Fetch. Il comando Fetch indica a Git di recuperare i metadati da una filiale remota negli ultimi aggiornamenti. Il comando Fetch non aggiorna i file archiviati in una versione locale di un repository.

Per tracciare tutti i rami remoti e recuperare i metadati per quei rami, possiamo usare il comando Git Fetch con il flag:

Questo comando restituisce:

Recuperare origine remoto: elenchi di oggetti: 5, fatto. remoto: conteggio di oggetti: 100% (5/5), fatto. Remoto: Totale 3 (Delta 0), riutilizzato 0 (Delta 0), RUBBIUTO 0 Oggetti di disimballaggio: 100% (3/3), fatto. Da https: // github.com/carriera-karma-tutorials/sito blog 3fcea0c..DA74D68 Dev -> Origin/Dev

Il comando Fetch ha recuperato tutte le modifiche&rsquo;VE realizzato al nostro repository remoto. Il comando Fetch conosce il nostro ramo dev remoto contiene modifiche che non abbiamo sulla nostra macchina locale. Abbiamo appena recuperato i metadati per quei commit.

Possiamo recuperare i metadati per un singolo ramo usando il comando Git Fetch Origin.

Git: tira tutti i rami

Cosa succede se vuoi aggiornare la tua copia di lavoro locale e recuperare i metadati? Quello&rsquo;s dove il comando git pull è utile.

“La carriera Karma è entrata in vita mia quando ne avevo più bisogno e mi ha aiutato rapidamente a abbinare con un bootcamp. Due mesi dopo la laurea, ho trovato il lavoro dei miei sogni in linea con i miei valori e obiettivi nella vita!”

Venus, ingegnere del software su Rockbot

Trova la tua partita di bootcamp

Ora sappiamo che sono state apportate modifiche al nostro repository. Siamo contenti di unire questi cambiamenti con il nostro repository locale. Per scaricare le modifiche alla nostra macchina locale, dobbiamo utilizzare il comando Git Pull:

Noi&rsquo;Ve ha usato il flag per indicare che vogliamo recuperare le modifiche da ogni ramo. Il nostro comando ritorna:

Recuperare origine remoto: elenchi di oggetti: 5, fatto. remoto: conteggio di oggetti: 100% (5/5), fatto. Remoto: Totale 3 (Delta 0), riutilizzato 0 (Delta 0), RUBBIUTO 0 Oggetti di disimballaggio: 100% (3/3), fatto. Da https: // github.com/carriera-karma-tutorials/sito blog 3fcea0c..DA74D68 Dev -> Origin/Dev Aggiornamento 3FCEA0C..DA74D68 Readme veloce.MD | 1 + 1 file modificato, 1 inserzione ( +)

Il comando Git pull prima esegue un comando Git Fetch per verificare le modifiche. L’operazione di recupero restituisce i metadati per i nostri commit . Quindi, il comando Git Pull recupera tutte le modifiche che abbiamo apportato al nostro repository remoto e modifica i nostri file locali.

Possiamo vedere il Readme.Il file MD è stato modificato nel nostro repository remoto. Ora che noi&rsquo;VE Esegui un’operazione pull, abbiamo la modifica sulla nostra macchina locale.

Per recuperare il codice da una filiale, potremmo usare il comando Git Pull Origin.

Conclusione

Il comando Git – Tutto il comando recupera i metadati su ogni modifica apportata a tutti i rami in un repository. Il comando Git – Tutti i download di tutte le modifiche apportate in tutte le filiali alla macchina locale.
Ora hai la conoscenza di cui hai bisogno per estrarre tutti i rami da Git come un professionista !

Chi siamo: Career Karma è una piattaforma progettata per aiutare le persone in cerca di lavoro a trovare, fare ricerche e connettersi con i programmi di formazione professionale per far avanzare le loro carriere. Scopri la pubblicazione CK.

Qual è il prossimo?

James Gallagher

Circa l’autore: James Gallagher è un programmatore autodidatta e il contenuto tecnico di Career Karma. Ha esperienza nella gamma di linguaggi di programmazione e ampie competenze in Python, HTML, CSS e JavaScript. James ha scritto centinaia di tutorial di programmazione e spesso contribuisce a pubblicazioni come Codecademy, Treehouse, Repl.It, Afrotech e altri.

articoli Correlati

• Git tira
• Errore: impossibile spingere alcuni ref a telecomando
• GIT: elenca i rami remoti
• Annulla git pull: una guida
• Git: tira tutti i rami

• Git reset in salvataggio
• Richiesta di pull Git: come creare una richiesta pull
• Git Fetch: una guida passo-passo
• Come usare Git Merge
• Git Cherry Pick: una guida passo-passo