Ahora que sabes qué es Git y cómo encaja GitHub en el panorama, estás listo para aprender el flujo de trabajo básico de Git.

En este tutorial, aprenderás lo más básico de lo que debes hacer para seguir tus proyectos usando Git y GitHub. Hay mucho que se puede decir sobre el por qué, cómo y qué significa cada parte. Es demasiado para cubrir en un solo tutorial para principiantes, así que, si hay una sección que no entiendes y realmente quieres saber más, la mejor opción es buscarlo en Google. Googlear es una habilidad (sí, en serio) y necesitarás usarla día tras día si trabajas como desarrollador. ¡No tengas miedo de usarla!

Por ahora, quiero que intentes leer todo el post antes de profundizar en los detalles: a veces, es mejor obtener una visión general primero, porque profundizar demasiado pronto puede ser una receta para la confusión y la frustración.

Dividiremos este post en tres secciones: empezar con Git, conectar un proyecto a GitHub y luego el flujo de trabajo diario de Git/GitHub.

1. ¿Cómo empiezo a seguir mi proyecto con Git?

Aquí tienes una visión general básica de cómo trabajamos en proyectos usando Git. Vamos a asumir que ya tienes Git instalado en tu computadora y estás en la Terminal.

Creamos una carpeta de proyecto local en nuestra computadora y entramos en ella:

$ mkdir CarpetaDeProyecto
$ cd CarpetaDeProyecto

Iniciamos el seguimiento de Git en esa carpeta:

$ git init

Creamos nuestro archivo README.md con algo de texto de relleno:

$ echo Mi Nuevo Proyecto > README.md

Añadimos el contenido de nuestra carpeta al área de preparación, diciéndole a Git que estos son los archivos de los que queremos seguir los cambios:

$ git add .

Confirmamos nuestros archivos a Git, junto con un mensaje en tiempo presente explicando el cambio:

$ git commit -m "Añadir README.md"

El punto 4 necesita un poco de explicación: en Git, antes de "guardar cambios", añadimos archivos al "área de preparación" usando git add nombrearchivo.txt. Esto es en caso de que tengamos archivos específicos que hayamos cambiado, pero no queramos guardar. En el caso anterior (y en la mayoría de los casos), no necesitaremos ser tan específicos, así que simplemente podemos añadir todos los archivos en nuestro directorio actual. Si vas a buscar algo en Google hoy, ¡busca "Git Staging Area"!

El punto 5 es donde esencialmente presionamos "Guardar Como" en el proyecto. Le decimos a Git que mantenga una copia del proyecto exactamente como está ahora. De esta manera, si en el futuro algo sale mal, siempre podemos volver y ver versiones anteriores de cada archivo en nuestro directorio.

También podemos combinar los pasos 4 y 5, preparando y cometiendo todos los archivos a la vez usando la opción -am, por ejemplo:

$ git commit -am "Añadir README.md"

2. ¿Cómo conecto Git y GitHub?

Ahora tenemos un directorio de trabajo para nuestro proyecto, y Git está siguiendo todos los cambios que hacemos, pero aún no tenemos un repositorio remoto (en línea) donde podamos guardar todo. GitHub es la plataforma líder para almacenar y acceder a proyectos seguidos con Git, así que necesitarás ir allí y crear una cuenta antes de continuar.

Ahora que tenemos una cuenta de GitHub, estamos listos para crear un nuevo repositorio y vincularlo a nuestra carpeta local:

Conectando un repositorio existente en tu computadora a GitHub

Actualmente tenemos un repositorio local y queremos añadirlo a un repositorio vacío de GitHub. La dirección de la conexión es de local a remoto. Por lo tanto, usaremos git remote add origin como nuestro método de conexión.

1. Crea un nuevo repositorio en GitHub: haz clic en el botón verde en el menú de la izquierda, o haz clic en el signo más en la parte superior derecha y luego en "Nuevo Repositorio".

2. Ingresa el nombre de nuestro nuevo repositorio, idealmente similar o idéntico al nombre de nuestro repositorio local o lo más parecido posible para que no los confundamos en el futuro. Mantenlo público y haz clic en el botón verde "Crear Repositorio".

3. Ahora tenemos un repositorio remoto (¡hurra!), pero aún no hay nada en él, y no se ha establecido ningún enlace. Después de crear nuestro repositorio de GitHub, seremos llevados a una página con el enlace que necesitamos para Git. Toma el enlace SSH, cópialo y luego pégalo en la Terminal como en el ejemplo a continuación. Asegúrate de haber usado cd para entrar en la carpeta del proyecto correcta primero:
   

$ git remote add origin git@github.com:TuUsuario/MiNuevoProyecto.git

Nuestro repositorio local de Git ahora está vinculado a nuestro repositorio remoto (en línea) vacío de GitHub, pero aún necesitamos "empujar" (el término técnico para subir) nuestros archivos/cambios/historial a GitHub. Para hacerlo, escribimos:

$ git push -u origin main

Si actualizamos nuestra página de repositorio en GitHub, ahora deberíamos ver nuestro README.md junto con el texto de relleno que pusimos en él al principio.

Conectando un repositorio de GitHub a una carpeta local

Digamos que has hecho lo anterior en tu PC de casa, pero es un día hermoso y quieres ir a un café a trabajar en tu laptop en su lugar. En tu laptop, no tienes ninguno de los archivos de tu repositorio, pero sí tienes acceso a wifi (¡uf!).

Para copiar tu repositorio remoto (GitHub) a tu computadora, vamos a usar el comando git clone, proporcionándonos una copia exacta (¡clon!) de todos tus archivos y tu historial de commits de Git.

1. Ve a tu perfil de GitHub y haz clic en el repositorio que deseas clonar.

