22 comandos esenciales de Git

Git se ha convertido en el sistema de control de versiones por excelencia. El aumento de la popularidad de Git se puede atribuir a su velocidad, agilidad y versatilidad. Ya sea que sea un desarrollador web autónomo 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 mediante el control de versiones sistemático. Git facilita la reversión a versiones anteriores del código o la creación de nuevas ramas para experimentar con el código base actual. Además, Git es un sistema de control de versiones distribuido, lo que significa que no tiene que conectarse siempre a un servidor central para realizar su trabajo.A continuación se muestran los comandos esenciales de Git que lo ayudarán en sus tareas diarias. Los ejemplos simples le darán una comprensión de los comandos, para que pueda 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 Git y los mueve al área de preparación. Tendrá que usar el comando git commit para hacerlos permanentes en sus instantáneas históricas.

Usar el comando es fácil. Puede elegir agregar archivos y carpetas individualmente o usar el operador glob de tipo asterisco (*) de Linux para agregarlos en grupos.

Tomemos el siguiente ejemplo:

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

Comprobemos el estado:

estado de $ git
En el maestro de la sucursal
Tu sucursal está actualizada con 'origen / maestro'.
Archivos sin seguimiento:
(use 'git add ... 'para incluir en lo que se va a comprometer)
archivo1.TXT
archivo2.TXT
carpeta1 /

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

$ git agregar archivo1.txt file2.txt carpeta1 / *

Si comprobamos el estado ahora:

estado de $ git
En el maestro de la sucursal
Tu sucursal está actualizada con 'origen / maestro'.
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
nuevo archivo: archivo1.TXT
nuevo archivo: file2.TXT
nuevo archivo: carpeta1 / archivo3.TXT
nuevo archivo: carpeta1 / archivo4.TXT

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

2. rama de git

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

Veamos el siguiente ejemplo.

Observe que estamos 'en el maestro de sucursal'. Cuando creas un nuevo proyecto, terminarás en branch master. También puede usar el comando git branch -a para averiguar en qué rama se encuentra:

$ git branch -a
* Maestro

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

Creemos una nueva rama llamada 'prueba':

$ git branch testing

Ahora podemos volver a comprobar las ramas:

$ git branch -a
* Maestro
pruebas

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

3. git checkout

El comando git checkout lo lleva a una sucursal, para que pueda trabajar en los recursos allí. Puedes pensar en las ramas como ríos y arroyos. Con una rama, creas una nueva secuencia. Con el comando de pago, te mueves a esa secuencia.

Veamos la rama 'prueba' del ejemplo anterior:

$ git checkout testing
Cambiado a la rama de 'prueba'

Ahora revisemos el estado y las ramas nuevamente:

estado de $ git
En pruebas de sucursales
nada que confirmar, directorio de trabajo limpio
$ git branch -a
Maestro
* prueba

Puede ver en el comando git branch -a que nos hemos movido a la rama de prueba.

4. clon de 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 completamente 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 Léame.TXT
$ git commit -m 'Inicializar mi repositorio'
[master (root-commit) 5a0bd75] Inicializar mi repositorio
1 archivo modificado, 0 inserciones (+), 0 eliminaciones (-)
modo de creación 100644 Léame.TXT

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

Creemos un directorio llamado 'dir2' y clonemos el repositorio 'myproject'. Estamos usando el clon de git

para clonar '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 / test / test.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 / test / test.git mytest

5. git commit

El comando git commit se ejecuta después del comando git add. En nuestro ejemplo de git add, habíamos agregado los archivos para el seguimiento, pero no los habíamos comprometido en el repositorio de Git. El seguimiento permanece local hasta que se realiza una confirmación. Cuando confirma los cambios, pasan a formar parte del registro permanente.

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

$ git commit -m 'Confirmando mis archivos y carpetas'
[master 3ef57b3] Confirmando mis archivos y carpetas
4 archivos modificados, 0 inserciones (+), 0 eliminaciones (-)
modo de creación 100644 file1.TXT
modo de creación 100644 file2.TXT
modo de creación 100644 carpeta1 / archivo3.TXT
modo de creación 100644 carpeta1 / archivo4.TXT

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

6. git config

El comando git config le permite configurar varias opciones para su repositorio git. Por ejemplo, puede usar git config -global comando para obtener y configurar su usuario.nombre y usuario.Email.

