Tutorial de Git para principiantes

El desarrollo de software es un trabajo colaborativo. Como ingeniero de software, necesita compartir su trabajo con otros. Pero compartir código y colaborar puede resultar complicado. Es difícil realizar un seguimiento de los diversos cambios que ocurren durante el ciclo de vida de un software. Por lo tanto, los equipos de desarrollo confían en las herramientas de control de versiones para ayudar con el proceso de colaboración del software. Git es una de las herramientas de control de versiones más destacadas de la industria del software.

Consejo: En este tutorial, aprenderá a utilizar los fundamentos de Git. Cada sección termina con algunas preguntas. Puede leer las preguntas antes de comenzar a leer la sección. Esto le ayudará a comprender y prestar atención a los puntos importantes.

Diviértete aprendiendo Git!

Git: una breve descripción

Git es un sistema de control de versiones distribuido. Realiza un seguimiento de cualquier cambio que realice en sus archivos y carpetas. Hace que sea más fácil guardar su trabajo en progreso. Si hay un problema, puede verificar fácilmente una versión anterior del archivo o carpeta. Si es necesario, incluso puede revertir todo su código base a una versión anterior.

El desarrollo de Git comenzó en 2005. El grupo de kernel de Linux utilizado para mantener su código en BitKeeper, un sistema de control de versiones distribuido propietario. Sin embargo, BitKeeper retiró su uso gratuito del producto. Entonces Linus Torvalds, el creador y desarrollador principal de Linux, diseñó un nuevo sistema de control de versiones distribuido de código abierto que cumpliría los requisitos de la comunidad de desarrollo de Linux. Y nació Git.

Como sistema de control de versiones distribuido, Git no requiere una autoridad centralizada para realizar un seguimiento del código. Los controles de versiones centralizados más antiguos como CVS, SVN o Perforce requieren servidores centrales para mantener el historial de cambios. Git puede realizar un seguimiento de todos los cambios a nivel local y trabajar de igual a igual. Por eso es más versátil que los sistemas centralizados.

Preguntas:

• ¿Por qué deberías usar Git??
• ¿Cuál es el beneficio del control de versiones distribuido??

Instalación de Git

Para los sistemas Linux, la instalación de Git es fácil. Si está usando una distribución basada en Debian como Ubuntu, puede usar apt install:

$ sudo apt install git-all

Para Fedora, RHEL o CentOS, puede usar:

$ sudo dnf instalar git-all

Puede verificar si se ha instalado Git, usando el siguiente comando:

$ git --version

Debería mostrarte la versión de Git que instalaste, por ejemplo:

git versión 2.17.0

Una vez que haya instalado Git, es hora de configurar su nombre de usuario y correo electrónico:

$ git config - usuario global.nombre "yourusername"
$ git config - usuario global.correo electrónico "[correo electrónico protegido]"

Puede verificar si las configuraciones se han establecido correctamente usando el siguiente comando:

$ git config --list
usuario.name = yourusername
usuario.email = yourusername @ example.com

Consejo: Es importante configurar el usuario.nombre y usuario.correo electrónico porque estas configuraciones se utilizan para realizar un seguimiento de sus cambios.

Preguntas

• ¿Cuál es el comando para instalar Git en su sistema Linux??
• ¿Por qué debería configurar el usuario.nombre y usuario.configuración de correo electrónico? ¿Cómo los configuras??

Entender Git conceptualmente

Para usar Git, primero debe comprender estos cuatro conceptos:

• Directorio de trabajo
• Área de ensayo
• Repositorio
• Repositorio remoto

El directorio de trabajo, el área de preparación y el repositorio son locales para su máquina. El repositorio remoto puede ser cualquier otra computadora o servidor. Pensemos en estos conceptos como cuatro cajas que pueden contener papeles estándar A1.

Suponga que está escribiendo un documento a mano en un papel A1 en su escritorio. Guarde este documento en la caja del directorio de trabajo. En una determinada etapa de su trabajo, decide que está listo para conservar una copia del trabajo que ya ha realizado. Así que haces una fotocopia de tu trabajo actual y lo pones en la caja de preparación.

La caja de preparación es un área temporal. Si decide descartar la fotocopia en la caja de preparación y actualizarla con una nueva copia del documento del directorio de trabajo, no habrá un registro permanente de ese documento.

Suponga que está bastante seguro de que desea mantener el registro permanente del documento que tiene en el cuadro de preparación. Luego haces una fotocopia del documento de la caja de preparación y la mueves a la caja del repositorio.

