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 que vous avez apscopes.

À quoi sert git push alors?

Fondamentalement, git commitenregistre les modifications apscopes au référentiel ” tandis que git pushmet à jour les références distantes avec les objects associés “. Le premier est donc utilisé avec votre référentiel local, tandis que le second est utilisé pour interagir avec un référentiel distant.

Voici une belle image d’ Oliver Steele , qui explique le modèle git et les commandes:

Commandes de transport de données Git

En savoir plus sur git push et git pull sur GitReady.com (l’article auquel j’ai fait référence en premier)

commit : ajout de modifications au référentiel local

push : pour transférer le dernier commit sur un serveur distant

Eh bien, fondamentalement, git commit place vos modifications dans votre repo local, tandis que git push envoie vos modifications à l’emplacement distant.

Git étant un système de contrôle de version dissortingbué, la différence réside dans le fait que le commit commettra des modifications dans votre référentiel local, alors que push poussera les modifications vers un repository à distance.

git push est utilisé pour append les commits que vous avez effectués sur le référentiel local à un repository distant – avec git pull , il permet aux utilisateurs de collaborer.

git commit enregistre vos modifications dans le référentiel local .

git push jour le référentiel distant avec vos modifications locales.

Commit : {Instantané | Changeset | Enregistrement de l’histoire | Version | ‘Enregistrer-sous’} d’un référentiel. Git repository = série (arbre) de commits (plus quelques éléments supplémentaires).

Dépôt local : référentiel sur votre machine.

Dépôt distant : référentiel sur un serveur (par exemple Github ).

git commit : ajoute un nouveau commit (dernier commit + modifications par étapes ) au référentiel local .

git push , git pull : synchronise le référentiel local avec un référentiel distant . push – appliquer les modifications de local à distant , pull – appliquer les modifications de distance à local .

Je veux juste append les points suivants:

Vous ne pouvez pas pousser jusqu’à ce que vous vous engagez, car nous utilisons git push pour pousser les commits effectués sur votre twig locale vers un référentiel distant.

La commande git push prend deux arguments:

Un nom distant, par exemple, origin Un nom de twig, par exemple master

Par exemple:

git push

Une analogie très grossière: si on compare git commit à la sauvegarde d’un fichier édité, alors git push copiera ce fichier à un autre endroit.

S’il vous plaît ne prenez pas cette analogie de ce contexte – commettre et pousser ne sont rien de plus que de sauvegarder un fichier édité et de le copier. Cela dit, il ne devrait tenir que pour les comparaisons.

Trois choses à noter:

1) Répertoire de travail —– dossier où nos fichiers de codes sont présents

2) Dépôt local —— Ceci est à l’intérieur de notre système. Lorsque nous effectuons la commande COMMIT pour la première fois, 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 commettrons, cela stockera les modifications que nous apportons dans le fichier du répertoire de travail au référentiel local (.git)

3) Référentiel distant —– Celui-ci est situé en dehors de notre système, comme sur les serveurs situés partout dans le monde. comme github. Lorsque nous faisons une commande PUSH, les codes de notre repository local sont stockés dans ce référentiel distant.

en termes simples, git commit est l’étape avant que git push vous les exécutez dans cet ordre pour réussir à envoyer votre fichier à github.

git commit n’est rien d’autre que de sauver officiellement nos changements, pour chaque commit nous donnons un message de commit, une fois que nous avons fini avec les commits, nous pouvons le pousser à distance pour voir notre changement globalement

ce qui signifie que nous pouvons faire de nombreux commits avant de pousser à distance (nous pouvons voir la liste des commits et les messages) git enregistre chaque commit avec un identifiant de validation qui est un code de 40 chiffres

et j’utilise git push uniquement lorsque je voulais voir mon changement dans la télécommande (là, je vérifierai si mon code a fonctionné avec Jenkins)

Il est plus facile de comprendre l’utilisation des commandes git add et commit si vous imaginez un fichier journal maintenu dans votre référentiel sur Github. Le fichier journal d’un projet type peut ressembler à ceci:

 ---------------- 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 habituellement ma journée par une requête git pull et la termine par une requête git push . Donc, tout ce qui se trouve dans un journal correspond à ce qui se passe entre eux. Au cours de chaque journée, une ou plusieurs tâches logiques que je réalise nécessitent la modification de quelques fichiers. Les fichiers modifiés lors de cette tâche sont répertoriés dans un index.

Chacune de ces sous-tâches (tâche A et tâche B ici) sont des commits individuels. La commande git add ajoute des fichiers à la liste ‘Index of Files Changed’. Ce processus est également appelé staging et, en réalité, enregistre les fichiers modifiés et les modifications effectuées. La commande git commit enregistre / finalise les modifications et la liste d’index correspondante avec un message personnalisé pouvant être utilisé pour référence ultérieure.

Rappelez-vous que vous ne changez que la copie locale de votre référentiel et non celle de Github. Après cela, seules les modifications enregistrées, ainsi que vos fichiers d’index pour chaque validation, seront consignés sur le repository principal (sur Github).

Par exemple, pour obtenir la deuxième entrée dans 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 résumé, git add et git commit vous permettent de décomposer un changement du référentiel principal en sous-modifications logiques systématiques. Comme d’autres réponses et commentaires l’ont fait remarquer, il ya bien sûr beaucoup d’autres utilisations. Cependant, c’est l’un des usages les plus courants et un principe de conduite derrière Git, un système de contrôle de la révision à plusieurs niveaux contrairement à d’autres systèmes populaires comme le Svn.

git commit consiste à valider les fichiers qui sont mis en scène dans le repo local. git push consiste à faire avancer rapidement la twig principale du côté local avec la twig principale distante. Mais la fusion ne sera pas toujours un succès. Si le rejet apparaît, vous devez pull pour que vous puissiez faire une git push réussie.

Eh bien, fondamentalement, git commit place vos modifications dans votre repo local, tandis que git push envoie vos modifications à l’emplacement distant. Git étant un système de contrôle de version dissortingbué, la différence réside dans le fait que la validation commettra des modifications dans votre référentiel local, tandis que la poussée poussera les modifications vers un repository à distance

source Google

http://gitref.org/basic/ ce lien sera très utile aussi

https://git-scm.com/docs/git-commit