Así es como puede establecer los valores:

$ git config - usuario global.nombre 'Zak H'
$ git config - usuario global.correo electrónico zakh @ ejemplo.com

Así es como puede verificar los valores:

$ git config - usuario global.nombre
Zak H
$ git config - usuario global.Email
zakh @ ejemplo.com

7. git diff

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

Supongamos que comenzamos nuestro trabajo con un archivo Léame.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 local modificada en el área de ensayo. Así es como se verá:

$ git diff
diff --git a / Léame.txt b / Léame.TXT
índice 9475ddc… 1804904 100644
--- a / Léame.TXT
+++ b / Léame.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 ha cambiado (blanca), la línea 2 se eliminó (roja) y la línea 3 se agregó (verde).
Puede usar el comando diff para encontrar también diferencias entre confirmaciones particulares.

8. git fetch

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

Veamos un ejemplo. Se supone que tiene la siguiente condición:

dir1 / myproject
dir2 / myproject (clonado)

La carpeta 'dir2 / myproject' se clona de 'dir1 / myproject'. Ahora, si alguien realizó cambios en 'dir1 / myproject', puede obtener esos cambios como este desde dentro de 'dir2 / myproject':

$ git buscar origen
remoto: Contando objetos: 2, hecho.
remoto: Comprimir objetos: 100% (2/2), hecho.
remoto: Total 2 (delta 0), reutilizado 0 (delta 0)
Desembalaje de objetos: 100% (2/2), hecho.
Desde / dir2 /… / dir1 / myproject
5a0bd75… 1713734 maestro -> origen / maestro

Es importante recordar que el comando git fetch no fusiona los cambios. Para obtener y fusionar automáticamente, use el comando git pull. Entonces quizás se pregunte por qué usar este comando en primer lugar. Puede haber opciones avanzadas de Git en las que obtiene todos los cambios de su servidor de origen y luego solo aplica los cambios de forma selectiva 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 en su árbol Git. Aquí hay un ejemplo de búsqueda de la palabra 'Línea' en nuestro repositorio de git. La opción -no --line-number muestra los números de línea donde Git encuentra una coincidencia:

$ git grep -n Línea
Léame.txt: 1: Línea 1: Mi primera línea
Léame.txt: 2: Línea 3: Mi TERCERA línea

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

git grep -c Línea
Léame.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. registro de git

El comando git log te muestra el historial de confirmaciones.

$ git log
cometer 171373479fc309846ef605fbe650933767afd0fb
Autor: Zak H
Fecha: Wed Nov 21 20:26:32 2018-0800
Nuevos archivos agregados
cometer 5a0bd759506d20b2b989873258bf60d003aa3d36
Autor: Zak H
Fecha: Wed Nov 21 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 --en línea
1713734 Nuevos archivos agregados
5a0bd75 Inicializar mi repositorio

11. git merge

El comando git merge fusiona ramas.

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

$ mkdir myproject
$ cd myproject
$ git init
Repositorio de Git vacío inicializado en / git_essentials / myproject /.git /
$ touch Léame.TXT
$ git add -A
$ git commit -m 'Confirmación inicial'
[master (root-commit) b31d4e1] Confirmación inicial
1 archivo modificado, 0 inserciones (+), 0 eliminaciones (-)
modo de creación 100644 Léame.TXT
prueba de rama $ git
$ git branch -a
* Maestro
prueba
$ git prueba de pago
Cambiado a la 'prueba' de la rama

En la rama 'prueba', hagamos algunos cambios:

$ touch File1.txt Archivo2.TXT
$ Ls
Archivo1.txt Archivo2.txt Léame.TXT
$ git add -A
$ git commit -m 'Se agregaron dos archivos nuevos'
[prueba 7e11910] Se agregaron dos archivos nuevos
2 archivos modificados, 0 inserciones (+), 0 eliminaciones (-)
modo de creación 100644 Archivo1.TXT
modo de creación 100644 Archivo2.TXT

Hemos agregado dos archivos a la prueba.

$ git branch -a
Maestro
* prueba
$ ls
Archivo1.txt Archivo2.txt Léame.TXT
$ git checkout master
Cambiado a la rama 'maestra'
$ git branch -a
* Maestro
prueba
$ ls
Léame.TXT

