Tutorial Git para principiantes

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

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

Diviértete aprendiendo git!

Git: una breve descripción general

Git es un sistema de control de versiones distribuidas. 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 toda su base de código a una versión anterior.

El desarrollo de GIT comenzó en 2005. El grupo de kernel Linux utilizado para mantener su código en Bitkeeper, un sistema de control de versiones distribuidas patentadas. 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 distribuidas de código abierto que cumpliría con los requisitos de la comunidad de desarrollo de Linux. Y Git nació.

Como sistema de control de versiones distribuidas, Git no requiere una autoridad centralizada para realizar un seguimiento del código. Controles de versiones centralizadas más antiguas como CVS, SVN o Perforce requieren que los servidores centrales mantengan el historial de cambios. Git puede realizar un seguimiento de todos los cambios localmente y trabajar entre pares. Entonces 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 distribuidas??

Instalación de GIT

Para los sistemas de Linux, la instalación de git es fácil. Si está utilizando 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 install git-all

Puede verificar si se ha instalado GIT, utilizando el siguiente comando:

$ git --versión

Debería mostrarle la versión del git que instaló, 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.Nombra "YouruseName"
$ git config -usuario global.Envíe un correo electrónico "[email protected] "

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

$ git config --list
usuario.Nombre = YourUsername
usuario.correo electrónico = [email protected]

Consejo: Es importante establecer al usuario.Nombre y usuario.correo electrónico porque estas configuraciones se utilizan para rastrear 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??

Comprender 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 puesta en escena 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 documentos estándar A1.

Supongamos que está escribiendo un documento a mano en un papel A1 en su escritorio. Mantiene este documento en el cuadro de directorio de trabajo. En una determinada etapa de su trabajo, decide que está listo para mantener una copia del trabajo que ya ha realizado. Entonces haces una fotocopia de tu papel actual y lo pones en la caja de puesta en escena.

La caja de puesta en escena es un área temporal. Si decide descartar la fotocopia en el cuadro de puesta en escena y actualizarla con una nueva copia del documento del directorio de trabajo, no habrá un registro permanente de ese documento escenificado.

Supongamos que está bastante seguro de que desea mantener el registro permanente del documento que tiene en el cuadro de puesta en escena. Luego hace una fotocopia del documento del cuadro de puesta en escena y lo mueve al cuadro del repositorio.

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

1. Una instantánea del documento se guarda permanentemente.
2. Se realiza una entrada de archivo de registro para ir con la instantánea.

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

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

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

Preguntas:

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

Su primer repositorio de Git

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

Supongamos 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

Puede decirle a GIT que monitoree este directorio con el siguiente comando:

$ git init

Deberías ver una salida como esta:

Repositorio de git vacío inicializado en/usuarios/zakh/_work/aprendizaje/git_tutorial/
Project_Helloworld/.git

Ahora cualquier archivo y carpetas dentro de Project_Helloworld será rastreado por Git.

Preguntas:

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

Comandos básicos de git: estado, registro, agregado y confirmación

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 rama maestro
Compromiso inicial
Nada para comprometer (crear/copiar archivos y usar "Git Add" para rastrear)

La salida del comando de estado git es decir que estás en la rama maestra. Esta es la rama predeterminada que GIT inicializa. (Puedes crear tus propias ramas. Más sobre ramas más tarde). Además, la salida dice que no hay nada que cometer.

Probemos el comando de registro:

Log de $ git
fatal: su rama actual 'maestro' aún no tiene ninguna compromiso

Entonces, es hora de crear algún código. Creemos un archivo llamado índice.HTML:

Hola Mundo

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

Estado de $ git
En rama maestro
Compromiso inicial
Archivos sin seguimiento:
(Use "git add ..." para incluir en lo que se cometirá)
índice.html
Nada agregado a la confirmación, pero los archivos no seguidos presentes (use "Git Agregar" para rastrear)

Git le dice que tiene un archivo llamado índice.html en su directorio de trabajo que no se realiza.

Asegurémonos del índice.HTML está rastreado. Deberá usar el comando Agregar:

$ git agregar índice.html

Alternativamente, podría usar el "."Opción para agregar todo en el directorio:

$ git add .

Ahora revisemos el estado nuevamente:

Estado de $ git
En rama maestro
Compromiso inicial
Cambios a ser cometidos:
(Use "git rm --cachado ..." para desico)
Nuevo archivo: índice.html

El verde indica que el índice.Git está rastreando el archivo HTML.

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

$ git rm -índice cached.html

Tu índice.HTML volverá al estado no considerado. Tendrás que agregarlo nuevamente para volver a la puesta en escena.]

Vamos a ver el registro nuevamente:

Log de $ git
fatal: su rama actual 'maestro' aún no tiene ninguna compromiso

Entonces, a pesar de que GIT es un seguimiento del índice.HTML, todavía no hay nada en el repositorio de git sobre el archivo. Comprometamos nuestros cambios:

$ git commit -m "Índice de compromiso.html "
La salida debería verse algo así:
[Maestro (Root-Commit) F136D22] Compromiso del índice.html
1 archivo cambiado, 6 inserciones (+)
Crear modo 100644 índice.html

