El manual esencial de Git

Introducción

¡Hola! Soy Sanjula, y en esta guía espero enseñarte un poco sobre Git, incluyendo:

  • Que es Git
  • Por que aprender Git
  • Establecer variables de configuración
  • Introducción al comando de ayuda en Git
  • Cómo convertir un proyecto existente en un repositorio local de Git
  • Cosas que hacer antes del primer compromiso
  • Cómo agregar archivos al área de preparación
  • Cómo eliminar archivos del área de preparación
  • Haciendo tu primer compromiso
  • Cómo clonar un repositorio remoto
  • Ver información sobre el repositorio remoto
  • Cómo enviar sus cambios al repositorio remoto
  • Cómo crear una rama para una característica o problema específico
  • Empuje la rama al repositorio remoto después de confirmar
  • Cómo fusionar una rama
  • Cómo eliminar una rama

¡Empecemos!

¿Qué es Git?

En términos sencillos, Git es un sistema de control de versiones distribuido de código abierto .

Los sistemas de control de versiones ayudan a cualquier equipo de software a administrar cambios en el código fuente de un producto o servicio a lo largo del tiempo. Realiza un seguimiento de todas las modificaciones al código fuente en una base de datos. Si se ha cometido un error crítico en el código fuente, los desarrolladores de un equipo de software pueden rebobinar el código fuente a una versión anterior a la realización del cambio erróneo. Como resultado, los sistemas de control de versiones protegen el código fuente de desastres, errores humanos y consecuencias no deseadas (cuando una corrección de errores rompe otra parte de la aplicación, por ejemplo).

Entonces, ¿por qué aprender Git?

Git es el sistema de control de versiones más utilizado en el mundo actual. Es un proyecto de código abierto maduro y mantenido activamente desarrollado originalmente por Linus Torvalds.

Una cantidad asombrosa de proyectos de software dependen de Git para el control de versiones, incluidos proyectos comerciales y de código abierto, especialmente utilizando el servicio de alojamiento de repositorios de git, GitHub, que ahora es propiedad de Microsoft. De ahí la importancia de aprender Git.

Requisito previo para esta guía

Descarga e instala git aquí

Verifique la versión de git

git --version

Si se devuelve el número de versión, significa que git se instaló correctamente en su computadora.

Establecer valores de configuración

Ahora necesitamos establecer las variables de configuración global, que son muy importantes, especialmente si está trabajando con otros desarrolladores. La principal ventaja de esto es que es más fácil descubrir quién ha comprometido un determinado bloque de código, por ejemplo.

git config --global user.name “Sanjula Madurapperuma”
git config --global user.email “[email protected]
git config --list

Comando de ayuda

Como puede notar, config es un verbo que se ha usado con frecuencia hasta ahora en este manual y los verbos también se pueden usar como prefijo o sufijo con el comando help. Podemos usar el mismo ejemplo (el verbo config ) de arriba para explicar estos comandos.

git help config
git config --help

Ambos comandos anteriores realizan la misma acción. Muestra la página de manual del verbo especificado. Esto será útil para identificar capacidades más avanzadas de git.

Cómo inicializar un repositorio a partir de código existente

Si tiene un repositorio local que desea convertir en un proyecto git para comenzar a rastrearlo, entonces podemos comenzar ejecutando el comando a continuación dentro del directorio del proyecto.

git init

¡Hecho! Así, ha convertido su proyecto en un repositorio local de git. Si abre la carpeta del proyecto, verá que se ha creado un nuevo directorio llamado .git.

Qué hacer antes del primer compromiso

Ingrese el siguiente comando para ver los archivos sin seguimiento:

git status

Si hay archivos que no desea que otras personas vean en el repositorio, como archivos que contienen preferencias personales o las del IDE, haga lo siguiente:

touch .gitignore

Para especificar qué archivos no se agregarán al repositorio de git, abra un editor de texto y vea el archivo .gitignore, que se puede editar como un archivo de texto normal. Ahora podemos ingresar lo siguiente en el archivo, por ejemplo:

.project
*.java

También se pueden utilizar caracteres comodín. En este caso, se ha utilizado para especificar que no se agreguen al repositorio todos los archivos que terminan con la extensión .java.

Ahora ejecuta git status de nuevo