Vemos de lo anterior, que File1.txt y File2.txt existe en la rama 'prueba', pero no en 'maestro'.

Vamos a fusionarnos ahora.

prueba de fusión de $ git
Actualizando b31d4e1… 7e11910
Avance rápido
Archivo1.txt | 0
Archivo2.txt | 0
2 archivos modificados, 0 inserciones (+), 0 eliminaciones (-)
modo de creación 100644 Archivo1.TXT
modo de creación 100644 Archivo2.TXT
$ ls
Archivo1.txt Archivo2.txt Léame.TXT
$ git branch -a
* Maestro
prueba

Ahora tenemos 'Archivo1.txt 'y' File2.txt 'en la rama' maestra 'también.

Nota: Piense en la fusión como una operación de extracción. Tienes que estar en la rama en la que quieres fusionarte. En este caso, estás en la rama 'maestra' extrayendo los cambios de la rama 'prueba'.

12. git mv

El git mv es un comando de atajo para ejecutar los comandos git add y git rm. Se puede utilizar para cambiar el nombre de los archivos.

Aquí hay un ejemplo:

Léame de $ git mv.txt Léame.Maryland
estado de $ git
En el maestro de la sucursal
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
renombrado: ReadMe.txt -> Léame.Maryland

13. git pull

El comando git pull es muy parecido al git fetch, excepto que la fusión ocurre automáticamente.

Aquí hay un ejemplo de ejecución de git pull origin como el git fetch one (estamos ejecutando una solicitud de extracción desde el clon para obtener cambios del repositorio de Git original):

$ git pull origin
remoto: Contando objetos: 3, hecho.
remoto: Comprimir objetos: 100% (2/2), hecho.
remoto: Total 3 (delta 0), reutilizado 0 (delta 0)
Desembalaje de objetos: 100% (3/3), hecho.
De / LearnGIT / git_essentials / myproject
7e11910… e67f932 maestro -> origen / maestro
Actualizando 7e11910… e67f932
Avance rápido
Archivo1.txt | 1 +
Archivo2.txt | 1 +
Archivo3.txt | 1 +
Léame.txt => Léame.md | 0
4 archivos cambiados, 3 inserciones (+)
modo de creación 100644 File3.TXT
renombrar Léame.txt => Léame.md (100%)

Puede ver que los cambios se descargaron desde el origen y se fusionaron en el clon.

14. git push

El comando git push se usa para enviar cambios a repositorios remotos. A continuación, se muestra un ejemplo de ejecución del comando push:

$ git push origin master
Contando objetos: 2, hecho.
Compresión delta usando hasta 4 subprocesos.
Comprimir objetos: 100% (2/2), hecho.
Objetos de escritura: 100% (2/2), 242 bytes | 0 bytes / s, hecho.
Total 2 (delta 1), reutilizado 0 (delta 0)
Para / LearnGIT / git_essentials / myproject
e67f932… 90dc546 maestro -> maestro

El comando git push origin master envía cambios a la rama 'maestra' del origen (el repositorio Git que clonaste) desde la rama 'maestra' 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 con la rama 'maestra' para crear una nueva confirmación.

En una rebase, esto es lo que sucede:

Los cambios de la lista de cambios E y F se recalculan y se bloquean al final de la rama maestra. Rebasar ayuda a simplificar las ramas.

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

$ git log --en línea
7f573d8 Confirmación C: agregado c.TXT
795da3c Compromiso B: agregado b.TXT
0f4ed5b Commit A: agregó un.TXT

Y una rama de funciones:

$ git log --en línea
8ed0c4e Confirmación F: modificado b.TXT
6e12b57 Commit E: modificado a.TXT
795da3c Compromiso B: agregado b.TXT
0f4ed5b Commit A: agregó un.TXT

Si rebase, obtenemos git rebase master:

$ git función de pago
Cambiado a la 'función' de la rama
$ git rebase maestro

Primero, rebobina la cabeza para reproducir tu trabajo encima ..

Aplicando: Compromiso E: modificado a.TXT
Aplicando: Compromiso F: modificado b.TXT
Luego fusiona 'característica' en 'maestro'.
$ git checkout master
Cambiado a la rama 'maestra'
función de fusión de $ git
Actualizando 7f573d8… 9efa1a3
Avance rápido
a.txt | 1 +
B.txt | 1 +
2 archivos cambiados, 2 inserciones (+)