El texto dentro de las citas después del "-m" es un comentario que irá al archivo de registro. Puede usar Git Commit sin "-m", pero luego Git abrirá un editor de texto pidiéndole que escriba los comentarios. Es más fácil simplemente poner los comentarios directamente en la línea de comando.

Ahora revisemos nuestro archivo de registro:

Log de $ git
Commit F136D22040BA81686C9522F4FF94961A68751AF7
Autor: Zak H
Fecha: lun 4 de junio 16:53:42 2018 -0700
Índice de compromiso.html

Puedes ver que muestra un comet. Ha cometido con éxito sus cambios en su repositorio local. Si desea ver el mismo registro de una manera concisa, puede usar el siguiente comando:

$ git log -enneline
F136D22 Conocimiento del índice.html

En el futuro, usaremos esta forma del comando de registro porque hace que sea más fácil entender lo que está sucediendo.

Empecemos a editar el índice.html. Abra el índice.Archivo HTML en un editor y cambie la línea "Hello World" a "Hello World! Soy yo!"Y guárdelo. Si verifica el estado nuevamente, verá que Git ha notado que está editando el archivo:

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

El cambio todavía está en su directorio de trabajo. Necesitas llevarlo al área de puesta en escena. Use el comando Agregar que usó antes:

$ git add .

Verifique el estado nuevamente:

Estado de $ git
En rama maestro
Cambios a ser cometidos:
(Use "Git Restinir Head ..." a Unstage)
Modificado: índice.html

Ahora sus cambios están en el área de puesta en escena. Puede comprometerlo con el repositorio de custodia permanente:

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

Puede verificar el registro de sus cambios permanentes:

$ git log -enneline
0586662 Índice modificado.html a un mensaje más feliz
F136D22 Conocimiento del índice.html

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

Preguntas:

• ¿Qué hace el estado de git??
• ¿Qué hace el registro de git??
• ¿Qué hace git agre??
• ¿Qué hace Git Commit??

Volver a los archivos más antiguos usando el pago

Cuando cometes un archivo en GIT, crea un hash único para cada confirmación. Puede usarlos como identificadores para volver a una versión anterior.

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

$ Cat Index.html



Hola Mundo! Soy yo!

Puedes ver que tienes la versión más nueva ("Hola mundo! Soy yo!"). Vamos a ver el registro:

$ git log -enneline
0586662 Índice modificado.html a un mensaje más feliz
F136D22 Conocimiento del índice.html

El hash para la versión anterior fue F136D22 ("Hello World"). Puede usar el comando de pago para llegar a esa versión:

$ git checkout f136d22
Nota: Revisar 'F136D22'.
Estás en el estado de 'cabeza separada'. Puedes mirar a su alrededor, hacer cambios experimentales
y confirértalos, y puedes descartar cualquier compromiso que hagas en este estado
sin afectar ninguna rama realizando otro pago.
Si desea crear una nueva sucursal para retener las comodidades que cree, puede
Hazlo (ahora o más tarde) usando -b con el comando de pago nuevamente. Ejemplo:
Git Checkout -B
La cabeza ahora está en f136d22 ... cometiendo índice.html

Si observa el contenido del índice.html, verás:

$ Cat Index.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 para comprometerse, Directorio de trabajo limpio

Básicamente, Git te dice que la cabeza no está en el compromiso más reciente. Puede volver a la confirmación más reciente revisando la rama maestra utilizando el siguiente comando:

$ git checkout maestro
La posición anterior de la cabeza era F136D22 ... Conjunto del índice.html
Cambio a la rama 'maestro'

Ahora si verifica el estado:

Estado de $ git
En rama maestro
Nada para comprometerse, Directorio de trabajo limpio

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

$ Cat Index.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 de pago 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??

Claro, 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 llevaba mucho tiempo y fue 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 rama maestro
Nada para comprometerse, Directorio de trabajo limpio

Supongamos que está haciendo un sitio web para su amigo David. Desea reutilizar el código de su propio sitio web. La ramificación es una gran solución. Llamemos a la rama david_website.

Puede emitir el siguiente comando:

$ git rama david_website

Puede usar el siguiente comando para ver todas las ramas:

$ Git Branch -Lista
David_website
* maestro

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

$ git checkout david_website
Cambio a la rama 'David_Website'

Ahora, si vuelve a verificar la lista de sucursales, ya ves:

$ Git Branch -Lista
* David_website
maestro

Entonces estás en la rama david_website.

Cambiemos el índice.html de "Hello World! Soy yo!"A" Hola mundo! Es David!"Y luego escenifica y comprométalo:

$ git add .
$ git commit -m "cambió de sitio web para David"

Si verifica los registros, debería ver:

$ git log -enneline
345c0f4 Sitio web cambiado para David
0586662 Índice modificado.html a un mensaje más feliz
F136D22 Conocimiento del índice.html

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

$ Cat Index.html



Hola Mundo! Es David!

Ahora vamos a ver la rama maestra nuevamente:

$ git checkout maestro
Cambio a la rama 'maestro'

Si verifica el estado y registra:

Estado de $ git
En rama maestro
Nada para comprometerse, Directorio de trabajo limpio
$ git log -enneline
0586662 Índice modificado.html a un mensaje más feliz
F136D22 Conocimiento del índice.html

Observe que no tiene su tercer compromiso en el maestro. Porque ese compromiso solo se mantiene en la rama david_website.

Esto es lo que pasó

Supongamos que en esta etapa decide que no desea continuar su sitio web. Solo serás el desarrollador de David. Entonces quieres fusionar los cambios en la rama david_website al 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 rama maestro
Nada para comprometerse, Directorio de trabajo limpio
$ git fusion david_website
Actualización 0586662 ... 345C0F4
Avance rápido
índice.html | 2 +-
1 archivo cambiado, 1 inserción (+), 1 deleción (-)

Consejo: Estás haciendo cambios de David_Website a Master. Tienes que estar en el maestro para lograr esto.

Ahora, si verifica el registro en el maestro, ve que el tercer confirmación está ahí:

$ git log -enneline
345c0f4 Sitio web cambiado para David
0586662 Índice modificado.html a un mensaje más feliz
F136D22 Conocimiento del índice.html

Has fusionado con éxito la rama david_website en el maestro. Y tu índice.HTML para Master Branch parece idéntico a David_Website Branch:

$ Cat Index.html



Hola Mundo! Es David!

Puedes mantener la rama david_website:

$ Git Branch -Lista
David_website
* maestro

O puedes eliminarlo:

$ git rama -d david_website
Rama eliminada David_Website (fue 345C0F4).

Después de la eliminación, ya no deberías 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 fusiones. En ese caso, debes resolver manualmente los problemas de fusión.

Preguntas:

• ¿Por qué necesitas ramificar??
• ¿Cómo se ramifica y fusiona archivos y carpetas??

Repositorio remoto

Hasta ahora, todo su trabajo ha sido local. Ha estado comprometiendo sus cambios en un repositorio local. Pero es hora de compartir tu trabajo con el mundo.

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

Creemos un repositorio remoto en GitHub.

Primero, debe crear una cuenta de GitHub []. Una vez que tenga la cuenta, cree un nuevo repositorio utilizando el botón "Nuevo repositorio". Use "Project_Website" como nombre del repositorio (puede elegir algo más si lo desea).

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

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

echo "# Project_Website" >> Readme.Maryland
git init
git agregar lectura.Maryland
git commit -m "Primer comandante"
git remoto agregar origen [email protected]: YourUsername/Project_Website.git
Git Push -U Origin Master

Copie el siguiente comando "Git Remote Add Origin" y ejecutarlo en su directorio de trabajo:

$ git remoto agregar origen [email protected]: YourUsername/Project_Website.git

Nota: En su caso, su nombre de USUNTER debe ser lo que usó para crear su cuenta de GitHub.

En el comando anterior, usted instruyó a GIT la ubicación del repositorio remoto. El comando le dice a GIT que el "origen" para su directorio de trabajo Project_Helloworld será "[email protected]: YourUsername/Project_Website.git ".

Ahora presione su código de su rama maestra a origen (repositorio remoto):

$ git push origin maestro
Contando objetos: 9, hecho.
Compresión delta utilizando hasta 4 hilos.
Objetos de comprimir: 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.
A [email protected]: 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. Por lo tanto, vale la pena intentar pagar el código de GitHub.

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

$ git clone [email protected]: YourUsername/Project_Website.git

La salida debería verse así:

$ git clone [email protected]: YourUsername/Project_Website.git
Clonarse en 'Project_website' ..
Remoto: Contación de objetos: 9, hecho.
remoto: objetos de comprimir: 100% (4/4), hecho.
Remoto: Total 9 (Delta 2), reutilizado 9 (Delta 2), Reussuse de paquete 0
Objetos de recepción: 100% (9/9), hecho.
Resolución de deltas: 100% (2/2), hecho.
Comprobación de conectividad ... hecho.

Creará un proyecto_website en su carpeta limpia. Si entras, deberías ver el índice.html de tu proyecto_helloworld.

Entonces has logrado lo siguiente:

• Creó e hizo cambios en Project_Helloworld
• Subí el código a GitHub en Project_Website
• Descargado el código de GitHub

Vamos a otro archivo del nuevo directorio de trabajo Project_Website:

$ Touch ReadMe.Maryland
$ git add .
$ git commit -m "agregó lectura.Maryland"
$ git push origin maestro

Si actualiza la página GitHub Project_Website, debería ver el ReadMe.archivo md allí.

Nota: Cuando descarga 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 se configura su repositorio local actual para conectarse al repositorio remoto??
• ¿Cómo se clonan repositorios remotos a su computadora local??

Conclusión

Puede encontrar más información sobre todos los comandos en los documentos de git []. A pesar de que hay herramientas de interfaz de usuario 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/documentos
• https: // git-scm.com/libro/en/v2
• https: // git-scm.com/videos