Cuando lo mueve al cuadro de repositorio, suceden dos cosas:

1. Una instantánea del documento se guarda de forma permanente.
2. Se crea una entrada de archivo de registro para acompañar la instantánea.

La entrada de registro lo ayudará a encontrar esa instantánea particular de su documento si la necesita en el futuro.

Ahora, en el cuadro del repositorio local, tiene una instantánea de su trabajo y una entrada de registro. Pero solo está disponible para ti. Así que hace una copia de su documento de repositorio local junto con el archivo de registro y lo coloca en una caja en la sala de suministros de la empresa. Ahora cualquier persona de su empresa puede venir y hacer una copia de su documento y llevarlo a su escritorio. La caja en la sala de suministros sería el depósito remoto.

El repositorio remoto es como compartir su documento usando Google Docs o Dropbox.

Preguntas:

• ¿Puede definir el directorio de trabajo, la preparación, el repositorio y el repositorio remoto??
• ¿Puedes dibujar cómo se mueven los documentos de una etapa a otra??

Tu primer repositorio de Git

Una vez que haya instalado Git, puede comenzar a crear sus propios repositorios de Git. En esta sección, va a inicializar su repositorio de Git.

Suponga que está trabajando en un proyecto de desarrollo web. Creemos una carpeta llamada project_helloworld y cambiemos al directorio:

$ mkdir project_helloworld
$ cd project_helloworld

Puedes decirle a Git que monitoree este directorio con el siguiente comando:

$ git init

Debería ver una salida como esta:

Repositorio de Git vacío inicializado en / Users / zakh / _work / LearnGIT / git_tutorial /
project_helloworld /.git

Ahora Git rastreará todos los archivos y carpetas dentro de project_helloworld.

Preguntas:

• ¿Cómo se inicializa un directorio para ser rastreado por Git??

Comandos básicos de Git: estado, registro, agregar y confirmar

El comando de estado muestra la condición actual de su directorio de trabajo y el comando de registro muestra el historial. Probemos el comando de estado:

estado de $ git
En el maestro de la sucursal
Compromiso inicial
nada que confirmar (crear / copiar archivos y usar "git add" para realizar un seguimiento)

La salida del comando git status dice que estás en la rama maestra. Esta es la rama predeterminada que inicializa Git. (Puedes crear tus propias ramas. Más sobre las ramas más adelante). Además, la salida dice que no hay nada que comprometer.

Probemos el comando de registro:

$ git log
fatal: su rama actual 'master' aún no tiene confirmaciones

Entonces, es hora de crear un código. Creemos un archivo llamado índice.html:

Hola Mundo

Puede utilizar el editor de texto para crear el archivo. Una vez que haya guardado el archivo, verifique el estado nuevamente:

estado de $ git
En el maestro de la sucursal
Compromiso inicial
Archivos sin seguimiento:
(use "git add ... "para incluir en lo que se comprometerá)
índice.html
no se agregó nada para confirmar, pero los archivos sin seguimiento están presentes (use "git add" para realizar el seguimiento)

Git te está diciendo que tienes un archivo llamado index.html en su directorio de trabajo que no tiene seguimiento.

Asegurémonos de indexar.html se rastrea. Necesitará usar el comando add:

$ git agregar índice.html

Alternativamente, puede utilizar el ".”Opción para agregar todo en el directorio:

$ git agregar .

Ahora revisemos el estado nuevamente:

estado de $ git
En el maestro de la sucursal
Compromiso inicial
Cambios a comprometer:
(use "git rm --cached ... "para quitar el escenario)
nuevo archivo: índice.html

El verde indica que el índice.El archivo html está siendo rastreado por Git.

Consejo: Como se mencionó en las instrucciones anteriores, si usa el comando:

$ git rm: índice en caché.html

Tu índice.html volverá al estado sin seguimiento. Tendrás que volver a agregarlo para que vuelva a la puesta en escena.]

Revisemos el registro nuevamente:

$ git log
fatal: su rama actual 'master' aún no tiene confirmaciones

Entonces, aunque Git está rastreando el índice.html, todavía no hay nada en el repositorio de Git sobre el archivo. Confirmemos nuestros cambios:

$ git commit -m "Índice de confirmación.html "
La salida debería verse así:
[master (root-commit) f136d22] Índice de confirmación.html
1 archivo modificado, 6 inserciones (+)
modo de creación 100644 índice.html

