¿Cuáles son las diferencias entre "git commit" y "git push"?

En un tutorial de Git que estoy siguiendo, git commitse usa para almacenar los cambios que ha realizado.

¿Para qué se git pushusa entonces?

Básicamente git commit" registra los cambios en el repositorio " mientras que git push" actualiza las referencias remotas junto con los objetos asociados ". Entonces, el primero se usa en conexión con su repositorio local, mientras que el último se usa para interactuar con un repositorio remoto.

Aquí hay una buena foto de Oliver Steele , que explica el modelo git y los comandos:

Lea más sobre git pushy git pullen GitReady.com (el artículo al que me referí primero)

commit : agregar cambios al repositorio local

push : para transferir los últimos commit (s) a un servidor remoto

Bueno, básicamente git commit coloca tus cambios en tu repositorio local, mientras que git push envía tus cambios a la ubicación remota.

git pushse utiliza para agregar confirmaciones que ha realizado en el repositorio local a una remota git pull, y permite a las personas colaborar.

Dado que git es un sistema de control de versiones distribuido, la diferencia es que commit confirmará los cambios en su repositorio local, mientras que push empujará los cambios a un repositorio remoto.

Comprometerse : Instantánea | Conjunto de cambios | History_record | Version | 'Guardar como' de un repositorio. Repositorio de Git = serie (árbol) de confirmaciones .

Repositorio local : repositorio en su computadora.

Repositorio remoto : repositorio en un servidor ( Github ).

git commit: Agregue una nueva confirmación (última confirmación + modificaciones por etapas ) al repositorio local . (Todas las confirmaciones se almacenan en /.git)

git push, git pull: Sincronice el repositorio local con su repositorio remoto asociado . push- aplicar cambios de local a remoto , pull- aplicar cambios de remoto a local .

git commitregistre sus cambios en el repositorio local .

git push Actualice el repositorio remoto con sus cambios locales.

Tres cosas a tener en cuenta:

1) Directorio de trabajo ----- carpeta donde están presentes nuestros archivos de códigos

2) Depósito local ------ Esto está dentro de nuestro sistema. Cuando hacemos el comando COMMIT por primera vez, se crea este repositorio local. en el mismo lugar donde está nuestro directorio de trabajo, se
crea el archivo Checkit (.git).
Después de eso, cuando nos comprometemos, esto almacenará los cambios que realicemos en el archivo del directorio de trabajo en el repositorio local (.git)

3) Repositorio remoto ----- Está situado fuera de nuestro sistema, como en servidores ubicados en cualquier parte del mundo. como github Cuando hacemos el comando PUSH, los códigos de nuestro repositorio local se almacenan en este repositorio remoto

Solo quiero agregar los siguientes puntos:

Yon no puede presionar hasta que se comprometa, ya que usamos git pushpara enviar los compromisos realizados en su sucursal local a un repositorio remoto.

El git pushcomando toma dos argumentos:

Un nombre remoto, por ejemplo, origin un nombre de sucursal, por ejemplo,master

Por ejemplo:

git push  <REMOTENAME> <BRANCHNAME> 
git push  origin       master

Una analogía muy cruda: si comparamos git commitcon guardar un archivo editado, git pushestaríamos copiando ese archivo en otra ubicación.

No saque esta analogía de este contexto: comprometerse y presionar no es como guardar un archivo editado y copiarlo. Dicho esto, debería ser válido por el bien de las comparaciones.

Es más fácil entender el uso de los comandos git addy commitsi imagina que se mantiene un archivo de registro en su repositorio en Github. El archivo de registro de un proyecto típico para mí puede verse así:

---------------- 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

Normalmente comienzo mi día con una git pullsolicitud y termino con una git pushsolicitud. Entonces, todo dentro del registro de un día corresponde a lo que ocurre entre ellos. Durante cada día, hay una o más tareas lógicas que completo que requieren cambiar algunos archivos. Los archivos editados durante esa tarea se enumeran en un índice.

Cada una de estas subtareas (Tarea A y Tarea B aquí) son confirmaciones individuales. El git addcomando agrega archivos a la lista 'Índice de archivos modificados'. Este proceso también se denomina puesta en escena y, en realidad, los registros cambian los archivos y los cambios realizados. El git commitcomando registra / finaliza los cambios y la lista de índice correspondiente junto con un mensaje personalizado que puede usarse para referencia posterior.

Recuerde que todavía solo está cambiando la copia local de su repositorio y no la que está en Github. Después de esto, solo cuando git pushrealice todos estos cambios registrados, junto con sus archivos de índice para cada confirmación, inicie sesión en el repositorio principal (en Github).

Como ejemplo, para obtener la segunda entrada en ese archivo de registro imaginario, habría hecho:

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 pocas palabras, git addy le git commitpermite descomponer un cambio en el repositorio principal en sub-cambios lógicos sistemáticos. Como han señalado otras respuestas y comentarios, por supuesto hay muchos más usos para ellos. Sin embargo, este es uno de los usos más comunes y un principio de conducción detrás de que Git es un sistema de control de revisión de múltiples etapas a diferencia de otros populares como Svn.

git commit no es más que guardar nuestros cambios oficialmente, por cada mensaje de compromiso que enviamos, una vez que hayamos terminado con los compromisos, podemos llevarlo a control remoto para ver nuestro cambio a nivel mundial

lo que significa que podemos hacer numerosos commits antes de pasar a remoto (podemos ver la lista de commits que sucedieron y los mensajes también) git guarda cada commit con commit id, que es un código de 40 dígitos

y uso git push solo cuando quería ver mi cambio en el control remoto (después comprobaré si mi código funcionó en jenkins)

Bueno, básicamente git commit coloca tus cambios en tu repositorio local, mientras que git push envía tus cambios a la ubicación remota. Dado que git es un sistema de control de versiones distribuido, la diferencia es que commit confirmará los cambios en su repositorio local, mientras que push empujará los cambios a un repositorio remoto

fuente de Google

http://gitref.org/basic/ este enlace también será muy útil

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

en términos simples, git commites el paso antes de git pushejecutarlos en ese orden para colocar con éxito su archivo en github.

git commites confirmar los archivos que se organizan en el repositorio local. git pushes avanzar rápidamente fusionando la rama maestra del lado local con la rama maestra remota. Pero la fusión no siempre será exitosa. Si aparece el rechazo, debe pullhacerlo para que pueda tener éxito git push.