Ahora, si va tanto a la rama 'maestra' como a la 'característica', verá los mismos registros:

$ git log --en línea
9efa1a3 Commit F: modificado b.TXT
8710174 Compromiso E: modificado a.TXT
7f573d8 Confirmación C: agregado c.TXT
795da3c Compromiso B: agregado b.TXT
0f4ed5b Commit A: agregó un.TXT

Rebasar los ha aplastado juntos.

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

dieciséis. git remoto

El comando git remote le permite configurar un servidor remoto para su repositorio. En una situación de clonación, el repositorio de origen se convierte automáticamente en el.

Por ejemplo:

$ pwd
/ LearnGIT / git_essentials / prueba
$ git remoto -v
origen / LearnGIT / git_essentials / myproject (buscar)
origen / LearnGIT / git_essentials / myproject (empujar)

Lo anterior muestra que el servidor remoto para 'prueba' es otra carpeta llamada 'myproject'. La razón es que se clonó 'prueba' para mi proyecto.

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

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

Puede configurar un repositorio remoto de git usando el comando git remote add :

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

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

17. git restablecer

El reinicio de git le permite eliminar la etapa de archivos agregados.

Digamos que agregaste el archivo 'prueba.txt 'a su repositorio:

$ prueba táctil.TXT
$ git add -A
estado de $ git
En el maestro de la sucursal
Tu sucursal está actualizada con 'origen / maestro'.
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
nuevo archivo: prueba.TXT

Sin embargo, decide que no desea realizar un seguimiento de la 'prueba.txt 'más. Puedes usar el git reset Head comando para desmontar el archivo:

$ git reset prueba HEAD.TXT

Si verifica el estado, el archivo se vuelve a anular el seguimiento:

estado de $ git
En el maestro de la sucursal
Tu sucursal está actualizada con 'origen / maestro'.
Archivos sin seguimiento:
(use 'git add ... 'para incluir en lo que se va a comprometer)
prueba.TXT

El archivo 'prueba.txt 'ya no se rastrea.

18. git revert

El comando git revert te permite revertir los cambios usando el número de hash de confirmación.

$ echo 'Prueba 1' >> MyFile.TXT
$ git add -A
$ git commit -m 'Cambio agregado 1'
[master 78a8277] Cambio añadido 1
2 archivos modificados, 1 inserción (+)
modo de creación 100644 MyFile.TXT
crear modo 100644 prueba.TXT
$ cat MyFile.TXT
Prueba 1
$ echo 'Prueba 2' >> MyFile.TXT
$ git add -A
$ git commit -m 'Cambio agregado 2'
[master a976e9c] Cambio añadido 2
1 archivo modificado, 1 inserción (+)
$ cat MyFile.TXT
Prueba 1
Prueba 2
$ git log --en línea
a976e9c Añadido Cambio 2
78a8277 Añadido Cambio 1
90dc546 Se agregó un archivo
e67f932 Nuevos archivos agregados
7e11910 Se agregaron dos archivos nuevos
b31d4e1 Confirmación inicial

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

$ git revert a976e9c
[master 4f270e7] Revertir 'Cambio añadido 2'
1 archivo modificado, 1 eliminación (-)
$ git log --en línea
4f270e7 Revertir 'Cambio agregado 2'
a976e9c Añadido Cambio 2
78a8277 Añadido Cambio 1
90dc546 Se agregó un archivo
e67f932 Nuevos archivos agregados
7e11910 Se agregaron dos archivos nuevos
b31d4e1 Confirmación inicial
$ cat MyFile.TXT
Prueba 1

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

19. git rm

El comando git rm configura archivos para futuras eliminaciones. Coloca los archivos que se eliminarán en el área de preparación.

prueba $ git rm.TXT
prueba rm.TXT'
estado de $ git
En el maestro de la sucursal
Su rama está por delante de 'origen / maestro' por 3 confirmaciones.
(use 'git push' para publicar sus confirmaciones locales)
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
eliminado: prueba.TXT

Tienes que confirmar los cambios para que la eliminación surta efecto.

20. git alijo

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

$ ls
John.txt María.TXT
Quieres cambiar estos archivos para que estén más basados en proyectos. Entonces empiezas con:
$ git mv John.txt ProjectFile1.TXT
$ ls
María.txt ProjectFile1.TXT
estado de $ git
En el maestro de la sucursal
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
renombrado: John.txt -> ProjectFile1.TXT