El texto entre las comillas después de la "-m" es un comentario que se incluirá en el archivo de registro. Puedes usar git commit sin "-m", pero luego Git abrirá un editor de texto pidiéndote que escribas los comentarios. Es más fácil poner los comentarios directamente en la línea de comando.

Ahora revisemos nuestro archivo de registro:

$ git log
cometer f136d22040ba81686c9522f4ff94961a68751af7
Autor: Zak H
Fecha: lun 4 de junio 16:53:42 2018-0700
Índice de compromiso.html

Puedes ver que muestra un compromiso. Has confirmado con éxito tus cambios en tu repositorio local. Si desea ver el mismo registro de forma concisa, puede utilizar el siguiente comando:

$ git log --en línea
f136d22 Índice de compromiso.html

En el futuro, usaremos esta forma del comando de registro porque facilita la comprensión de lo que está sucediendo.

Comencemos a editar el índice.html. Abrir el índice.html en un editor y cambie la línea "Hola mundo" a "Hola mundo! Soy yo!"Y guárdalo. Si vuelve a comprobar el estado, verá que Git ha notado que está editando el archivo:

estado de $ git
En el maestro de la sucursal
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: índice.html
no se agregaron cambios para confirmar (use "git add" y / o "git commit -a")

El cambio aún está en su directorio de trabajo. Necesitas empujarlo al área de preparación. Use el comando add que usó antes:

$ git agregar .

Verifique el estado nuevamente:

estado de $ git
En el maestro de la sucursal
Cambios a comprometer:
(use "git reset HEAD ... "para quitar el escenario)
modificado: índice.html

Ahora tus cambios están en el área de preparación. Puede enviarlo al repositorio para su custodia permanente:

$ git commit -m "Índice modificado.html a un mensaje más feliz "
[master 0586662] Índice modificado.html a un mensaje más feliz
1 archivo modificado, 1 inserción (+), 1 eliminación (-)

Puede consultar el registro para ver sus cambios permanentes:

$ git log --en línea
0586662 Índice modificado.html a un mensaje más feliz
f136d22 Índice de compromiso.html

En esta sección, ha aprendido a usar los comandos de estado, registro, agregar y confirmar para realizar un seguimiento de sus documentos en Git.

Preguntas:

• ¿Qué hace git status??
• ¿Qué hace git log??
• ¿Qué hace git add??
• ¿Qué hace git commit??

Volver a archivos más antiguos usando Checkout

Cuando envías un archivo en Git, crea un hash único para cada confirmación. Puede utilizarlos como identificadores para volver a una versión anterior.

Supongamos que desea volver a su versión anterior de index.html. Primero, veamos el índice.html en la condición actual:

$ índice de gato.html

Hola Mundo! Soy yo!

Puede ver que tiene la versión más reciente ("Hola mundo! Soy yo!"). Revisemos el registro:

$ git log --en línea
0586662 Índice modificado.html a un mensaje más feliz
f136d22 Índice de compromiso.html

El hash de la versión anterior era f136d22 ("Hola mundo").  Puede usar el comando de pago para llegar a esa versión:

$ git checkout f136d22
Nota: verificando 'f136d22'.
Estás en estado de 'CABEZA separada'. Puedes mirar a tu alrededor, hacer cambios experimentales
y cometerlos, y puedes descartar cualquier compromiso que hagas en este estado
sin afectar ninguna sucursal al realizar otro pago.
Si desea crear una nueva rama para retener las confirmaciones que crea, puede
hágalo (ahora o más tarde) usando -b con el comando de pago nuevamente. Ejemplo:
git checkout -b
HEAD está ahora en f136d22… Índice de compromiso.html

Si observa el contenido de index.html, verá:

$ índice de gato.html

Hola Mundo

Solo tiene "Hola mundo". Entonces tu índice.html ha cambiado a la versión anterior. Si verifica el estado:

estado de $ git
CABEZA separada en f136d22
nada que confirmar, directorio de trabajo limpio

Básicamente, Git te está diciendo que HEAD no está en la confirmación más reciente. Puede volver a la confirmación más reciente consultando la rama maestra con el siguiente comando:

$ git checkout master
La posición anterior de HEAD era f136d22… Índice de compromiso.html
Cambiado a la rama 'maestra'

Ahora, si verificas el estado:

estado de $ git
En el maestro de la sucursal
nada que confirmar, directorio de trabajo limpio

La advertencia roja se ha ido. Además, si revisa su índice.html, debería volver a la última versión:

$ índice de gato.html

Hola Mundo! Soy yo!

El comando de pago te lleva a varios estados. Aprenderemos más sobre el pago en la siguiente sección.

Preguntas:

• ¿Cómo se usa el comando git checkout para ir a una versión anterior de un archivo??
• ¿Cómo se usa git checkout para volver a la última versión del archivo??

Pago, ramificación y fusión

La ramificación es una de las mejores características de Git. Te ayuda a separar tu trabajo y experimentar más. En otros sistemas de control de versiones, la ramificación requería mucho tiempo y era difícil. Git facilitó la ramificación y la fusión.

Como notó en el comando de estado, cuando crea un nuevo repositorio de Git, está en la rama maestra.

estado de $ git
En el maestro de la sucursal
nada que confirmar, directorio de trabajo limpio

Suponga que está creando un sitio web para su amigo David. Quieres reutilizar el código de tu propio sitio web. La ramificación es una gran solución. Llamemos a la sucursal david_website.

Puede emitir el siguiente comando:

$ git branch david_website

Puede usar el siguiente comando para ver todas las ramas:

$ git branch - lista
david_website
* Maestro

La estrella (*) al lado de master significa que todavía estás en la rama master. Puede consultar la rama david_website con el siguiente comando:

$ git checkout david_website
Cambiado a la rama 'david_website'

Ahora, si vuelve a comprobar la lista de sucursales, verá:

$ git branch - lista
* david_website
Maestro

Entonces estás en la rama david_website.

Cambiemos el índice.html de "Hola mundo! Soy yo!"A" Hola mundo! Es David!”Y luego escenificarlo y comprometerlo:

$ git agregar .
$ git commit -m "Se cambió el sitio web de David"

Si revisa los registros, debería ver:

$ git log --en línea
345c0f4 Se cambió el sitio web de David
0586662 Índice modificado.html a un mensaje más feliz
f136d22 Índice de compromiso.html

Y su archivo de índice debería verse así:

$ índice de gato.html

Hola Mundo! Es David!

Ahora echemos un vistazo a la rama maestra nuevamente:

$ git checkout master
Cambiado a la rama 'maestra'

Si verifica el estado y el registro:

estado de $ git
En el maestro de la sucursal
nada que confirmar, directorio de trabajo limpio
$ git log --en línea
0586662 Índice modificado.html a un mensaje más feliz
f136d22 Índice de compromiso.html

Observe que no tiene su tercer compromiso en el maestro. Porque esa confirmación solo se mantiene en la rama david_website.

Esto es lo que pasó

Suponga que en esta etapa decide que no desea continuar con su sitio web. Solo serás el desarrollador de David. Entonces desea fusionar los cambios en la rama david_website con el maestro. Desde la rama maestra, solo tiene que emitir los siguientes comandos (el comando de estado se usa para verificar si está en el lugar correcto):

estado de $ git
En el maestro de la sucursal
nada que confirmar, directorio de trabajo limpio
 
$ git merge david_website
Actualizando 0586662… 345c0f4
Avance rápido
índice.html | 2 +-
1 archivo modificado, 1 inserción (+), 1 eliminación (-)

Consejo: Estás extrayendo cambios de david_website a master. Tienes que estar en el maestro para lograr esto.

Ahora, si revisa el registro en el maestro, verá que la tercera confirmación está allí:

$ git log --en línea
345c0f4 Se cambió el sitio web de David
0586662 Índice modificado.html a un mensaje más feliz
f136d22 Índice de compromiso.html

Has fusionado con éxito la rama david_website en master. Y tu índice.html para la rama maestra parece idéntico a la rama david_website:

$ índice de gato.html

Hola Mundo! Es David!

Puede conservar la rama david_website:

$ git branch - lista
david_website
* Maestro

O puede eliminarlo:

$ git branch -d david_website
Rama eliminada david_website (era 345c0f4).

Después de la eliminación, ya no debería ver la rama david_website:

$ git branch - lista
* Maestro

Consejo: Durante una fusión, si Git no puede fusionarse automáticamente, le dará errores de conflicto de fusión. En ese caso, debe resolver manualmente los problemas de combinación.

Preguntas:

• ¿Por qué necesitas ramificar??
• ¿Cómo se ramifican y fusionan archivos y carpetas??

Repositorio remoto

Hasta ahora todo tu trabajo ha sido local. Has estado confirmando tus cambios en un repositorio local. Pero es hora de compartir tu trabajo con el mundo.