Ahora puede ver que los archivos que excluimos en el archivo .gitignore ya no se muestran en la lista de archivos sin seguimiento. El archivo .gitignore debe confirmarse en el repositorio para mantener las mismas exclusiones en todos los demás lugares.

Agregar archivos al área de preparación

Todo este tiempo estuvimos en el directorio de trabajo. El área de preparación es donde organizamos todos los archivos que se rastrean y deben confirmarse antes de enviarlos al repositorio de git. Es un archivo que almacena lo que se debe incluir en la próxima confirmación.

Si desea agregar todos los archivos que actualmente no están rastreados y ha cambiado al área de preparación, use el siguiente comando:

git add -A

Si desea agregar archivos individualmente, podemos darle el nombre del archivo después de git add. Por ejemplo,

git add .gitignore

Ahora, si escribe git status, verá que el archivo .gitignore está ahora en el área de prueba.

Eliminar archivos del área de preparación

Para eliminar archivos individualmente del área de preparación, escriba lo siguiente (por ejemplo):

git reset simple.py

Esto eliminará el archivo simple.py del área de preparación. Para ver este cambio, escriba git status nuevamente.

Si desea eliminar todos los archivos del área de preparación, ejecute lo siguiente:

git reset

Ahora, si escribimos git status, veremos que todos los archivos se han cambiado a archivos sin seguimiento.

Haciendo el primer compromiso

Ahora ejecute lo siguiente para agregar todos los archivos al área de preparación para confirmar.

git add -A

Si lo desea, puede ejecutar git status para ver todos los archivos que se confirmarán.

Para confirmar, escriba lo siguiente.

git commit -m “Initial Commit”

“-M” especifica un mensaje que se debe pasar describiendo la confirmación. Dado que esta es nuestra primera confirmación, diremos Confirmación inicial.

Como puede ver, los archivos se han comprometido correctamente.

Si ejecuta git status ahora, verá que dice que el directorio de trabajo está limpio porque hemos confirmado los archivos y no hemos modificado ningún archivo desde entonces.

Si ejecutamos el siguiente comando:

git log

luego podemos ver la confirmación que acabamos de realizar, incluido el número hash de la confirmación.

¡Ahora estamos rastreando exitosamente el proyecto local con git!

Clonación de un repositorio remoto

Si queremos rastrear un proyecto remoto existente con git, entonces tenemos que escribir un comando en el siguiente formato:

git clone  

Por ejemplo, usaré el repositorio de git en este enlace.

Primero me moveré al directorio en el que quiero clonar el proyecto, aunque también puede especificar esto como se muestra arriba.

Vaya al enlace del repositorio que se muestra arriba y haga clic en el botón "Clonar o Descargar", luego copie el enlace que se proporciona allí.

Luego ingrese:

git clone //github.com/sanjulamadurapperuma/GitDemoMedium.git

Ahora hemos clonado el repositorio con éxito.

Si ingresamos el siguiente comando, veremos todos los archivos que están ahora en el directorio local.

ls -la

Ver información sobre el repositorio remoto

Si escribe el siguiente comando:

git remote -v

Este comando enumerará las ubicaciones de las que el repositorio local obtendría las confirmaciones externas y las enviará al repositorio remoto.

Si tuviera que escribir el comando

git branch -a

Esto mostrará una lista de todas las ramas que están en el repositorio, tanto de forma local como remota.

Para demostrar la actualización del repositorio remoto, haremos algunos cambios en los archivos del repositorio que clonamos.

Ahora que hemos realizado un cambio en nuestro código, la siguiente acción que debemos realizar es enviar estos cambios al repositorio remoto.

Enviar cambios al repositorio remoto

El siguiente comando mostrará todos los cambios que se han realizado en los archivos.

git diff

Si ingresamos al estado de git nuevamente, podemos ver que los cambios han sido rastreados y que simple.py ha sido modificado.

Ahora agrégalos al área de preparación

git add -A

Ejecuta git status nuevamente

Ahora podemos ver que simple.py está listo para ser comprometido.

Luego ingrese el comando de confirmación con un mensaje

git commit -m “Updated hello function”

Ahora tenemos que enviar los cambios confirmados al repositorio remoto para que otras personas tengan acceso a ellos.

