GIT
[Link]
[Link]
git-cheat-sheet-education
Introducción
Aprender a gestionar versiones en proyectos de software es fundamental para evitar el
caos de múltiples archivos llamados “versión final” y mejorar la colaboración en equipo.
Git, un sistema de control de versiones, permite a los desarrolladores trabajar de manera
ordenada, manteniendo solo los cambios realizados en los archivos y simplificando el
trabajo en equipo al coordinar y sincronizar las modificaciones.
¿Qué es Git?
Git es la herramienta de control de versiones más utilizada por programadores. Su función
es clara: gestiona versiones de archivos de forma eficaz, algo vital en proyectos
colaborativos. Sin Git, los desarrolladores enfrentaban problemas de organización y
errores en la sincronización manual de archivos, un proceso que era tan lento como
propenso a fallos.
¿Quién creó Git y por qué es tan relevante?
El creador de Git es Linus Torvalds, el mismo desarrollador detrás del núcleo de Linux,
quien creó esta herramienta para resolver sus propias necesidades de control de
versiones. Además, Git es open source, lo que permite a cualquier persona contribuir a su
mejora constante, garantizando que siga siendo una herramienta poderosa y en
evolución.
¿Cómo te beneficia aprender Git desde el inicio?
Desde que comienzas a programar, aprender Git te brinda una ventaja profesional. Esta
herramienta te permitirá organizar tu código, colaborar con otros desarrolladores y,
eventualmente, contribuir a proyectos externos. En el desarrollo de software, los
productos suelen ser el resultado del esfuerzo de un equipo, y Git se vuelve esencial para
gestionar el trabajo de manera efectiva.
¿Cómo funciona Git en tu entorno de trabajo?
Git se usa en la terminal o en editores como Visual Studio Code, utilizando comandos
clave como commit, pull, push, merge, entre otros. Para colaborar en proyectos con otros
desarrolladores, se usa una plataforma en la nube como GitHub. Allí puedes almacenar tu
código, gestionar versiones y acceder a funcionalidades adicionales que aumentan la
productividad y facilitan la colaboración.
Trabajar con Git en la terminal permite a los desarrolladores gestionar sus proyectos de
manera eficiente. A continuación, revisamos cómo instalar, configurar y utilizar Git en
Linux, Mac y WSL de Windows, junto con algunas recomendaciones prácticas para
dominar los comandos iniciales de esta herramienta.
¿Cómo confirmar que Git está instalado en tu sistema?
Para verificar la instalación de Git:
[Link] la terminal y escribe el comando: git --version.
[Link] el comando devuelve un número de versión, Git está listo para usarse.
[Link] no aparece la versión, revisa la documentación necesaria para las instalaciones en
cada sistema operativo. [Link]
¿Cómo crear y preparar el primer proyecto con Git?
El primer paso para crear un proyecto en Git es:
[Link] la terminal para evitar confusión visual.
[Link] una carpeta para el proyecto con mkdir nombre_del_proyecto.
[Link] a la carpeta con cd nombre_del_proyecto.
¿Cómo inicializar un repositorio en Git?
Al estar dentro de la carpeta de tu proyecto, inicia el repositorio con:
git init : Esto crea la rama inicial “master” por defecto.
Si prefieres la rama principal como “main”:
[Link] la configuración global escribiendo git config --global [Link]
Branch main
[Link] la rama en el proyecto actual con git branch -m main
¿Cómo personalizar tu configuración de usuario en Git?
Configura el nombre de usuario y correo electrónico de Git, que identificará todas tus
contribuciones:
[Link] git config --global [Link] "Tu Nombre o Apodo"
[Link] el correo electrónico con git config --global [Link]
"[Link]@[Link]"
Tip: Si necesitas corregir algún error en el comando, puedes usar la tecla de flecha hacia
arriba para recuperar y editar el último comando escrito.
¿Cómo confirmar la configuración de Git?
Para revisar tu configuración, ejecuta: git config –list : Aquí verás los datos de
usuario y el nombre de la rama principal.
Esta configuración se aplicará a todos los repositorios que crees en adelante.
¿Qué hacer si olvidas un comando?
Git incluye un recurso rápido y útil para recordar la sintaxis de comandos:
[Link] git help en la terminal.
[Link] la lista de comandos disponibles y consulta la documentación oficial de cada
uno cuando sea necesario.
¿Cómo inicia el control de versiones con Git?
El primer paso es iniciar un repositorio con el comando git init, que crea una carpeta
oculta llamada .git en el directorio de trabajo. Esta carpeta actúa como una bitácora,
almacenando cada cambio y movimiento de los archivos que se manejan en el proyecto.
¿Cómo se crean y agregan archivos a Git?
Para crear un archivo desde la terminal, utiliza un editor (o cat para crear un documento
ràpido desde la terminal). Una vez creado, puedes verificar su existencia y estado con
git status, que te mostrará el archivo como no registrado. Para incluirlo en el área de
staging, donde estará listo para el commit, usa git add nombre_del_archivo.txt.
Esta área de staging es un “limbo” donde decides qué archivos entrarán en el control de
versiones.
•Ejemplo de comandos:
cat > [Link]
Mensaje de prueba escrito en el documento: [Link]
git add [Link] para agregarlo al área de staging.
¿Qué es el área de staging y cómo funciona?
El área de staging permite revisar los cambios antes de que se registren oficialmente en el
repositorio. Los archivos en staging aún no forman parte del historial de versiones; están
en espera de que se realice un commit o de ser devueltos a su estado original con git
rm --cached nombre_del_archivo.txt
¿Cómo realizar el commit de los archivos en Git?
Una vez en staging, se ejecuta git commit -m "mensaje descriptivo" para
registrar los cambios en el repositorio. El mensaje en el commit es crucial porque indica la
acción realizada, como “nuevo archivo de testing”. Este mensaje permite identificar los
cambios de forma clara y ordenada en el historial del proyecto.
•Ejemplo de commit:
git commit -m "nuevo archivo de testing"
¿Cómo gestionar múltiples archivos en Git?
Para trabajar con varios archivos a la vez, utiliza git add . que agrega todos los
archivos sin registrar en el área de staging. Puedes decidir entre realizar commits
individuales o múltiples en función de la cantidad de archivos y los cambios realizados en
cada uno.
¿Cómo visualizar el historial de cambios en Git?
El comando git log muestra el historial de commits, proporcionando una vista completa
de cada cambio realizado en el proyecto. Esta bitácora permite ver el estado de cada
archivo y la información de cada commit.
¿Qué sucede al modificar un archivo en Git?
Cuando un archivo se edita, Git lo detecta como “modificado”. El flujo de trabajo para
registrar este cambio es el mismo que para un archivo nuevo: git add para llevarlo a
staging y git commit para guardar la modificación. Esto asegura que Git mantenga un
registro detallado de cada cambio, actualización o eliminación en el proyecto.
¿Cómo maneja Git diferentes tipos de archivos?
Git trata cualquier archivo de igual manera, sin importar su extensión o tipo, ya sea de
texto, código o imagen. Con git add y git commit, cualquier cambio en estos
archivos se registra, facilitando el control de versiones sin importar el tipo de contenido.
Ramas
El uso de ramas en Git permite trabajar en un entorno aislado sin interferir con otros,
facilitando la organización y el control del proyecto. Aprender a crear, gestionar y fusionar
ramas optimiza la colaboración y ayuda a mantener la limpieza en el historial de cambios.
¿Por qué son útiles las ramas en Git?
Las ramas son una herramienta que permite trabajar en tareas específicas sin alterar la
rama principal. Entre sus ventajas se encuentran:
• Aislamiento de cambios individuales.
• Posibilidad de desechar una rama sin afectar la principal.
• Organización de actividades múltiples en diferentes ramas.
¿Cómo verificar la rama actual?
Para saber en qué rama estás trabajando, ejecuta:
git branch
El asterisco (*) indica la rama activa. Inicialmente, suele ser main, pero al crear más
ramas, la lista crecerá, permitiéndote ver todas las disponibles y cuál es la actual.
¿Cómo crear una nueva rama en Git?
La creación de ramas permite desarrollar sin riesgo en paralelo. Para crear y moverte a
una nueva rama, usa:
git checkout -b
Por ejemplo, git checkout -b Rama1 crear y mover a la rama Rama1. Puedes
verificar que estás en esta rama ejecutando git branch.
¿Cómo agregar y confirmar cambios en una rama?
Dentro de una nueva rama, los archivos se editan y confirman sin que impacten otras
ramas. Sigue estos pasos para agregar y confirmar:
1. Crea o edita un archivo.
2. Añádelo con:
git add .
3. Confirma el cambio:
git commit -m "mensaje de confirmación"
Los cambios ahora son parte de la rama en la que trabajas y no afectan la principal.
¿Cómo fusionar cambios de una rama secundaria a la principal?
Para unificar el trabajo en la rama principal:
1. Cambia a la rama principal:
git switch main git checkout main
Nota: Puedes usar también git checkout main.
2. Fusiona la rama secundaria:
git merge
Git indicará que el proceso fue exitoso y actualizará el contenido en la rama main con los
cambios de la rama secundaria.
¿Por qué es importante eliminar ramas que ya no se usan?
Una vez fusionada una rama, es buena práctica eliminarla para evitar desorden. Hazlo
con:
git branch -d Rama1
Eliminar ramas que ya cumplieron su propósito previene conflictos y mantiene el entorno
de trabajo limpio y organizado.
Los comandos como git reset y git revert se vuelven herramientas
indispensables, ya que permiten deshacer errores y ajustar el historial de cambios sin
complicaciones.
¿Cuál es la diferencia entre Git Reset y Git Revert?
•Git Reset: mueve el puntero de los commits a uno anterior, permitiendo “volver en el
tiempo” y explorar el historial de cambios. Es útil para deshacer actualizaciones recientes
o revisar lo que se hizo en cada commit.
•Git Revert: crea un nuevo commit que revierte los cambios de un commit específico,
permitiendo conservar el historial original sin eliminaciones. Es ideal para regresar a un
estado anterior sin afectar los commits de otros usuarios.
¿Cómo se utiliza Git Reset?
[Link] git log para identificar el historial de commits. El commit actual se marca con
HEAD apuntando a main.
2. Si quieres eliminar cambios recientes:
• Crea un archivo temporal (ejemplo: [Link]) y realiza un commit.
• Verifica el historial con git log y localiza el hash del commit que deseas restablecer.
3. Para revertir a un estado anterior:
•Usa git reset con parámetros:
--soft: solo elimina el archivo del área de staging.
--mixed: remueve los archivos de staging, manteniendo el historial de commits.
--hard: elimina los archivos y el historial hasta el commit seleccionado.
•Este último parámetro debe ser una última opción debido a su impacto irreversible en el
historial.
¿Cómo funciona Git Revert?
[Link]ón del commit: usa git log para encontrar el commit a revertir.
[Link] git revert seguido del hash del commit: crea un nuevo commit inverso,
preservando el historial.
[Link] el mensaje de commit: permite dejar claro el motivo de la reversión, ideal en
equipos colaborativos para mantener claridad.
¿Cuándo es recomendable utilizar Git Reset o Git Revert?
Ambos comandos resultan útiles en diversas situaciones:
•Corrección de errores: si has subido un archivo incorrecto, git revert es rápido y
seguro para deshacer el cambio sin afectar el historial.
•Limpieza del historial: en proyectos sólidos, puede que quieras simplificar el historial
de commits; git reset ayuda a limpiar entradas innecesarias.
•Manejo de conflictos: en casos extremos de conflicto de archivos, git reset es útil,
aunque puede ser mejor optar por resolver conflictos manualmente.
¿Cómo aseguras una correcta comunicación en el uso de estos comandos?
•Utiliza estos comandos en sincronización con el equipo.
•Evita el uso de git reset --hard sin coordinación para prevenir la pérdida de trabajo
ajeno.
•Documenta cada reversión con un mensaje claro para asegurar el seguimiento de
cambios.
Gestión de versiones con tag y checkout
Git facilita el control de versiones y organización de proyectos, y los comandos git tag
y git checkout son piezas clave para una gestión eficiente y ordenada de los cambios
en el código. Ambos comandos ayudan a crear puntos de referencia y explorar cambios
sin afectar el desarrollo principal, ofreciendo opciones robustas para pruebas y
organización.
¿Cómo se utiliza git tag para organizar versiones?
El comando git tag permite marcar un commit con una etiqueta descriptiva, ideal para
señalar versiones estables o hitos importantes en el proyecto. Esto resulta útil en
proyectos donde el equipo necesita identificar fácilmente puntos clave de avance. Al
etiquetar, se añade una nota visible en el historial, lo cual facilita encontrar versiones
específicas en un flujo de trabajo con muchos commits.
Para crear un tag:
•Escribe git tag -a v1.0 -m "primera versión estable" y presiona Enter.
•Al consultar git log, se verá el tag junto al commit en el historial.
Además, git show muestra detalles de la etiqueta, quién la creó, el mensaje de la
versión y los cambios asociados a ese commit. Esto es especialmente útil cuando el
historial es extenso, ya que permite regresar a puntos específicos sin necesidad de
revisar cada commit en el log completo.
Para eliminar un tag:
•Usa git tag -d v1.0 para remover el tag sin afectar el historial ni los archivos. Esto
es conveniente si el nombre del tag necesita ser corregido o ajustado.
¿Qué permite git checkout al explorar el historial?
El comando git checkout tiene usos más amplios que solo cambiar entre ramas.
También permite revisar commits previos para explorar o probar cambios sin alterar la
rama principal. Al usar git checkout, puedes regresar a un punto específico en el
historial y evaluar cómo afectaban los cambios al proyecto en ese momento.
Por ejemplo:
[Link] a un commit específico con git checkout.
[Link] pruebas o modificaciones. Esto te permite simular cambios o ver el estado del
proyecto en esa versión.
[Link] regresar a la rama principal, escribe git checkout main. Esto restaura el
proyecto al estado actual y evita que los cambios temporales afecten el historial o la
estructura del proyecto.
Al navegar entre commits y regresar a main, es importante notar que no se crean ramas
adicionales, ni se modifican commits previos, lo cual asegura la integridad del historial y la
rama principal.
¿Cómo integran git tag y git checkout una experiencia de desarrollo
ordenada?
Ambos comandos permiten explorar y organizar sin interferir en el flujo principal del
trabajo. Git tag marca versiones y puntos importantes, actuando como separadores en
el historial, mientras que git checkout permite regresar a esos puntos y probar sin
comprometer la rama actual. Esto proporciona una estructura en la que el equipo puede
trabajar con libertad para realizar pruebas, versionar cambios y retornar al estado actual
en cualquier momento sin temor a alterar el trabajo original.