Git Pull expliqué

Résumé:

Git Pull est une commande couramment utilisée dans GIT qui est utilisée pour récupérer et fusionner les modifications d’un référentiel distant à votre référentiel local. Il met à jour votre référentiel local avec les dernières modifications du référentiel distant.

Points clés:

1. Git Pull combine les commandes Git Fetch et Git Merge dans une commande pratique.
2. Il est utilisé pour récupérer les derniers modifications du référentiel distant et les fusionner avec votre branche locale.
3. Git Pull peut être utilisé pour mettre à jour plusieurs branches de votre référentiel local.
4. Lorsque vous exécutez Git Pull, il vérifie s’il y a de nouvelles modifications dans le référentiel distant depuis votre dernier traction.
5. S’il y a de nouvelles modifications, Git Pull Télécharges et applique ces modifications à votre référentiel local.
6. Git Pull fusionne automatiquement les modifications avec votre branche locale.
7. S’il y a des conflits pendant le processus de fusion, vous devez les résoudre manuellement.
8. Vous pouvez utiliser l’origine Git Pull commande pour mettre à jour une branche spécifique.
9. Git Pull est une commande utile pour maintenir votre référentiel local à jour avec le référentiel distant.
10. Il est recommandé d’exécuter régulièrement Git Pull pour vous assurer que vous avez les derniers modifications.

Des questions:

1. Git tire-t-il toutes les branches?

Lorsque vous exécutez Git Pull, il met à jour la branche actuelle de votre référentiel local avec les modifications du référentiel distant. Il ne met pas automatiquement à jour toutes les branches de votre référentiel local.

2. Comment fonctionne la traction Git?

Git Pull combine les commandes Git Fetch et Git Merge. Il récupère d’abord les derniers modifications du référentiel distant, puis fusionne ces modifications avec votre branche locale. S’il y a des conflits pendant le processus de fusion, vous devez les résoudre manuellement.

3. Peut git tirer à jour une branche spécifique?

Oui, vous pouvez utiliser l’origine Git Pull commande pour mettre à jour une branche spécifique dans votre référentiel local avec les modifications du référentiel distant.

4. À quelle fréquence dois-je exécuter Git Pull?

Il est recommandé d’exécuter régulièrement Git Tull, surtout avant de commencer tout travail ou de pousser vos modifications au référentiel distant. Cela garantit que vous avez les derniers changements et réduit les chances de conflits.

5. Que se passe-t-il s’il y a des conflits pendant Git Pull?

S’il y a des conflits pendant le processus de fusion, Git Pull s’arrête et vous invite à résoudre les conflits manuellement. Vous devez modifier les fichiers contradictoires, résoudre les conflits, puis commettre les modifications.

6. Puis-je annuler une traction git?

Annuler une traction Git peut être un peu délicat. Une fois que vous avez tiré les modifications du référentiel distant et les avez fusionnés dans votre branche locale, cela fait partie de votre historique de validation. Vous pouvez utiliser Git Revert pour retourner les modifications, mais il est recommandé de créer une sauvegarde ou de consulter votre équipe avant d’effectuer des opérations d’annulation.

7. Peut-on tirer l’écrasement des changements locaux?

Si vous avez apporté des modifications locales à un fichier qui a également été modifié dans le référentiel distant, Git Pull essaie de fusionner automatiquement ces modifications. S’il y a des conflits, cela vous invite à les résoudre manuellement. Par défaut, Git Pull ne remplace pas avec force vos modifications locales sans votre permission.

8. Comment puis-je vérifier si ma succursale locale est à jour avec la succursale distante?

Vous pouvez utiliser la commande Git Branch pour vérifier si votre branche locale est à jour avec la branche distante. Après avoir exécuté Git Pull, vous pouvez utiliser Git Branch -VV pour afficher des informations plus détaillées sur vos succursales locales et distantes.

9. Puis-je utiliser Git Pull pour mettre à jour plusieurs branches?

Oui, Git Pull peut être utilisé pour mettre à jour plusieurs branches de votre référentiel local. Vous pouvez passer à une branche spécifique et exécuter Git Pull pour mettre à jour cette branche avec les dernières modifications du référentiel distant.

dix. Git tire-t-il le même que Git récupérer?

Non, Git Pull n’est pas le même que Git Fetch. Git Fetch ne télécharge que les derniers modifications du référentiel distant mais ne les fusionne pas avec votre branche locale. Git Pull, en revanche, récupère les modifications et les fusionne avec votre branche locale.

11. Peut git till être utilisé pour mettre à jour une branche à partir d’un autre référentiel distant?

Oui, vous pouvez spécifier le référentiel distant lors de l’exécution de la commande git pull. Par exemple, Git Pull met à jour la branche spécifiée du référentiel distant spécifié.

12. Puis-je exécuter Git Pull sans spécifier une branche?

Si vous exécutez Git Pull sans spécifier une branche, il met à jour la branche actuelle de votre référentiel local avec les modifications du référentiel distant.

13. Puis-je utiliser Git Pull pour mettre à jour une branche vers un engagement spécifique?

Non, Git Pull est principalement utilisé pour mettre à jour une branche avec les dernières modifications du référentiel distant. Si vous souhaitez mettre à jour une branche vers un engagement spécifique, vous pouvez utiliser la commande GIT RESET.

14. Comment puis-je éviter les conflits pendant Git Pull?

Pour éviter les conflits pendant Git Pull, il est recommandé de mettre à jour régulièrement votre référentiel local avec les dernières modifications du référentiel distant en exécutant Git Pull. Cela aide à garder vos branches locales et distantes en synchronisation. C’est aussi une bonne pratique de communiquer et de se coordonner avec votre équipe pour minimiser les chances de changements contradictoires.

15. Peut git extraire des fichiers de suppression dans mon référentiel local?

Non, Git Pull ne supprime pas les fichiers dans votre référentiel local à moins qu’ils aient été supprimés dans le référentiel distant. Même dans ce cas, Git Pull essaie de fusionner les modifications et préserve vos modifications locales si possible. Cependant, c’est toujours une bonne pratique pour sauvegarder votre référentiel local avant d’effectuer des opérations de fusion.

Git Pull expliqué