En medio de cambiar el nombre y actualizar 'John.txt 'a' ProjectFile1.txt ', recibe una solicitud para cambiar algo en el proyecto. Pero no está listo para enviar 'ProjectFile1.TXT'. Así que lo escondes.

$ git alijo

WIP de estado de índice y directorio de trabajo guardado en el maestro: f0b5a01 Init John and Mary

HEAD ahora está en f0b5a01 Init John and Mary

$ ls
John.txt María.TXT

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

$ git mv María.txt ProjectFile2.TXT
estado de $ git
En el maestro de la sucursal
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
renombrado: Mary.txt -> ProjectFile2.TXT
$ ls
John.txt ProjectFile2.TXT

Te interrumpen de nuevo y guardas tu nuevo trabajo en 'Mary.TXT':

$ git alijo
WIP de estado de índice y directorio de trabajo guardado en el maestro: f0b5a01 Init John and Mary
HEAD ahora está en f0b5a01 Init John and Mary
$ ls
John.txt María.TXT

Una vez finalizado el trabajo de interrupción, verifica la lista de alijo:

$ git lista de alijo
stash @ 0: WIP en el maestro: f0b5a01 Init John and Mary
stash @ 1: WIP en el maestro: f0b5a01 Init John and Mary

Tienes dos trabajos en progreso (WIP) en el alijo. La primera vez que haces estallar el alijo, obtienes la última 'Mary.txt 'cambios:

$ git stash pop
Sacando a Mary.TXT
En el maestro de la sucursal
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
nuevo archivo: ProjectFile2.TXT
Cambios no preparados para confirmar:
(use 'git add / rm ... 'para actualizar lo que se comprometerá)
(use 'git checkout -- ... 'para descartar cambios en el directorio de trabajo)
eliminado: María.TXT
Se eliminó refs / stash @ 0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

La segunda vez que sacas el alijo, obtienes el 'John.txt 'cambios relacionados:

$ git stash pop
Eliminando a John.TXT
En el maestro de la sucursal
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
nuevo archivo: ProjectFile1.TXT
nuevo archivo: ProjectFile2.TXT
Cambios no preparados para confirmar:
(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: María.TXT
Descartó refs / stash @ 0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ ls
ProjectFile1.txt ProjectFile2.TXT

Y tiene su trabajo en progreso 'ProjectFile1.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 HEAD.

Aquí hay un ejemplo:

estado de $ git
En el maestro de la sucursal
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
renombrado: File2.txt -> Archivo3.TXT
Cambios no preparados para confirmar:
(use 'git add ... 'para actualizar lo que se comprometerá)
(use 'git checkout -- ... 'para descartar cambios en el directorio de trabajo)
modificado: File1.TXT

Está mostrando que 'File2.txt 'se renombra a' File3.txt 'que está listo para confirmar, pero las modificaciones en' Archivo1.txt 'aún no está en el área de preparación.

Entonces, agregamos todo:

$ git add -A

Ahora, cuando comprobamos el estado:

estado de $ git
En el maestro de la sucursal
Cambios a comprometer:
(use 'git reset HEAD ... 'para quitar el escenario)
modificado: File1.TXT
renombrado: File2.txt -> Archivo3.TXT

Vemos que todos los cambios están listos para ser confirmados.

22. etiqueta git

El comando git tag le ayuda a crear etiquetas para sus puntos históricos importantes. Generalmente se usa para configurar números de versión.

El comando git tag le mostrará las etiquetas disponibles actualmente:

$ git etiqueta
v1.0
v2.0

Puede etiquetar con el formato de comando git tag :

$ git etiqueta v3.0

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

$ git show v1.0
cometer 61e9e8aa1b98b2a657303e6822b291d2374314b5
Autor: Zak H
Fecha: Jue 22 Nov 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 el formato de comando git tag :

$ git log --en línea
374efe9 Archivo modificado
a621765 Agregar
6d6ed84 Segunda confirmación
61e9e8a Primera confirmación
$ git etiqueta v4.0 a621765
$ git show v4.0
cometer a6217650a2c7b2531ecb9c173ba94bd4b3ba7abd
Autor: Zak H
Fecha: Jue 22 Nov 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 / docs