Top 10 comandos Git esenciales

Git se ha convertido en el sistema de control de versiones por excelencia. El surgimiento de la popularidad de Git se puede atribuir a su velocidad, agilidad y versatilidad. Ya sea que sea un desarrollador web independiente o un diseñador de software para aplicaciones de nivel empresarial, puede beneficiarse del uso de GIT. Le ayuda a realizar un seguimiento de sus archivos a través de versiones sistemáticas. Git hace que sea más fácil volver a las versiones de código más antiguas o crear nuevas ramas para experimentar en la base de código actual. Además, Git es un sistema de control de versiones distribuidas, lo que significa que no tiene que conectarse siempre a un servidor central para hacer su trabajo.A continuación se muestran los comandos Git esenciales que ayudarán en sus tareas diarias. Los ejemplos simples le darán una comprensión de los comandos, por lo que puede recordar fácilmente la sintaxis cuando necesite usarlos.

1. Git Agregar

El comando git add le permite comenzar a rastrear archivos y carpetas para su repositorio de git y los mueve al área de puesta en escena. Tendrás que usar el comando Git Commit para hacerlos permanentes en tus instantáneas históricas.

Usar el comando es fácil. Puede optar por agregar archivos y carpetas individualmente o usar el operador de Glob de Asterisk (*) de tipo Linux para agregarlos en grupos.

Tomemos el ejemplo a continuación:

Supongamos que, en el caso anterior, ya hemos agregado el readme.TXT. Pero el resto de los archivos no se han agregado.

Verifiquemos el estado:

Estado de $ git
En rama maestro
Su rama está actualizada con 'Origin/Master'.
Archivos sin seguimiento:
(Use 'git add ...' para incluir en lo que se comprometerá)
archivo1.TXT
archivo2.TXT
carpeta1/

Los archivos y las carpetas están en rojo, lo que significa que no se están rastreando. Podemos agregarlos usando:

$ git agregar archivo1.archivo txt2.carpeta txt1/*

Si verificamos el estado ahora:

Estado de $ git
En rama maestro
Su rama está actualizada con 'Origin/Master'.
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
nuevo archivo: archivo1.TXT
nuevo archivo: archivo2.TXT
Nuevo archivo: carpeta1/file3.TXT
Nuevo archivo: carpeta1/archivo4.TXT

El comando git add ha agregado los archivos al área de puesta en escena. Los archivos se mantienen en el área de puesta en escena antes de hacerlos permanentes a través del proceso de confirmación.

2. rama git

En Git, la ramificación es fácil. En otros sistemas de control de versiones, fue una operación costosa. Pero los algoritmos GIT están optimizados para la ramificación. Por lo tanto, puede usar el comando de rama git siempre que desee crear una línea de desarrollo separada sin preocuparse por el rendimiento.

Veamos el siguiente ejemplo.

Estado de $ git
En rama maestro
Su rama está actualizada con 'Origin/Master'.
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
nuevo archivo: archivo1.TXT
nuevo archivo: archivo2.TXT
Nuevo archivo: carpeta1/file3.TXT
Nuevo archivo: carpeta1/archivo4.TXT

Observe que estamos 'en la rama maestro'. Cuando cree un nuevo proyecto, terminará en Branch Master. También puede usar el comando Git Branch -A para averiguar en qué rama se encuentra:

$ git rama -a
* maestro

Lo anterior te dice que solo hay una rama llamada 'maestro' y el asterisco (*) significa que estás en esa rama.

Creemos una nueva rama llamada 'Prueba':

Prueba de sucursal de $ git

Ahora podemos revisar las ramas nuevamente:

$ git rama -a
* maestro
pruebas

Aunque, todavía estamos en la rama 'maestro', también podemos ver la nueva rama de 'prueba' que se creó. La rama de 'prueba' es una réplica de la rama 'maestro'.

3. CAMENTA DE GIT

El comando Git Checkout lo lleva a una rama, para que pueda trabajar en los recursos allí. Puedes pensar en ramas como ríos y corrientes. Con una rama, creas una nueva transmisión. Con el comando de pago, te mueves a esa transmisión.

Compruebemos la rama de 'prueba' del ejemplo anterior:

Pruebas de pago de $ git
Cambiado a la rama 'prueba'

Ahora revisemos el estado y las ramas nuevamente:

Estado de $ git
En la prueba de ramas
Nada para comprometerse, Directorio de trabajo limpio
$ git rama -a
maestro
* Prueba

Puede ver desde el comando de la rama GIT que hemos movido a la rama de prueba.

4. clon git

El comando git clone le permite hacer una copia de cualquier repositorio de git. Tan pronto como clone un repositorio, la nueva carpeta clonada comenzará a realizar un seguimiento de los cambios localmente. Debido a que GIT se distribuye, un clon es un repositorio de Git totalmente autónomo.

Para mostrar cómo funciona la clonación, creemos un nuevo repositorio:

$ mkdir dir1
$ CD Dir1
$ mkdir myproject
$ CD myProject/
$ git init
Repositorio de git vacío inicializado en/dir1/myproject/.git/
$ Touch ReadMe.TXT
$ git commit -m 'inicializar mi repositorio'
[Maestro (Root-Commit) 5A0BD75] Inicializa mi repositorio
1 archivo cambiado, 0 inserciones (+), 0 deleciones (-)
Crear modo 100644 Readme.TXT

En el ejemplo anterior, hemos creado el repositorio de git llamado 'myproject' adentro 'dir1' carpeta. Supongamos que este es nuestro principal repositorio. Ahora queremos hacer una copia y trabajar en otro lugar.

Creemos un directorio llamado 'Dir2' y clone el repositorio 'myProject'. Estamos usando el clon Git para clon 'myProject':

$ mkdir dir2
$ CD Dir2
$ git clone/dir1/myproject/
Clonando en 'myproject' ..
hecho.
$ LS
mi proyecto

El comando Git Clone también funciona con una URL.

$ git clon https: // github.com/prueba/prueba.git

Además, puede cambiar el nombre del clon especificándolo después de la dirección del repositorio de git:

$ git clon https: // github.com/prueba/prueba.Git Mytest

5. Git Commit

El comando git confirm se ejecuta después del comando git add. En nuestro ejemplo de Git Add, habíamos agregado los archivos para el seguimiento, pero no lo habíamos comprometido al repositorio de Git. El seguimiento permanece local hasta que se haga una confirmación. Cuando comete los cambios, se convierten en parte del registro permanente.

A continuación estamos ejecutando el comando git commit -m:

$ git commit -m 'cometer mis archivos y carpetas'
[Maestro 3EF57B3] Ejecución de mis archivos y carpetas
4 archivos cambiados, 0 inserciones (+), 0 deleciones (-)
Crear modo 100644 archivo1.TXT
Crear modo 100644 file2.TXT
Crear modo 100644 carpeta1/archivo3.TXT
Crear modo 100644 carpeta1/file4.TXT

Si no usa la opción -m para poner un comentario, Git abrirá su editor de texto predeterminado y lo solicitará. Los comentarios se consideran una buena práctica de control de versiones. Así que siempre ponte comentarios significativos en tu compromiso.

6. configuración git

El comando de configuración git le permite configurar varias opciones para su repositorio git. Por ejemplo, puede usar el comando git config -global para obtener y configurar a su usuario.Nombre y usuario.correo electrónico.

Así es como puedes establecer los valores:

$ git config -usuario global.Nombre 'Zak H'
$ git config -usuario global.Envíe un correo electrónico a [email protected]

Así es como puede verificar los valores:

$ git config -usuario global.nombre
Zak h
$ git config -usuario global.correo electrónico
[email protected]

7. Git Diff

El comando Git Diff lo ayuda a ver las diferencias entre archivos y carpetas. Si está haciendo cambios en un archivo, es una herramienta útil para evaluar rápidamente los cambios que realizó.

Supongamos que comenzamos nuestro trabajo con un readme.archivo txt con dos líneas. Luego nos deshacemos de la segunda línea y agregamos una tercera línea.

Ahora, si ejecutamos el comando DIFF, mostrará las diferencias entre la versión comprometida y la versión cambiada local en el área de puesta en escena. Así es como se verá:

$ git diff
diff - -git a/readme.txt b/readme.TXT
Índice 9475DDC ... 1804904 100644
--- a/readme.TXT
+++ B/Readme.TXT
@@ -1,2 +1,2 @@
Línea 1: Mi primera línea
-Línea 2: mi segunda línea
+Línea 3: Mi tercera línea

La línea 1 no cambia (blanca), la línea 2 eliminada (roja) y la línea 3 agregada (verde).
Puede usar el comando DIFF para encontrar también diferencias entre compromisos particulares.

8. Git busca

El comando git fetch obtiene los últimos recursos del origen especificado.

Veamos un ejemplo. Supuse que tienes la siguiente condición:

dir1/myproject
dir2/myproject (clonado)

La carpeta 'Dir2/myProject' está clonada de 'Dir1/myProject'. Ahora, si alguien cometió cambios en 'Dir1/myProject', puede obtener esos cambios como este desde el interior 'Dir2/myProject':

$ git fetch origen
Remoto: Contación de objetos: 2, hecho.
remoto: objetos de comprimir: 100% (2/2), hecho.
Remoto: Total 2 (Delta 0), reutilizado 0 (Delta 0)
Desempacar objetos: 100% (2/2), hecho.
De /dir2 /… /dir1 /myproject
5A0BD75 ... 1713734 Master -> Origen/Master

Es importante recordar que el comando git fetch no fusiona los cambios. Para obtener una búsqueda y fusión automática, use el comando git pull. Entonces te preguntarás por qué usar este comando en primer lugar. Puede haber opciones de GIT avanzadas en las que obtenga todos los cambios de su servidor de origen y luego solo aplique cambios selectivamente a ciertos archivos. El comando git fetch te permite lograr esto. Sin embargo, es un tema avanzado que puede encontrar en la documentación de Git Fetch.

9. Git Grep

El comando git grep le permite buscar información para buscar información. Aquí hay un ejemplo de buscar la palabra 'línea' en nuestro repositorio git. La opción -n o -línea -número muestra números de línea donde Git encuentra una coincidencia:

$ git grep -n línea
Readme.txt: 1: línea 1: mi primera línea
Readme.txt: 2: línea 3: mi tercera línea

Puede ejecutar una búsqueda similar de un número de veces que la coincidencia está allí con -c o -opción de count:

Git Grep -C Line
Readme.txt: 2

La razón para usar Git Grep sobre Linux Grep es que Git Grep es más rápido para los repositorios de Git.

10. Git log

El comando de registro git te muestra la historia de confirmación.

Log de $ git
Commit 171373479fc309846ef605fbe650933767afd0fb
Autor: Zak H
Fecha: miércoles 21 de noviembre 20:26:32 2018 -0800
Nuevos archivos agregados
Commit 5A0BD759506D20B2B989873258BF60D003AA3D36
Autor: Zak H
Fecha: miércoles 21 de noviembre 18:48:35 2018 -0800
Inicializar mi repositorio

También puede usar la opción --oneline para ver una versión abreviada. La versión abreviada es más fácil de seguir.

$ git log -enneline
1713734 Archivos nuevos agregados
5A0BD75 Inicializa mi repositorio

11. git fusionar

El comando de fusión git fusiona ramas.

Creemos un nuevo repositorio con 'principal' y luego creemos una rama de 'prueba'.

$ mkdir myproject
$ CD myProject
$ git init
Repository Git de vacío inicializado en/git_essentials/myproject/.git/
$ Touch ReadMe.TXT
$ git add -a
$ git commit -m 'commit inicial'
[Maestro (Root-Commit) B31D4E1] Conjunto inicial
1 archivo cambiado, 0 inserciones (+), 0 deleciones (-)
Crear modo 100644 Readme.TXT
Prueba de sucursal de $ GIT
$ git rama -a
* maestro
prueba
Prueba de pago de $ git
Cambiado a la rama 'prueba'

En la rama de 'prueba', hagamos algunos cambios:

$ touch archivo1.archivo txt2.TXT
$ LS
Archivo1.archivo txt2.Readme de txt.TXT
$ git add -a
$ git commit -m 'agregó dos archivos nuevos'
[Prueba 7e11910] Se agregó dos archivos nuevos
2 archivos cambiados, 0 inserciones (+), 0 deleciones (-)
Crear modo 100644 archivo1.TXT
Crear modo 100644 file2.TXT

Hemos agregado dos archivos a la prueba.

$ git rama -a
maestro
* prueba
$ LS
Archivo1.archivo txt2.Readme de txt.TXT
$ git checkout maestro
Cambio a la rama 'maestro'
$ git rama -a
* maestro
prueba
$ LS
Readme.TXT

Vemos de lo anterior, ese archivo1.txt y file2.TXT existe en la rama 'Test', pero no en 'Master'.

Fusionemos ahora.

Prueba de fusión de $ git
Actualización B31D4E1 ... 7E11910
Avance rápido
Archivo1.txt | 0
Archivo2.txt | 0
2 archivos cambiados, 0 inserciones (+), 0 deleciones (-)
Crear modo 100644 archivo1.TXT
Crear modo 100644 file2.TXT
$ LS
Archivo1.archivo txt2.Readme de txt.TXT
$ git rama -a
* maestro
prueba

Ahora tenemos 'archivo1.txt 'y' file2.txt 'en la rama' maestro 'también.

Nota: Piense en fusionar como una operación de extracción. Tienes que estar en la rama en la que quieres fusionarte. En este caso, se encuentra en la rama 'maestro' tirando de los cambios de la rama de 'prueba'.

12. Git MV

El Git MV es un comando corta para ejecutar los comandos Git Add and Git RM. Se puede usar para cambiar el nombre de los archivos.

Aquí hay un ejemplo:

$ git MV Readme.Readme de txt.Maryland
Estado de $ git
En rama maestro
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
renombrado: Readme.txt -> Readme.Maryland

13. git tirón

El comando Git Pull se parece mucho a la búsqueda de git, excepto que la fusión ocurre automáticamente.

Aquí hay un ejemplo de ejecutar Git Pull Origin como el Git Fetch One (estamos ejecutando una solicitud de extracción del clon para obtener cambios del repositorio Git original):

$ Git Pull Origin
Remoto: Contación de objetos: 3, hecho.
remoto: objetos de comprimir: 100% (2/2), hecho.
Remoto: Total 3 (Delta 0), reutilizado 0 (Delta 0)
Desempaquetando objetos: 100% (3/3), hecho.
De/aprendizaje/git_essentials/myproject
7e11910… E67F932 Master -> Origen/Master
Actualización 7E11910 ... E67F932
Avance rápido
Archivo1.txt | 1 +
Archivo2.txt | 1 +
Archivo3.txt | 1 +
Readme.txt => Readme.MD | 0
4 archivos cambiados, 3 inserciones (+)
Crear modo 100644 archivo3.TXT
renombrar readme.txt => Readme.MD (100%)

Puede ver que los cambios se han descargado del origen y se fusionaron en el clon.

14. Git Push

El comando git push se usa para empujar los cambios a repositorios remotos. Aquí hay un ejemplo de ejecutar el comando push:

$ git push origin maestro
Contando objetos: 2, hecho.
Compresión delta utilizando hasta 4 hilos.
Objetos de comprimir: 100% (2/2), hecho.
Escribir objetos: 100% (2/2), 242 bytes | 0 bytes/s, hecho.
Total 2 (delta 1), reutilizado 0 (Delta 0)
A/aprendizaje/git_essentials/myproject
E67F932 ... 90DC546 Master -> Master

El comando Git Push Origin Master está enviando cambios a la rama 'Maestro' del origen (el repositorio de git que clonó) de la rama 'maestro' del repositorio clonado. Visualmente, el empuje se ve así:

clonado/maestro -> origen/maestro

15. Git Rebase

El comando Git Rebase te ayuda a cambiar la base de las ramas. En una fusión general, sucede algo como esto:

La rama de prueba se ha fusionado en la rama 'maestro' para crear un nuevo commit.

En un Rebase, esto es lo que sucede:

Los cambios de E y F Changelist se recalculan y se enganchan al final de la rama maestra. Rebasing ayuda a simplificar las ramas.

Supongamos que tenemos esta situación en la rama 'Maestro':

$ git log -enneline
7f573d8 Commit C: agregado C.TXT
795DA3C Commit B: agregado B.TXT
0F4ED5B COMISMA A: Se agregó un.TXT

Y una rama de características:

$ git log -enneline
8ED0C4E Conjunto F: Modificado B.TXT
6E12B57 Commit E: modificado un.TXT
795DA3C Commit B: agregado B.TXT
0F4ED5B COMISMA A: Se agregó un.TXT

Si nos rebajamos, obtenemos Git Rebase Master:

función de pago de $ git
Cambiado a la rama 'característica'
$ Git Rebase Master

Primero, rebobinar la cabeza para reproducir su trabajo sobre él ..

Aplicación: Commit E: modificado un.TXT
Aplicación: Commit F: Modificado B.TXT
Luego fusionar 'característica' en 'maestro'.
$ git checkout maestro
Cambio a la rama 'maestro'
función de fusión de $ git
Actualización 7F573D8 ... 9EFA1A3
Avance rápido
a.txt | 1 +
b.txt | 1 +
2 archivos cambiados, 2 inserciones (+)

Ahora, si vas a la rama 'maestro' y de 'característica', verás los mismos registros:

$ git log -enneline
9EFA1A3 Commit F: Modificado B.TXT
8710174 Commit E: modificado un.TXT
7f573d8 Commit C: agregado C.TXT
795DA3C Commit B: agregado B.TXT
0F4ED5B COMISMA A: Se agregó un.TXT

Rebasing los ha juntado.

NOTA: Nunca use la reubicación en repositorios públicos, ya que los desarrolladores se encontrarán con problemas de fusión importantes.

git remoto

El comando Remote Git le permite establecer un servidor remoto para su repositorio. En una situación de clonación, el repositorio de la fuente se convierte automáticamente en el control remoto.

Por ejemplo:

$ PWD
/Aprendizaje/git_essentials/test
$ git remoto -v
origen/aprendizaje/git_essentials/myproject (Fetch)
origen/aprendizaje/git_essentials/myproject (push)

Lo anterior muestra que el servidor remoto para 'prueba' es otra carpeta llamada 'myProject'. La razón es que 'prueba' fue clonada para mi proyecto.

Pero el servidor remoto no necesita ser local. Puedes tener algo como esto con una URL:

$ git remoto -v
origen https: // github.com/zakh/myproject (buscar)
origen https: // github.com/zakh/myproject (empuje)

Puede configurar un repositorio remoto Git utilizando el comando git remoto Agregar:

$ git remoto agregar origen https: // github.com/zakh/myproject

Esto conectará su repositorio con el origen para que pueda buscar y empujar.

17. reinicio de git

El reinicio de git le permite desico de archivos agregados.

Digamos que agregó la prueba del archivo '.txt 'a su repositorio:

Prueba de $ touch.TXT
$ git add -a
Estado de $ git
En rama maestro
Su rama está actualizada con 'Origin/Master'.
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
Nuevo archivo: prueba.TXT

Sin embargo, decides que no quieres rastrear 'prueba.txt 'más. Puede usar el comando git rein head para desico el archivo:

Prueba de cabeza de reinicio de $ git.TXT

Si verifica el estado, el archivo nuevamente no se vean:

Estado de $ git
En rama maestro
Su rama está actualizada con 'Origin/Master'.
Archivos sin seguimiento:
(Use 'git add ...' para incluir en lo que se comprometerá)
prueba.TXT

La prueba del archivo '.Txt 'ya no se rastrea.

18. git revertir

El comando git revert le permite revertir cambios utilizando el número de hash de confirmación.

$ echo 'prueba 1' >> myfile.TXT
$ git add -a
$ git commit -m 'se agregó cambio 1'
[Maestro 78A8277] Se agregó un cambio 1
2 archivos cambiados, 1 inserción (+)
Crear modo 100644 myfile.TXT
Prueba de creación del modo 100644.TXT
$ Cat MyFile.TXT
Prueba 1
$ echo 'prueba 2' >> myfile.TXT
$ git add -a
$ git commit -m 'agregó cambio 2'
[Maestro A976E9C] Se agregó el cambio 2
1 archivo cambiado, 1 inserción (+)
$ Cat MyFile.TXT
Prueba 1
Prueba 2
$ git log -enneline
A976E9C Cambio agregado 2
78A8277 Cambio agregado 1
90DC546 agregó un archivo
E67F932 agregó nuevos archivos
7e11910 agregó dos archivos nuevos
B31D4E1 Commit inicial

Creamos un 'myfile.txt 'y cometió dos cambios, por lo que el archivo tiene las líneas' Prueba 1 'y' Prueba 2 '. Pero decidimos que no queremos el segundo compromiso. Así que encontramos el confirmación de hash (A976E9C) para ello. Podemos usar el git revert para deshacerse de la confirmación:

$ git revert a976e9c
[Maestro 4F270E7] Revertir 'Cambio agregado 2'
1 archivo cambiado, 1 deleción (-)
$ git log -enneline
4F270E7 Revertir 'Cambio agregado 2'
A976E9C Cambio agregado 2
78A8277 Cambio agregado 1
90DC546 agregó un archivo
E67F932 agregó nuevos archivos
7e11910 agregó dos archivos nuevos
B31D4E1 Commit inicial
$ Cat MyFile.TXT
Prueba 1

Vemos que se creó un nuevo conteo de confirmación que volvió al confirmación de la línea 'Prueba 2'. El archivo solo tiene la línea 'Prueba 1' ahora.

19. git rm

El comando git rm establece archivos para eliminar futuras eliminaciones. Pone los archivos que se eliminan en el área de puesta en escena.

Prueba de $ git rm.TXT
prueba de RM.TXT'
Estado de $ git
En rama maestro
Su rama está por delante de 'Origin/Master' por 3 Compromisos.
(Use 'Git Push' para publicar sus confirmaciones locales)
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
Eliminado: prueba.TXT

Tienes que cometer los cambios para que el eliminación entre en vigencia.

20. Git Stash

El comando git stash le permite abandonar temporalmente el trabajo que aún no está listo para cometer.
Supongamos que está trabajando en un repositorio con los siguientes archivos:

$ LS
John.Txt Mary.TXT
Desea cambiar estos archivos para estar más basados ​​en proyectos. Entonces comienzas con:
$ git MV John.Txt ProjectFile1.TXT
$ LS
María.Txt ProjectFile1.TXT
Estado de $ git
En rama maestro
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
renombrado: John.txt -> ProjectFile1.TXT

En medio del cambio de nombre y actualización de John.Txt 'a' ProjectFile1.txt ', recibe una solicitud para cambiar algo en el proyecto. Pero no está listo para enviar 'ProjectFile1.TXT'. Entonces lo esconde.

$ git stash

Directorio de trabajo guardado e índice Estado WIP en el maestro: f0b5a01 init John y Mary

Head ahora está en f0b5a01 init John y Mary

$ LS
John.Txt Mary.TXT

Su entorno de trabajo local ha vuelto a donde estaba antes de hacer sus cambios basados ​​en proyectos. Después, atendiendo a la interrupción, en lugar de volver a 'John.txt ', decides trabajar en' Mary.archivo de txt 'ahora:

$ git mv mary.Txt ProjectFile2.TXT
Estado de $ git
En rama maestro
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
renombrado: Mary.txt -> ProjectFile2.TXT
$ LS
John.Txt ProjectFile2.TXT

Te interrumpen de nuevo y esconde su nuevo trabajo en 'Mary.TXT':

$ git stash
Directorio de trabajo guardado e índice Estado WIP en el maestro: f0b5a01 init John y Mary
Head ahora está en f0b5a01 init John y Mary
$ LS
John.Txt Mary.TXT

Una vez realizado el trabajo de interrupción, verifica la lista de alojamiento:

Lista de stash de $ git
stash@0: Wip on Master: F0B5A01 Init John y Mary
stash@1: Wip on Master: F0B5A01 Init John y Mary

Tienes dos trabajos en progreso (WIP) en el alijo. FIRS TIEME TE PASTA EL STASH, obtienes la última 'María.Cambios de txt ':

$ git stash pop
Quitando a Mary.TXT
En rama maestro
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
Nuevo archivo: ProjectFile2.TXT
Cambios no organizados para Commit:
(Use 'git add/rm ...' para actualizar lo que se comprometerá)
(Use 'Git Checkout - ...' para descartar cambios en el directorio de trabajo)
Eliminado: Mary.TXT
Refs/stash@0 (9B77A6B75E4E414FB64DE341668C812D3D35150C)

La segunda vez que colocas el alijo, obtienes el 'John.Cambios relacionados con txt ':

$ git stash pop
Quitando a John.TXT
En rama maestro
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
Nuevo archivo: ProjectFile1.TXT
Nuevo archivo: ProjectFile2.TXT
Cambios no organizados para Commit:
(Use 'git add/rm ...' para actualizar lo que se comprometerá)
(Use 'Git Checkout - ...' para descartar cambios en el directorio de trabajo)
Eliminado: John.TXT
Eliminado: Mary.TXT
Refs/stash@0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ LS
ProjectFile1.Txt ProjectFile2.TXT

Y tienes tu trabajo de trabajo en progreso1.txt 'y' ProjectFile2.Txt 'Volver.

Entonces, el comando git stash te ayuda a guardar tu trabajo para que puedas volver a él más tarde.

21. estado de git

El comando Git Status muestra la diferencia entre los archivos actuales y la confirmación de la cabeza.

Aquí hay un ejemplo:

Estado de $ git
En rama maestro
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
renombrado: archivo2.txt -> archivo3.TXT
Cambios no organizados para Commit:
(Use 'git add ...' para actualizar lo que se comprometerá)
(Use 'Git Checkout - ...' para descartar cambios en el directorio de trabajo)
modificado: archivo1.TXT

Está mostrando que 'file2.TXT 'se renombra a' Archivo3.txt 'que está listo para la confirmación, pero las modificaciones en' archivo1.txt 'no está en el área de puesta en escena todavía.

Entonces, agregamos todo:

$ git add -a

Ahora, cuando verificamos el estado:

Estado de $ git
En rama maestro
Cambios a ser cometidos:
(Use 'git reiniciar la cabeza ...' para desico)
modificado: archivo1.TXT
renombrado: archivo2.txt -> archivo3.TXT

Vemos que todos los cambios están listos para cometer.

22. etiqueta git

El comando de etiqueta git te ayuda a crear etiquetas para tus puntos históricos importantes. Generalmente se usa para configurar los números de versión.

El comando de etiqueta git le mostrará las etiquetas actuales disponibles:

Etiqueta de $ git
V1.0
V2.0

Puede etiquetar con la etiqueta Git de formato de comando:

$ git etiqueta v3.0

Para ver qué hay en la etiqueta, puede usar el comando git show:

$ git show v1.0
Commit 61E9E8AA1B98B2A657303E6822B291D2374314B5
Autor: Zak H
Fecha: Jue 22 de noviembre 01:06:42 2018 -0800
Primer compromiso
diff - -git a/1.txt b/1.TXT
nuevo modo de archivo 100644
Índice 0000000 ... E69DE29

También puede etiquetar usando un hash de confirmación y la etiqueta Git de formato de comando:

$ git log -enneline
374Efe9 Archivo modificado
A621765 Agregar
6D6ED84 Segundo confirmación
61E9E8A Primer comisión
$ git etiqueta v4.0 A621765
$ git show v4.0
Commit A6217650A2C7B2531ECB9C173BA94BD4B3BA7ABD
Autor: Zak H
Fecha: Jue 22 de noviembre 01:15:55 2018 -0800
Agregar
diff - -git a/1.txt b/1.TXT
Índice E69DE29 ... 587BE6B 100644
--- A/1.TXT
+++ b/1.TXT
@@ -0,0 +1 @@

En conclusión

Para cualquier comando, puede usar git -h para obtener más información.

Estudio adicional

• https: // git-scm.com/documentos