País o región e idioma

    Elige tu país o región y tu idioma.

    Sugerido para ti

      Todos los países y regiones

        Elige tu personaje

        Aparece en la barra superior y en tu perfil. Puedes cambiarlo cuando quieras.

        Git: comandos básicos paso a paso

        Practica los comandos básicos de Git con dos archivos: prepara cambios, crea commits y verifica qué versión queda guardada y cuál sigue fuera del historial local.

        Una persona practica con un equipo portátil en un espacio de trabajo tranquilo

        Puedes practicar los comandos básicos de Git para crear un repositorio, revisar archivos, preparar cambios y guardar un commit, que registra el contenido seleccionado. En este ejercicio local trabajarás con dos archivos y comprobarás una distinción fundamental: editar un archivo después de prepararlo no cambia automáticamente lo que guardará el próximo commit.

        El flujo mínimo de trabajo

        El flujo mínimo consiste en editar, preparar, comprobar y guardar. Git mantiene separados los archivos que tienes delante y el contenido seleccionado para el siguiente registro; entender esa separación evita guardar versiones distintas de las que pretendías.

        • Repositorio: el historial y la información de seguimiento que gestiona Git para un proyecto.
        • Directorio de trabajo: los archivos que puedes abrir y modificar, como una tarea o un documento de notas.
        • Área de preparación: el contenido seleccionado para el próximo commit. También se conoce como índice.
        • Commit: un registro del contenido preparado, acompañado de información como la autoría y un mensaje.

        El ejemplo utiliza Git 2.28 o posterior y una terminal Bash, disponible en Linux, macOS y Git Bash para Windows. Necesitas Git instalado, pero no una cuenta en un servicio de alojamiento ni una conexión con un repositorio remoto. Ejecuta el ejercicio en Bash, no directamente en PowerShell, porque las instrucciones para escribir los archivos corresponden a Bash.

        Un repositorio con dos archivos

        Crearás un repositorio con una tarea y unas notas ficticias, pero guardarás únicamente la tarea. Después cambiarás la tarea dos veces para demostrar que Git registra la versión preparada, no necesariamente la última versión visible en el archivo.

        Abre la terminal en una carpeta donde puedas crear un directorio nuevo llamado git-taller-local. Si ese directorio ya existe, cambia su nombre en las dos primeras instrucciones ejecutables antes de empezar. No reutilices una carpeta con trabajo real ni introduzcas información privada.

        Si prefieres acompañar el ejercicio con práctica adicional, puedes utilizar el curso de Git de The Work Gym.

        Ejecuta el bloque en orden, deteniéndote en cada comprobación para comparar la salida de tu terminal con los comentarios. El bloque conserva el objetivo, el estado inicial, los cambios exactos y los resultados esperados del ejercicio completo.

        # Ejercicio ficticio completo.
        # Objetivo: guardar tareas.txt sin incluir notas.txt y comprobar
        # que el segundo commit guarda la versión preparada: en curso.
        # Estado inicial: git-taller-local todavía no existe.
        # Archivos iniciales: tareas.txt contiene pendiente;
        # notas.txt contiene nota privada de prueba, sin datos reales.
        # Modelo: editar cambia el archivo; preparar copia su contenido
        # al área de preparación; confirmar guarda ese contenido preparado.
        
        mkdir git-taller-local
        cd git-taller-local
        git init -q -b practica
        git config user.name "Persona de prueba"
        git config user.email "[email protected]"
        printf 'pendiente\n' > tareas.txt
        printf 'nota privada de prueba\n' > notas.txt
        
        # Preparar solo tareas.txt y comprobar la selección.
        git add tareas.txt
        git status --short
        # Salida esperada:
        # A  tareas.txt
        # ?? notas.txt
        
        # Guardar el primer registro y comprobar su contenido.
        git commit -qm "Guarda la tarea inicial"
        git show HEAD:tareas.txt
        # Salida esperada: pendiente
        git status --short
        # Salida esperada: ?? notas.txt
        
        # Variación: sustituir tareas.txt por en curso y prepararlo.
        printf 'en curso\n' > tareas.txt
        git add tareas.txt
        # Volver a sustituir tareas.txt, ahora por completado,
        # sin preparar esta última edición.
        printf 'completado\n' > tareas.txt
        
        # Comprobar la versión preparada y la versión del archivo.
        git show :tareas.txt
        # Salida esperada: en curso
        cat tareas.txt
        # Salida esperada: completado
        
        # Guardar la versión preparada y comprobar ambas versiones.
        git commit -qm "Registra la tarea en curso"
        git show HEAD:tareas.txt
        # Salida esperada: en curso
        cat tareas.txt
        # Salida esperada: completado
        git status --short
        # Salida esperada:
        #  M tareas.txt
        # ?? notas.txt

        La inicialización crea el repositorio y una rama llamada practica. Una rama permite mantener una línea de trabajo dentro del historial; en este recorrido no necesitas crear ninguna más. La configuración de nombre y correo afecta únicamente a este repositorio, identifica la autoría de los commits y no inicia sesión en ningún servicio.

        Las instrucciones de escritura sustituyen el contenido de cada archivo; no añaden una línea al final. Los comentarios que empiezan con el símbolo de almohadilla no se ejecutan. Las opciones silenciosas de inicialización y confirmación reducen los mensajes informativos para que puedas concentrarte en las comprobaciones.

        Practica lo que enseña este artículo

        La selección antes del registro

        El primer commit incluye únicamente tareas.txt porque preparaste ese archivo por su nombre. Que notas.txt esté en la misma carpeta no basta para incorporarlo: Git distingue entre los archivos presentes y los archivos seleccionados.

        La primera salida abreviada muestra una A en la primera columna junto a tareas.txt. Esa letra indica una incorporación preparada. Los dos signos de interrogación junto a notas.txt indican que es un archivo sin seguimiento: Git lo detecta, pero todavía no lo has incorporado al contenido que registra.

        • La primera columna compara el área de preparación con el commit actual.
        • La segunda columna compara los archivos del directorio de trabajo con el área de preparación.
        • Un espacio significa que no hay diferencias en esa comparación; no lo ignores al leer la salida.
        • Los dos signos de interrogación identifican un archivo sin seguimiento, no dos modificaciones distintas.

        Después del primer commit, la lectura de tareas.txt desde HEAD devuelve «pendiente». HEAD identifica aquí el commit actual. Consultar el archivo dentro del commit comprueba lo que quedó guardado; leer solo el mensaje del commit no ofrece esa garantía, porque el mensaje lo escribes tú.

        El estado posterior sigue mostrando las notas como archivo sin seguimiento. Por tanto, el primer registro cumple las dos condiciones del objetivo: conserva la tarea inicial y deja fuera las notas.

        Dos versiones de una misma tarea

        La variación deja una versión de tareas.txt preparada y otra diferente en el directorio de trabajo. La separación se produce en el momento en que sustituyes «en curso» por «completado» después de preparar el archivo.

        Respeta el orden del bloque: primero escribe «en curso» en tareas.txt y prepara ese contenido; después escribe «completado» en el mismo archivo sin volver a prepararlo. Si preparas el archivo otra vez tras la segunda edición, habrás cambiado la selección y ya no estarás reproduciendo la misma prueba.

        Las dos comprobaciones anteriores al segundo commit consultan lugares diferentes. La primera lee tareas.txt desde el área de preparación y devuelve «en curso». La segunda lee el archivo del directorio de trabajo y devuelve «completado». No hay contradicción: son dos versiones del mismo archivo.

        Al guardar el segundo commit, Git utiliza «en curso». La lectura posterior desde HEAD confirma ese contenido, mientras que el archivo local conserva «completado». Git no descarta la última edición por el hecho de guardar una versión preparada anterior.

        En el estado final, la M aparece en la segunda columna junto a tareas.txt. La primera columna está vacía: el área de preparación coincide con el commit recién creado, pero el directorio de trabajo contiene una modificación todavía sin preparar.

        Los errores y el alcance

        Este recorrido enseña a seleccionar y comprobar contenido local, pero no cubre colaboración remota, resolución de conflictos ni recuperación de cambios descartados. Entender el área de preparación es una base para esas tareas, no un sustituto de practicarlas.

        Otro error importante es interpretar «sin seguimiento» como «protegido». Las notas permanecen fuera de estos commits porque no las has seleccionado; podrían incorporarse más adelante si preparas todos los archivos. No uses datos sensibles para probar la exclusión.

        Si obtienes «completado» al leer el segundo commit, revisa el orden de tus acciones: probablemente volviste a preparar tareas.txt después de la última edición. Si las notas aparecen en el historial, seleccionaste más archivos de los previstos. Ambos resultados se detectan comprobando el contenido, no por el texto del mensaje de confirmación.

        Para repetir el ejercicio, vuelve a una carpeta superior y elige un nombre de directorio nuevo en las dos primeras instrucciones del bloque. Antes de ejecutar cada comprobación, predice su salida. El criterio de dominio es poder explicar por qué el segundo commit contiene «en curso» mientras el archivo local contiene «completado».

        Preguntas frecuentes

        ¿Qué diferencia hay entre preparar un archivo y guardar un commit? Preparar selecciona el contenido que tendrá el próximo commit; guardar el commit incorpora ese contenido al historial. Las ediciones posteriores a la preparación quedan fuera de ese registro salvo que vuelvas a prepararlas.

        ¿Por qué mi último cambio no aparece en el commit? Una causa habitual es haber editado el archivo después de prepararlo. Compara el contenido preparado con el archivo local, como en el ejercicio, para comprobar si seleccionaste una versión anterior.

        ¿Necesito una cuenta en un servicio de alojamiento para practicar Git? No: puedes crear un repositorio y guardar commits de forma local con Git instalado. El nombre y el correo configurados identifican la autoría, pero no crean una cuenta ni conectan el repositorio con un servicio.

        ¿Un archivo sin seguimiento queda excluido de todos los commits futuros? No: un archivo sin seguimiento todavía puede prepararse e incorporarse a un commit posterior. Que notas.txt quede fuera del ejercicio no significa que esté protegido frente a futuras selecciones.

        Practica lo que enseña este artículo

        Your Work Gym account

        Save your progress and pick up on another device. Your browser's progress comes with you.

        or

        You can keep practicing without an account.

        Ayuda y comentarios

        Haz una pregunta, cuéntanos qué no funciona o comparte una idea. Te respondemos por correo electrónico.

        ¿De qué se trata?

        Solo lo usamos para responderte.