Courir branche git encore et vérifier si les branches existent localement:

Git tire-t-il toutes les branches

Changements dans le tire manuel

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

Vérifiez votre version de Git en fonctionnant

NOM

git-pull – récupérer et intégrer à un autre référentiel ou à une branche locale

SYNOPSIS

tirage git [] [[…]]

DESCRIPTION

Intègre des modifications d’un référentiel distant dans la branche actuelle. Si la branche actuelle est derrière la télécommande, alors par défaut, il a rapidement obtenu la branche actuelle pour correspondre à la télécommande. Si la branche actuelle et la télécommande ont divergé, l’utilisateur doit spécifier comment réconcilier les branches divergentes avec –rebase ou –no-rebase (ou l’option de configuration correspondante dans Pull.Rebase).

Plus précisément, Git Pull exécute Git Fetch avec les paramètres donnés, puis en fonction des options de configuration ou des drapeaux de ligne de commande, appellera Git Rebase ou Git Merge pour réconcilier les branches divergentes.

devrait être le nom d’un référentiel distant admis à Git-Fetch [1]. peut nommer une réf à distance arbitraire (par exemple, le nom d’une balise) ou même une collection d’arbitres avec des branches de suivi de télécommande correspondantes (E.g., Réfs / Heads / *: Refs / Remotes / Origin / *), mais c’est généralement le nom d’une branche dans le référentiel distant.

Les valeurs par défaut pour et sont lues à partir de la configuration “télécommande” et “fusion” pour la branche actuelle telle que définie par Git-Branch [1] –Track .

Supposons que l’histoire suivante existe et que la branche actuelle est “maître”:

A --- b --- c maître sur l'origine / d --- e --- f --- g maître ^ origine / maître dans votre référentiel

Ensuite, “Git Pull” va récupérer et rejouer les modifications de la branche maître distante car elle a divergé du maître local (i.e., E) jusqu’à ce que son engagement actuel (c) en plus du maître et enregistre le résultat dans un nouvel engagement avec les noms des deux parents et un message de journal de l’utilisateur décrivant les modifications.

A --- b --- c Origin / maître / \ d --- e --- f --- g --- h Master

Voir Git-Merge [1] pour plus de détails, y compris comment les conflits sont présentés et gérés.

Dans Git 1.7.0 ou version ultérieure, pour annuler une fusion contradictoire, utilisez Git Reset – Merge . Avertissement: Dans les anciennes versions de Git, courir tirage git Avec des changements non engagés, il est découragé: bien que possible, il vous laisse dans un état qui peut être difficile à reculer dans le cas d’un conflit.

Si l’une des modifications à distance se chevauche avec des modifications locales non engagées, la fusion sera automatiquement annulée et l’arbre de travail intact. Il est généralement préférable d’obtenir des changements locaux en état de marche avant de les retirer ou de les ranger avec Git-stash [1].

Options

Ceci est transmis à la fois sous-jacent git-fetch pour faire des reportages silencieux pendant le transfert, et sous-jacent de la gitge à la sortie de silence pendant la fusion lors de la fusion.

Pass –verbose à git-fetch et git-merge.

Cette option contrôle si de nouveaux engins de sous-modules peuplés doivent être récupérés, et si les arbres de sous-modules actifs doivent également être mis à jour (voir Git-Fetch [1], Git-Config [1] et Gitmodules [5]).

Si le paiement est effectué via Rebase, les commits du sous-module local sont également redigées.

Si la mise à jour est effectuée via la fusion, les conflits de sous-module sont résolus et vérifiés.

Options liées à la fusion

–engager – pas-commit

Effectuez la fusion et engagez le résultat. Cette option peut être utilisée pour remplacer -. Uniquement utile lors de la fusion.

Avec – pas-Commit effectuez la fusion et arrêtez-vous juste avant de créer un engagement de fusion, pour donner à l’utilisateur une chance d’inspecter et de modifier davantage le résultat de la fusion avant de s’engager.

Notez que les mises à jour rapide ne créent pas de commit de fusion et il n’y a donc aucun moyen d’arrêter ces fusions avec -. Ainsi, si vous souhaitez vous assurer que votre branche n’est pas modifiée ou mise à jour par la commande Merge, utilisez –no-f avec -.

–Edit -e –no-edit

Invoquez un éditeur avant de commettre une fusion mécanique réussie pour éditer davantage le message de fusion généré automatiquement, afin que l’utilisateur puisse expliquer et justifier la fusion. L’option –no-edit peut être utilisée pour accepter le message généré automatiquement (ceci est généralement découragé).

Les scripts plus anciens peuvent dépendre du comportement historique de ne pas permettre à l’utilisateur de modifier le message du journal de fusion. Ils verront un éditeur ouvert lorsqu’ils exécuteront Git Merge . Pour faciliter l’ajustement de ces scripts au comportement mis à jour, la variable d’environnement GIT_MERGE_AUTOEDIT peut être définie sur le début d’eux.

Cette option détermine comment le message de fusion sera nettoyé avant de s’engager. Voir Git-Commit [1] pour plus de détails. De plus, si la valeur des ciseaux est donnée, les ciseaux seront annexés pour fusionner_msg avant d’être transmis à la machinerie commet dans le cas d’un conflit de fusion.

Mettre à jour uniquement la nouvelle histoire s’il n’y a pas d’histoire locale divergente. Ceci est la valeur par défaut lorsqu’aucune méthode de réconciliation des histoires divergentes n’est fournie (via les drapeaux –rebase = *).

Lors de la fusion plutôt que de rebasser, spécifie comment une fusion est gérée lorsque l’histoire fusionnée est déjà un descendant de l’histoire actuelle. Si la fusion est demandée, –ff est la valeur par défaut, sauf si la fusion d’une balise annotée (et éventuellement signée) qui n’est pas stockée à sa place naturelle dans les refs / tags / hiérarchie, auquel cas –no-f.

Avec –ff, si possible, résolvez la fusion comme un avance rapide (mettez uniquement à mettre à jour le pointeur de la branche pour correspondre à la branche fusionnée; ne créez pas de commit de fusion). Lorsqu’il n’est pas possible (lorsque l’histoire fusionnée n’est pas un descendant de l’histoire actuelle), créez un engagement de fusion.