El repositorio remoto de Git es básicamente otra copia de su repositorio local al que otros pueden acceder. Puede configurar un servidor y convertirlo en el repositorio remoto. Pero la mayoría de la gente usa GitHub o Bitbucket para este propósito. Puede crear repositorios públicos de forma gratuita allí a los que puede acceder cualquier persona.

Creemos un repositorio remoto en GitHub.

Primero, necesitas crear una cuenta de GitHub []. Una vez que tenga la cuenta, cree un nuevo repositorio usando el botón "Nuevo repositorio". Utilice "project_website" como nombre del repositorio (puede elegir otra cosa si lo desea).

Debería ver una pestaña Código con instrucciones como estas:

... o crea un nuevo repositorio en la línea de comandos

echo "# project_website" >> README.Maryland
git init
git add README.Maryland
git commit -m "primer compromiso"
git remoto agregar origen git @ github.com: yourusername / project_website.git
git push -u maestro de origen

Copie el siguiente comando "git remote add origin" y ejecútelo en su directorio de trabajo:

$ git remoto agregar origen git @ github.com: yourusername / project_website.git

Nota: En su caso, su nombre de usuario debe ser el que utilizó para crear su cuenta de GitHub.

En el comando anterior, le indicaste a Git la ubicación del repositorio remoto. El comando le dice a Git que el "origen" de su directorio de trabajo project_helloworld será "[email protected]: yourusername / project_website.git ".

Ahora empuje su código desde su rama maestra al origen (repositorio remoto):

$ git push origin master
Contando objetos: 9, hecho.
Compresión delta usando hasta 4 subprocesos.
Comprimir objetos: 100% (6/6), hecho.
Objetos de escritura: 100% (9/9), 803 bytes | 0 bytes / s, hecho.
Total 9 (delta 2), reutilizado 0 (delta 0)
remoto: Resolución de deltas: 100% (2/2), hecho.
Para git @ github.com: yourusername / project_website.git
* [nueva rama] maestro -> maestro

Si actualiza su navegador en GitHub, debería ver que el índice.El archivo html está ahí arriba. Por lo tanto, su código es público y otros desarrolladores pueden consultar y modificar el código en el repositorio remoto.

Como desarrollador, trabajará con el código de otras personas. Entonces vale la pena intentar verificar el código de GitHub.

Vayamos a un nuevo directorio donde no tienes nada. En el lado derecho del repositorio de GitHub, verá el botón "Clonar o descargar". Si hace clic en él, debería darle una dirección SSH. Ejecute el siguiente comando con la dirección SSH:

$ git clon git @ github.com: yourusername / project_website.git

La salida debería verse así:

$ git clon git @ github.com: yourusername / project_website.git
Clonando en 'project_website'…
remoto: Contando objetos: 9, hecho.
remoto: Comprimir objetos: 100% (4/4), hecho.
remoto: Total 9 (delta 2), reutilizado 9 (delta 2), paquete reutilizado 0
Recepción de objetos: 100% (9/9), hecho.
Resolución de deltas: 100% (2/2), hecho.
Comprobando conectividad ... hecho.

Creará un project_website en su carpeta limpia. Si entra, debería ver el índice.html de su project_helloworld.

Entonces ha logrado lo siguiente:

• Creado y realizado cambios en project_helloworld
• Subió el código a GitHub en project_website
• Descargó el código de GitHub

Veamos otro archivo del nuevo directorio de trabajo project_website:

$ touch Léame.Maryland
$ git agregar .
$ git commit -m "Léame agregado.Maryland"
$ git push origin master

Si actualiza la página del sitio web del proyecto de GitHub, debería ver el archivo Léame.archivo md allí.

Nota: cuando descarga el código de GitHub, el directorio de trabajo conoce automáticamente el origen. No tiene que definirlo con el comando "git remote add origin".

Preguntas:

• ¿Por qué necesitas usar repositorios remotos??
• ¿Cómo configura su repositorio local actual para conectarse al repositorio remoto??
• ¿Cómo clona repositorios remotos en su computadora local??

Conclusión

Puede encontrar más información sobre todos los comandos en los documentos de Git []. Aunque hay herramientas de interfaz de usuario de Git disponibles, la línea de comandos es la mejor manera de dominar Git. Le dará una base más sólida para su trabajo de desarrollo.

Estudio adicional:

• https: // git-scm.com / docs
• https: // git-scm.com / book / en / v2
• https: // git-scm.com / videos