Quelles sont les différences entre "git commit" et "git Push"?
Dans un tutoriel Git que je suis en train de parcourir, git commit est utilisé pour stocker les modifications apportées.
À quoi sert git Push alors?
En gros, git commit "enregistre les modifications dans le référentiel" tandis que git Push "met à jour les références distantes avec les objets associés". Ainsi, le premier est utilisé en connexion avec votre référentiel local, tandis que le second est utilisé pour interagir avec un référentiel distant.
Voici une belle image de Oliver Steele , qui explique le modèle git et les commandes:
En savoir plus sur git Push et git pull sur GitReady.com (l'article dont j'ai parlé en premier)
commit : ajout de modifications au référentiel local
Push : pour transférer le (s) dernier (s) commit (s) sur un serveur distant
Eh bien, fondamentalement, git commit place vos modifications dans votre référentiel local, tandis que git Push les envoie à l’emplacement distant.
git Push est utilisé pour ajouter les commits que vous avez effectués sur le référentiel local à un autre distant. Avec git pull, il permet aux utilisateurs de collaborer.
Puisque git est un système de contrôle de version distribué, la différence est que commit engage les modifications dans votre référentiel local, tandis que Push transmet les modifications à un référentiel distant.
git commit enregistrez vos modifications dans le répertoire local .
git Push update the remote repository avec vos modifications locales.
Commit : {Snapshot | Changeset | Fiche de l'histoire | Version | 'Enregistrer-sous'} d'un référentiel. Dépôt Git = série (arbre) de commits (plus quelques choses supplémentaires).
Local repository: référentiel sur votre machine.
Remote repository: référentiel sur un serveur (par exemple, Github.com).
git commit: Ajouter un nouveau commit (dernier commit + staged modifications) au local repository.
git Push, git pull: Synchronisez un local repository avec son repertoire remote associé. Push - applique les modifications depuis local dans remote , pull - applique les modifications depuis remote dans local .
Je veux juste ajouter les points suivants:
Yon ne peut pas pousser jusqu'à ce que vous validiez, car nous utilisons git Push pour pousser les commits effectués sur votre branche locale vers un référentiel distant.
La commande git Push prend deux arguments:
Un nom distant, par exemple, Origin Un nom de branche, par exemple, master.
Par exemple:
git Push <REMOTENAME> <BRANCHNAME>
git Push Origin master
Trois choses à noter:
1) Répertoire de travail ----- dossier où nos fichiers de codes sont présents
2) Répertoire local ------ Ceci est à l'intérieur de notre système. Quand nous faisons première fois COMMIT, ce référentiel local est créé. au même endroit où se trouve notre répertoire de travail,
Le fichier Checkit (.git) est créé.
Après cela, chaque fois que nous nous engageons, cela stockera le modifications apportées au fichier de répertoire de travail en Dépôt local (.git)
3) Référentiel distant ----- Ceci est situé en dehors de notre système, comme sur des serveurs situé n'importe où dans le monde. comme github . Quand nous faisons la commande Push, alors les codes de notre local le référentiel est stocké dans ce référentiel distant
Une analogie très grossière: si nous comparons git commit à l'enregistrement d'un fichier édité, alors git Push copiera ce fichier dans un autre emplacement.
S'il vous plaît, ne retirez pas cette analogie de ce contexte. Engager et pousser ne sont rien de plus que de sauvegarder et de copier un fichier édité. Cela dit, cela ne devrait servir qu'à des fins de comparaison.
git commit n’est rien d’autre que la sauvegarde officielle de nos modifications, nous pouvons envoyer un message de validation à chaque message de validation.
ce qui signifie que nous pouvons faire de nombreux commits avant de pousser Push to remote (nous pouvons voir la liste des commits et les messages).
et j'utilise git Push uniquement quand je voulais voir mon changement de télécommande (après je vérifierai si mon code a fonctionné en jenkins)
Il est plus facile de comprendre l'utilisation des commandes git add et commit si vous imaginez qu'un fichier journal est maintenu dans votre référentiel sous Github .
---------------- Day 1 --------------------
Message: Completed Task A
Index of files changed: File1, File2
Message: Completed Task B
Index of files changed: File2, File3
-------------------------------------------
---------------- Day 2 --------------------
Message: Corrected typos
Index of files changed: File3, File1
-------------------------------------------
...
...
...and so on
Je commence généralement ma journée par une requête git pull et la termine par une requête git Push. Ainsi, tout ce qui se trouve dans le compte rendu d'une journée correspond à ce qui se passe entre eux. Au cours de chaque journée, il y a une ou plusieurs tâches logiques que je complète et qui nécessitent de modifier quelques fichiers. Les fichiers édités lors de cette tâche sont répertoriés dans un index.
Chacune de ces sous-tâches (les tâches A et B ici) sont des commits individuels. La commande git add ajoute des fichiers à la liste "Index des fichiers modifiés". Ce processus est également appelé mise en attente et en réalité, les enregistrements ont été modifiés et les modifications effectuées. La commande git commit enregistre/finalise les modifications et la liste d'index correspondante, ainsi qu'un message personnalisé pouvant être utilisé pour référence ultérieure.
Rappelez-vous que vous ne modifiez que la copie locale de votre référentiel et non celle de Github. Après cela, ce n’est que lorsque vous faites un git Push que toutes ces modifications enregistrées, ainsi que vos fichiers d’index pour chaque commit, sont consignés dans le référentiel principal (sur Github).
Par exemple, pour obtenir la deuxième entrée de ce fichier journal imaginaire, j'aurais fait:
git pull
# Make changes to File3 and File4
git add File3 File4
# Verify changes, run tests etc..
git commit -m 'Corrected typos'
git Push
En bref, git add et git commit vous permettent de décomposer une modification du référentiel principal en sous-modifications logiques systématiques. Comme d'autres réponses et commentaires l'ont souligné, leur utilisation est bien plus fréquente. Cependant, c’est l’un des usages les plus courants et un principe fondamental qui explique que Git soit un système de contrôle de révision en plusieurs étapes, contrairement à d’autres systèmes populaires tels que Svn.