Avec –no-ff, créez un engagement de fusion dans tous les cas, même lorsque la fusion pourrait plutôt être résolue comme un avance rapide.

-S [] –gpg-Sign [=] –no-gpg-SIGN

GPG-Signe la fusion résultante. L’argument KeyId est facultatif et par défaut de l’identité de l’engagement; S’il est spécifié, il doit être collé à l’option sans espace. –NO-GPG-SIGN est utile pour contrer les deux.Variable de configuration GPGSign, et antérieure – GPG-SIGN .

En plus des noms de branche, remplissez le message du journal avec des descriptions en une ligne du plus réels qui sont fusionnés. Voir aussi Git-Fmt-Merge-MSG [1]. Uniquement utile lors de la fusion.

Avec –no-log, ne répertoriez pas les descriptions d’une ligne des commits réels en cours de fusion.

–panneau – no-signal

Ajoutez une bande-annonce signée par le commiss à la fin du message du journal de validation. Le sens d’une panneau dépend du projet auquel vous’REMISSER. Par exemple, il peut certifier que l’engagement a le droit de soumettre les travaux dans le cadre du projet’s licence ou accepte une représentation des contributeurs, comme un certificat d’origine du développeur. (Voir http: // DevelopperCertificate.org pour celui utilisé par les projets du noyau et Git Linux.) Consulter la documentation ou le leadership du projet auquel vous’Rendez-vous à comprendre comment les signes sont utilisés dans ce projet.

L’option –No-Signoff peut être utilisée pour contrer une option de signature antérieure sur la ligne de commande.

–stat -n –no-stat

Montrer un diffstat à la fin de la fusion. Le diffstat est également contrôlé par l’option de configuration fusion.stat.

Avec -n ou –no-stat ne montrent pas de diffstat à la fin de la fusion.

–Squash – Pas de squash

Produisez l’arborescence et l’état d’index comme si une véritable fusion se produisait (à l’exception des informations de fusion), mais ne vous engagez pas, déplacez la tête ou enregistrez $ git_dir / merge_head (pour faire en sorte que la prochaine commande GIT Commit pour créer un engagement de fusion). Cela vous permet de créer un seul engagement au-dessus de la branche actuelle dont l’effet est le même que la fusion d’une autre branche (ou plus en cas de poulpe).

Avec –no-squash effectuez la fusion et engagez le résultat. Cette option peut être utilisée pour remplacer – Squash.

Avec –Squash, – – Commit n’est pas autorisé et échouera.

Uniquement utile lors de la fusion.

Par défaut, les crochets pré-fumer et commit-MSG sont exécutés. Quand –No-Verify est donné, ceux-ci sont contournés. Voir aussi Githooks [5]. Uniquement utile lors de la fusion.

Utilisez la stratégie de fusion donnée; peut être fourni plus d’une fois pour les spécifier dans l’ordre, ils doivent être essayés. S’il n’y a pas d’option -s, une liste de stratégies intégrée est utilisée à la place (ORT lors de la fusion d’une seule tête, Octopus autrement).

Passer une option spécifique à la stratégie de fusion à la stratégie de fusion.

Vérifiez que le conseil d’administration de la branche latérale fusionnée est signé avec une clé valide, je.e. Une clé qui a un UID valide: dans le modèle de confiance par défaut, cela signifie que la clé de signature a été signée par une clé de confiance. Si le conseil d’administration de la branche latérale n’est pas signé avec une clé valide, la fusion est abandonnée.

Uniquement utile lors de la fusion.

–Résumé – pas

Synonymes à –stat et –no-stat; Ceux-ci sont dépréciés et seront supprimés à l’avenir.

Créez automatiquement une entrée de cachette temporaire avant le début de l’opération, enregistrez-la dans la réf. Special Merge_Autostash et appliquez-la après la fin de l’opération. Cela signifie que vous pouvez exécuter l’opération sur un stress worktree. Cependant, utilisez avec soin: la demande finale de cachette après une fusion réussie peut entraîner des conflits non triviaux.

Par défaut, Git Merge Command refuse de fusionner des histoires qui ne partagent pas un ancêtre commun. Cette option peut être utilisée pour remplacer cette sécurité lors de la fusion des histoires de deux projets qui ont commencé leur vie indépendamment. Comme il s’agit d’une occasion très rare, aucune variable de configuration pour permettre cela par défaut n’existe et ne sera pas ajoutée.

Uniquement utile lors de la fusion.

-r –rebase [= false | true | fusion | interactif]

Lorsqu’il est vrai, réprimandez la branche actuelle sur le dessus de la branche en amont après avoir récupéré. S’il y a une branche de suivi à distance correspondant à la branche en amont et que la branche en amont a été rebasée depuis la dernière allure, la Rebase utilise ces informations pour éviter de reprendre des changements non locaux.

Lorsqu’il est défini sur les fusions, réprimandez à l’aide de Git Rebase –rebase-Merghes afin que les commits de fusion locaux soient inclus dans la Rebase (voir Git-Rebase [1] pour plus de détails).

Lorsqu’il est faux, fusionnez la branche en amont dans la branche actuelle.

Lorsqu’il est interactif, activez le mode interactif de la rebase.

Voir Pull.Rebase, branche..Rebase et branche.AutoSetuprebase dans Git-Config [1] Si vous souhaitez faire en sorte que Git Tull utilise toujours – Rebase au lieu de fusionner.

C’est une raccourci pour –rebase = false.

Options liées à la récupération

Récupérer tous les télécommandes.

Ajouter les noms et les noms d’objets des références récupérées au contenu existant de .git / fetch_head . Sans cette option, vieilles données dans .git / fetch_head sera écrasé.

Utilisez une transaction atomique pour mettre à jour les références locales. Soit tous les arbitres sont mis à jour, soit sur l’erreur, aucun arbitre n’est mis à jour.

Limiter la récupération au nombre spécifié de validations à partir de la pointe de chaque historique de branche distante. Si vous récupérez à un peu profond Référentiel créé par Git Clone avec – Depth = Option (voir Git-Clone [1]), approfondir ou raccourcir l’histoire au nombre spécifié de validations. Les balises pour les validations approfondies ne sont pas récupérées.

Similaire à – Depth, sauf qu’il spécifie le nombre de validations de la frontière peu profonde actuelle au lieu de la pointe de chaque branche distante de l’historique de la branche.

Approfondir ou raccourcir l’histoire d’un référentiel superficiel pour inclure tous les engins accessibles après .

Approfondir ou raccourcir l’historique d’un référentiel peu profond pour exclure les engins accessibles d’une branche ou d’une balise distante spécifiée. Cette option peut être spécifiée plusieurs fois.

Si le référentiel source est terminé, convertissez un référentiel peu profond en un référentiel complet, en supprimant toutes les limitations imposées par les référentiels peu profonds.

Si le référentiel source est superficiel, récupérez autant que possible pour que le référentiel actuel ait le même historique que le référentiel source.

–mise à jour

Par défaut, lors de la récupération d’un référentiel peu profond, Git Fetch refuse les références qui nécessitent une mise à jour .git / peu profond. Cette option se met à jour .git / peu profond et accepter ces arbitres.

Par défaut, Git rapportera, au serveur, les engagements accessibles de toutes les arbitres locaux pour trouver des engins communs pour tenter de réduire la taille du packfile de réception. S’il est spécifié, Git ne rapportera que Commits Accessibles à partir des conseils donnés. Ceci est utile pour accélérer les récupérations lorsque l’utilisateur sait quel REF local est susceptible d’avoir des engagements en commun avec la référence en amont.

Cette option peut être spécifiée plus d’une fois; Si c’est le cas, Git rapportera des commits accessibles à l’un des commits donnés.

L’argument de cette option peut être un globe sur les noms de reflète, une réf, ou le SHA-1 (éventuellement abrégé) d’un engagement. La spécification d’un glob est équivalent à spécifier cette option plusieurs fois, une pour chaque nom de référence correspondant.

Voir aussi la récupération.négociationalgorithme et pousser.Négocier les variables de configuration documentées dans Git-Config [1] et l’option – negotiate uniquement ci-dessous.

–négocier uniquement

Ne pas récupérer rien du serveur et imprimez plutôt les ancêtres des arguments fournis – Négotiation-tip = *, que nous avons en commun avec le serveur.

Ceci est incompatible avec –Recurse-submodules = [Oui | à la demande] . En interne, ceci est utilisé pour implémenter la poussée.Négocier l’option, voir Git-Config [1].

Montrez ce qui serait fait, sans apporter de modifications.

Quand git chercher est utilisé avec: refspec, il peut refuser de mettre à jour la branche locale comme discuté dans la partie de la documentation Git-Fetch [1]. Cette option remplace cette vérification.

Gardez le pack téléchargé.

Modifiez le refspec configuré pour placer toutes les références dans l’espace Refs / Prefetch / Names. Voir la tâche de préfescée dans Git-Maintenne [1].

Avant de récupérer, supprimez toutes les références de suivi à distance qui n’existent plus sur la télécommande. Les balises ne sont pas soumises à l’élagage si elles sont récupérées uniquement en raison du suivi automatique des balises par défaut ou en raison d’une option – Tags. Cependant, si les balises sont récupérées en raison d’un refspec explicite (soit sur la ligne de commande, soit dans la configuration distante, par exemple si la télécommande a été clonée avec l’option – miroir), alors ils sont également soumis à l’élagage. Fourniture – Prune-Tags est une raccourci pour fournir le tag refspec.

Par défaut, les balises qui pointent sur les objets téléchargés à partir du référentiel distant sont récupérés et stockés localement. Cette option désactive cette balise automatique après. Le comportement par défaut pour une télécommande peut être spécifié avec la télécommande..paramètre Tagopt. Voir Git-Config [1].

Lors de la récupération des refs répertoriés sur la ligne de commande, utilisez le refspec spécifié (peut être donné plus d’une fois) pour mapper les références aux branches de suivi de télécommande, au lieu des valeurs de télécommande.*.Répondez les variables de configuration pour le référentiel distant. Fournir une option vide à l’option – Refmap amène Git à ignorer les refspecs configurées et à s’appuyer entièrement sur les refscs fournis comme arguments en ligne de commandement. Voir la section sur les «branches de suivi de la télécommande configurées» pour plus de détails.

Répondez toutes les balises de la télécommande (je.e., Réfondez des balises distantes refs / balises / * en balises locales avec le même nom), en plus de tout ce qui serait autrement récupéré. L’utilisation de cette option seule ne soumet pas les balises à l’élagage, même si – unepune est utilisée (bien que les balises puissent être taillées de toute façon si elles sont également la destination d’un refspec explicite; voir –prune).

Nombre d’enfants parallèles à utiliser pour toutes les formes de récupération.

Si l’option –multiple était spécifiée, les différents télécommandes seront récupérés en parallèle. Si plusieurs sous-modules sont récupérés, ils seront récupérés en parallèle. Pour les contrôler indépendamment, utilisez les paramètres de configuration récupérer.parallèle et sous-module.FetchJobs (voir Git-Config [1]).

En règle générale, les récupérations parallèles récursives et multi-recul seront plus rapides. Par défaut, les récupérations sont effectuées séquentiellement, pas en parallèle.

–installer

Si la télécommande est récupérée avec succès, ajoutez une référence en amont (suivi), utilisée par Git-Pull sans argument [1] et d’autres commandes. Pour plus d’informations, voir la branche..fusionner et branche..Remote dans Git-Config [1].

Lorsqu’il est donné, et le référentiel à récupérer est géré par git fetch-pack, –exec = est transmis à la commande pour spécifier le chemin d’accès sans défaut pour l’exécution de la commande à l’autre extrémité.

L’état de progression est signalé sur le flux d’erreur standard par défaut lorsqu’il est attaché à un terminal, sauf si -Q est spécifié. Cet drapeau oblige le statut de progression même si le flux d’erreur standard n’est pas dirigé vers un terminal.

Transmettez la chaîne donnée au serveur lors de la communication à l’aide du protocole version 2. La chaîne donnée ne doit pas contenir de caractère NUL ou LF. Le serveur’Le traitement des options de serveur, y compris des inconnues, est spécifique au serveur. Lorsque plusieurs – server-option = sont donnés, ils sont tous envoyés de l’autre côté dans l’ordre indiqué sur la ligne de commande.

Par défaut, Git vérifie si une branche est mise à jour pendant la fetch. Cela peut être désactivé via Fetch.ShowForcedUpdates, mais l’option de dates forcées – garantit ce chèque se produit. Voir Git-Config [1].

Par défaut, Git vérifie si une branche est mise à jour pendant la fetch. Pass – pas de dames forcées ou réglez-vous chercher.ShowForceDudates à false pour ignorer ce chèque pour des raisons de performance. Si vous êtes utilisé pendant tire L’option –ff uniquement vérifiera toujours les mises à jour forcées avant de tenter une mise à jour rapide. Voir Git-Config [1].

Utilisez uniquement les adresses IPv4, en ignorant les adresses IPv6.

Utilisez uniquement les adresses IPv6, en ignorant les adresses IPv4.

Le référentiel “distant” qui est la source d’une opération de récupération ou de traction. Ce paramètre peut être soit une URL (voir les URL Git de la section ci-dessous) ou le nom d’une télécommande (voir les télécommandes de la section ci-dessous).

Spécifie les arbitres pour récupérer et les arbitres locaux à mettre à jour. Lorsqu’aucun s apparaît sur la ligne de commande, les arbitres à récupérer sont lus à partir de distance..Répondez à la place des variables (voir la section “Branches de suivi à distance configurées” dans Git-Fetch [1]).

Le format d’un paramètre est un plus + facultatif, suivi de la source, suivi d’un côlon:, suivi de la destination de la destination . Le côlon peut être omis quand est vide. est généralement une référence, mais elle peut aussi être un nom d’objet hexagonal entièrement orthographié.

A peut contenir un * dans son pour indiquer une correspondance de motif simple. Un tel refspec fonctionne comme un globe qui correspond à n’importe quel reflète avec le même préfixe. Un motif doit avoir un * dans les deux et . Il mappera les arbitres à la destination en remplaçant le * le contenu correspondant à la source.

Si un refspec est préfixé par ^, il sera interprété comme un refspec négatif. Plutôt que de spécifier quelles références pour récupérer ou les arbitres locaux à mettre à jour, un tel refspec spécifiera plutôt les références pour exclure. Un reflète sera considéré comme correspondant s’il correspond au moins un refspec positif et ne correspond à aucun refspec négatif. Les refscs négatifs peuvent être utiles pour restreindre la portée d’un motif refspec afin qu’il n’inclue pas les références spécifiques. Les refspecs négatifs peuvent eux-mêmes être des refspecs de modèle. Cependant, ils ne peuvent contenir qu’à et ne spécifient pas un . Les noms d’objets hexadécimaux entièrement orthographiés ne sont également pas pris en charge.

Le balise signifie la même chose que Refs / Tags /: Refs / Tags /; il demande à tout chercher à la balise donnée.

La référence distante qui correspond est récupérée, et si ce n’est pas une chaîne vide, une tentative est faite pour mettre à jour l’arbitre local qui le correspond.

Si cette mise à jour est autorisée sans – Force dépend de l’espace de noms de la référence’s récupéré, le type d’objet est récupéré, et si la mise à jour est considérée comme une avance rapide. Généralement, les mêmes règles s’appliquent à la récupération que lors de la poussée, voir le . Section de Git-push [1] pour ce que ce sont. Exceptions à ces règles particulières à git chercher sont notés ci-dessous.

Jusqu’à Git version 2.20, et contrairement à la poussée avec Git-push [1], toutes les mises à jour des références / tags / * seraient acceptées sans + dans le refspec (ou –force). Lors de la récupération, nous avons considérablement considéré toutes les mises à jour de balises d’une télécommande pour être forcée. Depuis Git version 2.20, aller chercher pour mettre à jour les références / tags / * fonctionne de la même manière qu’en poussant. je.e. Toutes les mises à jour seront rejetées sans + dans le refspec (ou –force).

Contrairement à la poussée avec Git-push [1], toutes les mises à jour en dehors de Refs // * seront acceptées sans + dans le refspec (ou –force), que ce soit’s échange e.g. un objet d’arbre pour un blob, ou un engagement pour un autre engagement’s ne fait pas’T a le commit précédent en tant qu’ancêtre etc.

Contrairement à la poussée avec Git-push [1], il n’y a aucune configuration qui’LL modifier ces règles, et rien de tel qu’un crochet pré-fetch analogue au crochet avant le receive.

Comme pour pousser avec Git-push [1], toutes les règles décrites ci-dessus’S pas autorisé car une mise à jour peut être remplacée en ajoutant une leader facultatif + à une option RefSpec (ou en utilisant – Force de la ligne de commande). La seule exception à cela est qu’aucune quantité de forçage ne fera que les arbitres / têtes / * l’espace de noms accepteront un objet non engagé.

Git Pull expliqué

Git Pull est une commande git utilisée pour mettre à jour la version locale d’un référentiel à partir d’une télécommande.

C’est l’une des quatre commandes qui invite l’interaction réseau par git. Par défaut, Git Pull fait deux choses.

1. Met à jour la branche de travail locale actuelle (branche actuellement vérifiée)
2. Met à jour les branches de suivi à distance pour toutes les autres branches.

git tiret récupére (git fetch) les nouveaux engagements et fusionnent (Git fusionnent) dans votre branche locale.

Cette commande’La syntaxe S est la suivante:

# Format général Git Pull Options Repository RefSpec # Pull de la branche spécifique Git Pull Name de branche

• Options sont les options de commande, telles que –quiet ou –verbose . Vous pouvez en savoir plus sur les différentes options de la documentation GIT
• DÉPÔT Est-ce que l’URL de votre dépôt. Exemple: https: // github.com / freecodecamp / freecodecamp.git
• Refspec Spécifie les arbitres pour récupérer et les arbitres locaux à mettre à jour
• Nom de télécommande est le nom de votre référentiel distant. Par exemple: origine.
• NOM DE LA FILIALE est le nom de votre branche. Par exemple: développer.

Note

Si vous avez des modifications non engagées, la partie fusion de la commande Git Pull échouera et votre branche locale sera intacte.

Ainsi, tu devrais commettez toujours vos modifications dans une branche avant de tirer Nouveaux engagements d’un référentiel distant.

Table des matières

• Utilisation de Git Pull
• Contrôle de version distribuée
• Git Fetch + Git Merge
• Git Pull in ides

Utilisation de Git Pull

Utilisez Git Pull pour mettre à jour un référentiel local à partir du référentiel distant correspondant. Ex: Tout en travaillant localement sur Master, exécutez Git Pull pour mettre à jour la copie locale de Master et mettre à jour les autres branches de suivi distantes. (Plus d’informations sur les succursales de suivi à distance dans la section suivante.)

Mais, il y a quelques choses à garder à l’esprit pour que cet exemple soit vrai:

Le référentiel local a un référentiel distant lié

• Vérifiez ceci en exécutant Git Remote -V
• S’il y a plusieurs télécommandes, Git Pull pourrait ne pas être suffisant d’informations. Vous devrez peut-être entrer dans Git Pull Origin ou Git Pull en amont .

La succursale à laquelle vous êtes actuellement vérifié a une branche de suivi à distance correspondante

• Vérifiez ceci en exécutant le statut GIT . S’il n’y a pas de branche de suivi à distance, Git ne fait pas’Je sais où extraire les informations depuis.

Contrôle de version distribuée

Git est un Système de contrôle de version distribué (DVC). Avec les DVC, les développeurs peuvent travailler sur le même fichier en même temps dans des environnements séparés. Après poussée coder jusqu’au référentiel à distance partagé, d’autres développeurs peuvent tirer code modifié.

Interactions de réseau dans GIT

Il n’y a que quatre commandes qui provoquent des interactions réseau dans GIT. Un référentiel local n’a aucune conscience des modifications apportées au référentiel distant jusqu’à ce qu’il y ait une demande d’informations. Et, un référentiel à distance n’a aucune conscience des modifications locales jusqu’à ce que les commits soient poussés.

Les quatre commandes de réseau sont:

• clone git
• git chercher
• tirage git
• push git

Branches en DVC

Lorsque vous travaillez avec Git, il peut sembler qu’il y a beaucoup de copies du même code flottant partout. Il existe différentes versions du même fichier sur chaque branche. Et, différentes copies des mêmes branches sur chaque développeur’ordinateur et sur la télécommande. Pour garder une trace de cela, Git utilise quelque chose appelé Branches de suivi à distance.

Si vous exécutez Git Branch – tout dans un référentiel GIT, les branches de suivi à distance apparaissent en rouge. Ce sont des copies en lecture seule du code telles qu’elle apparaît sur la télécommande. (Quand a été la dernière interaction réseau qui aurait apporté des informations localement? N’oubliez pas quand ces informations ont été mises à jour pour la dernière fois. Les informations dans les branches de suivi à distance reflètent les informations de cette interaction.)

Avec Branches de suivi à distance, Vous pouvez travailler dans Git sur plusieurs branches sans interaction réseau. Chaque fois que vous exécutez les commandes Git Pull ou Git Fetch, vous mettez à jour Branches de suivi à distance.

git fetch plus git fusiter

Git Pull est une commande de combinaison, égale à Git Fetch + Git Merge .

git chercher

En soi, Git Fetch met à jour toutes les branches de suivi distantes dans le référentiel local. Aucun changement n’est réellement reflété sur aucune des branches de travail locales.

git fusionner

Sans aucun argument, Git Merge fusionnera la branche de suivi à distance correspondante à la branche de travail locale.

tirage git

Git Fetch met à jour les branches de suivi à distance. Git Merge met à jour la branche actuelle avec la branche de suivi à distance correspondante. En utilisant Git Pull, vous obtenez les deux parties de ces mises à jour. Mais, cela signifie que si vous êtes vérifié sur la branche des fonctionnalités et que vous exécutez Git Pull, lorsque vous passerez à Master, les nouvelles mises à jour ne seront pas incluses. Chaque fois que vous passerez à une autre branche qui peut avoir de nouveaux changements, il’est toujours une bonne idée d’exécuter Git Pull .

Git Pull in ides

La langue commune dans d’autres ides peut ne pas inclure le mot traction . Si vous cherchez les mots Git Pull mais Don’t les voir, recherchez le mot synchronisé à la place.

Récupérer un PR distant (demande de traction) dans le référentiel local

Aux fins de l’examen et autres, PRS en télécommande doit être récupéré au dépôt local. Vous pouvez utiliser la commande git fetch comme suit pour y parvenir.

git fetch origin pull / id / tête: branchenname

ID est l’ID de demande de traction et la branche est le nom de la branche que vous souhaitez créer. Une fois la branche créée, vous pouvez utiliser Git Checkout pour passer à ce brach.

Autres ressources sur Git Vous pourriez aimer:

• Git Merge et Git Rebase
• Caisse git
• Git engager
• Cachette git
• Branche git

Comment tirer toutes les branches de Git

Git est un système de contrôle de version qui permet aux utilisateurs de maintenir plusieurs lignes de développement, i.e., succursales, dans un seul projet. Lorsque vous commencez à travailler sur un projet et que vous souhaitez cloner le référentiel dans une machine locale, Git vous permet de récupérer les branches individuelles ou toutes les branches distantes à la fois.

Dans ce tutoriel, vous apprendrez à tirer toutes les branches de Git.

• Git installé (voir comment installer Git sur Ubuntu, MacOS, Windows, Centos 7 ou Centos 8).
• Un référentiel Git.

Tirer toutes les branches de Git

Les succursales GIT peuvent être stockées dans un référentiel éloigné ou local. Lorsque vous souhaitez travailler sur une fonctionnalité d’une branche stockée dans un référentiel distant, vous devez d’abord le télécharger dans le référentiel local.

Les deux commandes Git utilisées pour télécharger le contenu à partir d’un référentiel distant sont Git Pull et git chercher :

• git chercher est la version la plus sûre de tirage git . Il télécharge le contenu distant sans mettre à jour l’état de travail du référentiel local, ce qui signifie que votre travail reste intact.
• tirage git est plus agressif car il télécharge le contenu du référentiel distant et exécute Git Merge sur la branche active locale. La fusion crée un nouveau commit de fusion et intègre le contenu avec votre travail. Cependant, la fusion du contenu comme celle-ci peut entraîner des conflits avec le travail en cours, et cela peut nécessiter une résolution manuelle.

Les sections ci-dessous montrent comment extraire toutes les branches GIT vers un référentiel local en utilisant les deux commandes.

Méthode Git Fetch

Avec git chercher , Vous pouvez télécharger des métadonnées à partir du référentiel distant sans affecter votre travail local. C’est une option utile lorsque vous souhaitez vérifier si un autre développeur a apporté des modifications dans le référentiel distant. git chercher est également utilisé lors du clonage d’un référentiel et du téléchargement des données sur une machine locale.

Le git chercher Commande récupère les dernières mises à jour du référentiel distant. Selon que vous souhaitiez télécharger des métadonnées pour les branches individuelles ou toutes les branches, la commande a les variations suivantes:

git chercher

• La commande récupère uniquement la branche spécifiée du référentiel distant.

git fetch - tout

• Une commande est considérée comme un mouvement de puissance car il récupère tous les télécommandes enregistrées et leurs branches.

Pour ce tutoriel, nous allons cloner un nouveau référentiel et récupérer toutes les branches associées. Suivez les étapes ci-dessous:

1. Ouvrez une invite de commande git bash sur Windows ou ouvrez une nouvelle fenêtre de terminal dans Linux (Ctrl+Alt+T) ou macOS.

2. Accédez au répertoire où vous souhaitez stocker les fichiers de référentiel. Utilisez la commande CD pour modifier le répertoire.

3. Sur github, localisez le référentiel distant que vous souhaitez cloner et cliquez sur le <> Code bouton. Par exemple, nous allons cloner le référentiel de kit de développement de logiciel API Bare Metal Cloud de Phoenixnap. La plate-forme BMC GitHub Actions vous permet d’automatiser les tâches dans votre référentiel GIT.

4. Dans le menu déroulant, sélectionnez l’option de sécurité que vous souhaitez utiliser pour Git et Copiez l’URL. Dans ce tutoriel, nous utiliserons HTTPS car il est le plus facile à mettre en place. Si vous voulez une option plus sécurisée, allez avec SSH.

5. Dans Git bash, clonez le référentiel distant en utilisant le clone git commande et l’URL que vous avez copiée. La syntaxe est:

clone git

6. Après cloner le référentiel, vérifiez les succursales disponibles dans les référentiels locaux et distants. Pour vérifier les succursales locales, exécutez:

branche git

Vérifiez les succursales disponibles à distance en fonctionnant:

Branche git -r

Seulement le développer La succursale est disponible dans le référentiel local, ce qui signifie que nous devons récupérer les autres.

7. Répondez les métadonnées pour les branches distantes et commencez à les suivre. Courir:

git fetch - tout

Le –tous Flag dit à Git de récupérer les métadonnées pour toutes les branches du référentiel.

8. Après avoir récupéré les métadonnées, commencez à suivre les branches avec cette commande:

Git Branch -r | grep -v '\ ->' | sed "s, \ x1b \ [[0-9;] * [a-za-z] ,, g" | tout en lisant à distance; Do Git Branch --Track "$" "$ Remote"; fait

La commande configure les branches du référentiel local et les fait suivre leurs homologues dans le référentiel distant.

Courir branche git encore et vérifier si les branches existent localement:

Dans l’exemple ci-dessus, nous voyons que toutes les branches du référentiel distant existent maintenant également dans le local.

Note: Lisez notre comparaison de SSH et HTTPS pour GIT.

Méthode de traction Git

Le tirage git la méthode est une combinaison de git chercher et git fusionner . La commande récupère les métadonnées de la branche du référentiel distant et met à jour votre copie de travail locale pour refléter les modifications.

Note: Le tirage git La méthode fonctionne mieux dans un référentiel existant où vous souhaitez que les changements mis en œuvre par d’autres développeurs reflètent dans votre référentiel local. Cloner un référentiel puis fonctionner tirage git ne donnerait aucun résultat, car tout est déjà à jour.

Suivez les étapes ci-dessous pour tirer toutes les branches distantes:

1. Ouvrez une fenêtre Git Bash et modifiez l’emplacement dans votre référentiel local.

2. Exécutez la commande suivante pour vous assurer que Git commence à suivre toutes les branches distantes, y compris celles qui n’existent pas dans votre copie locale:

Git Branch -r | grep -v '\ ->' | sed "s, \ x1b \ [[0-9;] * [a-za-z] ,, g" | tout en lisant à distance; Do Git Branch --Track "$" "$ Remote"; fait

7. Tirez toutes les branches du référentiel git distant:

git pull - tout

La sortie montre que toutes les branches distantes ont été tirées avec succès et affiche les modifications.

Ce tutoriel a montré comment tirer toutes les branches d’un référentiel distant à votre copie de travail locale. Il existe deux méthodes disponibles – git chercher et tirage git , chacun adapté à son propre cas d’utilisation.

En savoir plus sur Git dans notre guide de Git Débutant, ou télécharger une feuille de triche Git Commands Git et enregistrer pour une utilisation future.

Git: Tirez toutes les branches

Git vous permet de maintenir plusieurs lignes de développement distinctes pour un projet. Ces lignes de développement sont appelées branches. Vous pouvez récupérer la dernière version d’une branche à partir d’un référentiel distant indépendamment ou vous pouvez récupérer la dernière version de toutes les branches à la fois.

Dans ce guide, nous parlons de la façon d’utiliser le git fetch – tout et git till – tout pour récupérer les modifications d’un référentiel distant.

Qu’est-ce que la ramification?

Laisser&rsquo;S Disons que nous travaillons sur un site Web de blog. Nous&rsquo;Je vais ajouter une fonctionnalité au blog qui permet aux utilisateurs de commenter. Nous donnions&rsquo;T Je veux que cette fonctionnalité fasse partie de la version principale de notre projet parce que nous y travaillons toujours.

Trouvez votre match de bootcamp

• Le karma de carrière vous correspond aux meilleurs bootcamps technologiques
• Accédez aux bourses exclusives et aux cours de préparation

Sélectionnez votre intérêt
Prénom

Nom de famille

E-mail

Numéro de téléphone

En vous poursuivant, vous acceptez nos conditions d’utilisation et notre politique de confidentialité, et vous consentez à recevoir des offres et des opportunités de carrière par téléphone, SMS et e-mail.

Nous pouvons utiliser une branche git pour cela. Nous pouvons créer une branche appelée &ldquo;commentaires&rdquo; Pour stocker tout le code pour notre fonctionnalité de commentaires. Cela nous permettra de travailler sur notre fonctionnalité de commentaires sans modifier la version principale de notre base de code qui est déployée sur un site Web.

Les branches peuvent être stockées localement ou à distance. Si vous travaillez sur une version locale d’un projet, une succursale sera locale. Les succursales distantes sont stockées avec la version principale d’un projet.

Git: récupérer toutes les branches

Nous&rsquo;REVOIR SUR UN PROJET appelé Blog-Site. Ce projet contient deux branches: Origin Master and Origin Dev.

La branche Dev contient toutes les fonctionnalités expérimentales avec lesquelles nous travaillons. Nous pensons qu’un autre collaborateur a poussé les changements dans les deux branches. Nous voulons nous assurer et récupérer les métadonnées pour toute modification si elles ont été apportées.

Nous pouvons le faire en utilisant la commande fetch. La commande Fetch indique à Git de récupérer les métadonnées à partir d’une branche distante sur les dernières mises à jour. La commande fetch ne met pas à jour les fichiers stockés dans une version locale d’un référentiel.

Pour suivre toutes les branches éloignées et récupérer les métadonnées pour ces branches, nous pouvons utiliser la commande git fetch avec le drapeau –Al:

Cette commande renvoie:

Remote d'origine d'origine: énumération des objets: 5, fait. Remote: comptage des objets: 100% (5/5), fait. Remote: Total 3 (Delta 0), réutilisé 0 (Delta 0), Pack-Reusing 0 Objets de déballage: 100% (3/3), fait. De https: // github.com / carrière-karma-tutoriels / site blog 3fcea0c..DA74D68 Dev -> Origin / Dev

La commande Fetch a récupéré tous les changements que nous&rsquo;velle à notre référentiel distant. La commande fetch sait que notre branche de développement distant contient des modifications que nous n’avons pas sur notre machine locale. Nous venons de récupérer les métadonnées pour ces commits.

Nous pouvons récupérer les métadonnées pour une branche individuelle en utilisant la commande Git Fetch Origin.

Git: Tirez toutes les branches

Et si vous souhaitez mettre à jour votre copie de travail locale ainsi que récupérer les métadonnées? Ce&rsquo;s où la commande git till est utile.

“La carrière Karma est entrée dans ma vie quand j’en avais le plus besoin et m’a rapidement aidé à correspondre à un bootcamp. Deux mois après avoir obtenu mon diplôme, j’ai trouvé mon emploi de rêve qui s’alignait avec mes valeurs et mes objectifs dans la vie!”

Vénus, ingénieur logiciel chez Rockbot

Trouvez votre match de bootcamp

Nous savons maintenant que des changements ont été apportés à notre référentiel. Nous sommes satisfaits de fusionner ces changements avec notre référentiel local. Pour télécharger les modifications sur notre machine locale, nous devons utiliser la commande git till:

Nous&rsquo;Ve a utilisé le drapeau de tout pour indiquer que nous voulons récupérer les changements de chaque branche. Notre commande renvoie:

Remote d'origine d'origine: énumération des objets: 5, fait. Remote: comptage des objets: 100% (5/5), fait. Remote: Total 3 (Delta 0), réutilisé 0 (Delta 0), Pack-Reusing 0 Objets de déballage: 100% (3/3), fait. De https: // github.com / carrière-karma-tutoriels / site blog 3fcea0c..DA74D68 Dev -> Origin / Dev Mise à jour 3FCEA0C..DA74D68 Readme rapide rapide.MD | 1 + 1 fichier modifié, 1 insertion (+)

La commande git pull exécute d’abord une commande git fetch pour vérifier les modifications. L’opération de récupération renvoie les métadonnées pour nos commits . Ensuite, la commande git till récupère toutes les modifications que nous avons apportées à notre référentiel distant et modifie nos fichiers locaux.

Nous pouvons voir le Readme.Le fichier MD a été modifié sur notre référentiel distant. Maintenant que nous&rsquo;VE UNE OPÉRATION DE PULLE, nous avons le changement sur notre machine locale.

Pour récupérer le code à partir d’une branche, nous pourrions utiliser la commande Git Pull Origin.

Conclusion

La commande git fetch –all récupère les métadonnées sur chaque modification apportée à toutes les branches d’un référentiel. Le Git Pull – All Command télécharge toutes les modifications apportées à toutes les branches de votre machine locale.
Vous avez maintenant les connaissances dont vous avez besoin pour tirer toutes les branches de Git comme un pro !

À propos de nous: Career Karma est une plate-forme conçue pour aider les demandeurs d’emploi à trouver, rechercher et se connecter avec des programmes de formation professionnelle pour faire avancer leur carrière. Renseignez-vous sur la publication CK.

Et après?

James Gallagher

A propos de l’auteur: James Gallagher est un programmeur autodidacte et le responsable du contenu technique de Career Karma. Il a de l’expérience dans la gamme de langages de programmation et une vaste expertise en Python, HTML, CSS et JavaScript. James a écrit des centaines de tutoriels de programmation, et il contribue fréquemment à des publications comme Codecademy, Treehouse, REPT.It, Afrotech et autres.

Articles Liés

• Tirage git
• Erreur: n’a pas réussi à pousser certains arbitres à éloigner
• Git: énumérez les succursales distantes
• Annuler la traction Git: un guide
• Git: Tirez toutes les branches

• Git réinitialise le sauvetage
• Demande de traction GIT: comment créer une demande de traction
• Git Fetch: un guide étape par étape
• Comment utiliser Git Merge
• Git Cherry Pick: un guide étape par étape