Dado que el caso común es que hay varios desarrolladores trabajando en un solo proyecto, primero tenemos que extraer cualquier cambio que se haya realizado en el repositorio remoto antes de enviar nuestros cambios para evitar conflictos.

Ejecute el siguiente comando:

git pull origin master

Como ya estamos actualizados, ahora podemos enviar nuestros cambios al repositorio remoto.

Ahora ejecuta lo siguiente:

git push origin master

¡Hemos enviado con éxito nuestros cambios a la rama maestra del repositorio remoto!

Crear una rama para una característica o problema

Hasta ahora hemos estado trabajando en nuestra rama maestra, pero no es así como deberías trabajar en git como desarrollador porque la rama maestra debe ser una versión estable del proyecto en el que estás trabajando. Entonces, para cada característica o problema, generalmente es la norma crear su propia rama y luego trabajar fuera de esa rama.

El comando para crear una nueva rama llamada simple-greeting es el siguiente:

git branch simple-greeting

Ahora si corres

git branch

luego verá todas las ramas en el repositorio, y la rama actual en la que se encuentra se resaltará con un asterisco en el lado izquierdo.

Si desea cambiar a la rama que acaba de crear, escriba lo siguiente:

git checkout simple-greeting

Ahora, si escribe git branch, verá que ahora está en la rama de saludo simple.

Ahora tenemos que hacer los cambios en el proyecto. Cambiaremos al proyecto y definiremos la función de saludo.

Ahora repetiremos el proceso de realizar estos cambios:

git status
git add -A
git commit -m “Greeting Function”

Esta confirmación solo cambiará los archivos en la rama local simple-greeting y todavía no ha tenido ningún efecto en la rama maestra local o en el repositorio remoto.

Empujar la rama al repositorio remoto después de confirmar

Ingrese el siguiente comando:

git push -u origin simple-greeting

donde origin es el nombre del repositorio y simple-greeting es la rama a la que queremos enviar.

Ahora hemos enviado la rama de saludo simple al repositorio remoto. Si escribe:

git branch -a

Podemos ver que, en nuestro repositorio remoto, ahora tenemos la rama de saludo simple. ¿Por qué necesitamos enviar la rama al repositorio remoto? Porque en algunas empresas es donde ejecutan sus pruebas unitarias y varias otras para asegurarse de que el código se ejecute bien antes de fusionarse con la rama maestra.

Dado que todas las pruebas han salido bien (no entraremos en detalles aquí), ahora podemos fusionar el saludo simple de la rama con la rama maestra.

Fusionando una rama

Primero, tenemos que pagar en la rama maestra local

git checkout master

Extraiga todos los cambios en la rama maestra remota:

git pull origin master

Ahora veremos las ramas en las que nos hemos fusionado hasta ahora:

git branch —-merged

La rama de saludo simple no aparecerá aquí porque aún no la hemos combinado.

Para fusionar el saludo simple con el maestro, ingrese:

git merge simple-greeting

(Tenga en cuenta que estamos en la rama maestra en este momento)

Ahora que se ha fusionado, podemos enviar los cambios a la rama maestra del repositorio remoto.

git push origin master

Ahora los cambios se han enviado a la rama maestra en el repositorio remoto.

Eliminar una rama

Dado que la función ya se ha implementado, podemos eliminar la rama de saludo simple. Para verificar la combinación realizada en la sección anterior, podemos ejecutar:

git branch --merged

Si aparece un saludo simple aquí, significa que hemos fusionado todos los cambios y que la rama ahora se puede descartar.

git branch -d simple-greeting

Ahora la rama se ha eliminado localmente.

Pero como empujamos la rama al repositorio remoto, todavía está allí en el repositorio remoto. Esto se puede ver ejecutando:

git branch -a

Para eliminar la rama del repositorio remoto, ingrese:

git push origin --delete simple-greeting

Si volvemos a correr

git branch -a

podemos ver que la rama ahora también se ha eliminado del repositorio remoto.

¡¡¡Felicidades!!! ¡Ahora eres un maestro en los comandos básicos pero críticos de Git!

Para referencia o uso de este tutorial, aquí está el enlace del repositorio público de GitHub

Mientras tanto, dé tantas palmadas como desee a este artículo si le gustó, comente abajo para cualquier inquietud. ¡También por favor revise mi perfil en LinkedIn y síganme en Twitter!