2. En la parte superior derecha, verás un botón verde. Hacer clic en ese botón mostrará una URL que puedes copiar.

3. En la Terminal, navega al directorio donde quieres almacenar el proyecto (ten en cuenta que clone creará una nueva carpeta para ti con el nombre del repositorio de GitHub, así que no necesitas crear una carpeta dedicada tú mismo). Digamos que queremos almacenarlo en nuestro Directorio de Inicio:
   

$ cd

Ahora usaremos la URL que copiamos para clonar el repositorio, por ejemplo:

$ git clone git@github.com:TuUsuario/MiNuevoProyecto.git

¡Felicidades! Ahora tienes una conexión entre Git y GitHub, y todos tus archivos están actualizados en ambos lugares. Ahora quieres empezar a construir tu proyecto y seguir los cambios...

3. Flujo de trabajo diario: pull, branch, add, commit, merge, push

El título anterior es el flujo de trabajo básico que necesitarás día tras día cuando trabajes entre Git y GitHub.

Dado que este post solo está dirigido a proyectos personales y no colaborativos, hay un argumento para ignorar el lado del "pull" (término técnico de Git para descargar) de esta relación, pero es un buen hábito adquirirlo, así que lo incluiré. Lo mismo aplica para las ramas: suponiendo que solo una persona está trabajando en nuestro proyecto, podríamos trabajar siempre en la rama principal (main), pero como queremos formar buenos hábitos a largo plazo, comencemos a ramificarnos desde hoy.

Antes de seguir cualquiera de los pasos siguientes, asegúrate de haber navegado a la carpeta de tu proyecto.

• Haz un pull (es decir, descarga) de cualquier cambio que pueda haber ocurrido en el repositorio remoto (GitHub). De esta manera, si alguien más ha trabajado en el proyecto (o si lo hemos actualizado desde otra computadora), recibimos todos los cambios y nos mantenemos actualizados.

$ git pull

• Crea una nueva rama: piensa en esto como un espacio de trabajo separado donde puedes probar y experimentar sin "arruinar" los archivos principales. En un espacio profesional, la ramificación se usaría para que diferentes miembros del equipo puedan trabajar en diferentes problemas al mismo tiempo. Eso no se aplica a nosotros, pero vamos a construir esos hábitos ahora para ahorrarnos algo de dolor más tarde. Así que comencemos a trabajar en una nueva rama llamada "MisCambios":

$ git checkout -b MisCambios

• Añade, elimina o edita archivos y directorios a tu gusto. ¡Aquí es donde realmente ocurre la mayor parte de la codificación para nuestro proyecto!

• Una vez que hayamos hecho algunos cambios y queramos guardarlos más permanentemente, ahora los añadiremos y cometeremos juntos en Git, con un mensaje cubriendo lo que cambiamos.
  

$ git commit -am "Añadir index.html y style.css"

Podemos (y deberíamos) repetir los pasos 3 y 4 múltiples veces mientras hacemos más y más cambios. Cuanto más confirmamos los cambios, más opciones tendremos para revertir cualquier cambio más tarde. Sin embargo, usualmente no querrás guardar cada pequeño cambio que hagas (aunque hay programadores que lo hacen).

¡Uf! Hemos pasado todo el día codificando en nuestra rama MisCambios y nuestros archivos se ven geniales. Pero antes de ir a casa, necesitamos asegurarnos de que nuestra rama principal esté actualizada con nuestro trabajo del día. Vamos a pasarnos a la rama principal (main), fusionarla toda y luego eliminar la rama que ahora es redundante:

$ git checkout main
$ git merge MisCambios
$ git branch -d MisCambios

Nuestro paso final es asegurarnos de que todos los cambios también se añadan a GitHub, por si necesitamos acceder a ellos en otro lugar, que alguien más vea nuestro código o nuestra computadora principal muera. Así que ahora empujamos (¡subimos!) todo a nuestro repositorio remoto (GitHub):

$ git push

¡Genial! ¡El día ha terminado! Todos nuestros cambios están actualizados y guardados en la nube, junto con cada versión del proyecto que hemos tenido. Podemos acceder a él desde cualquier lugar, nuestros amigos pueden acceder a él desde cualquier lugar, y si queremos, podemos dejar que otros trabajen en él con nosotros.

¿Eso fue mucha información? ¿Puedo ver todo en un solo lugar solo con los comandos?

¡Claro! Aquí tienes:

Crear carpeta de proyecto local

$ mkdir CarpetaDeProyecto
$ cd CarpetaDeProyecto
$ git init
$ echo Mi Nuevo Proyecto > README.md
$ git add .
$ git commit -m "Primer commit con README.md"

Conectar local a un repositorio vacío de GitHub

$ git remote add origin git@github.com:TuUsuario/MiNuevoProyecto.git
$ git push -u origin main

Traer tu repositorio de GitHub a una computadora diferente, por ejemplo

$ git clone git@github.com:TuUsuario/MiNuevoProyecto.git

Flujo de trabajo diario

$ cd NombreDeCarpetaDeProyecto
$ git pull
$ git checkout -b MisCambios
<<Trabaja en tu código aquí>>
$ git commit -am "Describe los cambios aquí"
$ git checkout main
$ git merge MisCambios
$ git branch -d MisCambios
$ git push

Conclusión

Sé que fue mucha información, pero esos son los comandos básicos que necesitas. Recuerda que las primeras y segundas secciones son puramente sobre la configuración del proyecto: día a día, todo lo que necesitarás son esos comandos en la sección de flujo de trabajo diario.

Como se dijo, podrías profundizar en temas relacionados con cualquier parte de este post, pero si eres nuevo en Git y GitHub, estos son los pasos que puedes seguir para comenzar a rastrear los cambios de un nuevo proyecto HOY. Espero que este tutorial haya sido de ayuda para ti.