Students Save 30%! Learn & create with unlimited courses & creative assets Students Save 30%! Save Now
Advertisement
  1. Code
  2. Git
Code

Control de Versión Git en la Línea de Comando para Desarrolladores iOS

by
Difficulty:IntermediateLength:LongLanguages:

Spanish (Español) translation by Rafael Chavarría (you can also view the original English article)

Nos ha pasado a todos: cambiamos algo en nuestro código, y de repente, todo parece estar "roto". Aquí es cuando el control de versiones es una bendición---si sabes cómo usarlo. En este tutorial, aprenderemos cómo usar Git desde la línea de comando.

Xcode y otros IDEs modernos tienen opciones básicas para Git integradas en sus interfaces gráficas, pero solo tienes un control de alto nivel de tu repositorio (Repositorio Git) a través de la línea de comando. Si estás haciendo codificación o administración Git avanzada, es importante estar cómodo con la línea de comando. Si nunca antes has usado la línea de comando, podrías querer revisar mi otro turorial sobre el tema:

Sobre Control de Versión

Antes de que comencemos, deberíamos revisar lo que es exactamente Control de Versión. Un Sistema de Control de Versión es una solución de software que puede guardar fácilmente revisiones de tu código y otros datos para que puedas regresar a versiones anteriores, revisar cambios que hayan sido hechos, y compartir actualizaciones con colaboradores.

Hay muchas ventajas y casos de uso para control de versión. Por ejemplo, revisando los cambios ("commits") de tu proyecto, puedes identificar quién escribió cualquier pedazo particular de código y por qué. También puedes regresar a cualquier cambio que haya sido encontrado como un error o que rompa la funcionalidad.

La versión más comunmente usada de control de versión hoy en día es Git, así que es el que estaremos viendo en este artículo. Ten en cuenta que hay otros sistemas ampliamente usados---por ejemeplo, SVN y Mercurial.

Términos y Conceptos Clave

  • repositorio o repo---contiene todo el código para un solo proyecto, junto con el historial completo de cambio de cada archivo.
  • directorio de trabajo---cuando editas tu código, estás haciendo cambios a tu directorio de trabajo. Si quieres guardar estos cambios en el repositorio, necesitarás hacer un commit. Si todos los cambios en el directorio de trabajo han sido comprometidos al repositorio, el directorio de trabajo está limpio.
  • commit---un grupo de cambios a los archivos fuente. Usualmente, estos cambios están agrupados juntos de manera que cada commit pertenece a una sola reparación de error o característica.
  • branch---el trabajo en un proyecto puede ser organizado en ramas. Esto le permite a un desarrollador o grupo de desarrolladores trabajar sobre una característica, mientras que otro desarrollador trabaja en otra característica.
  • merge---junta los cambios de dos ramas. Por lo regular, esto puede ser hecho de forma automática por Git, pero si hay algún conflicto, podrías tener que decirle a Git cómo unir los archivos.

Servicios de Administración de Repositorio

Cuando usas control de versión, creas un repositorio, o repo, y es más común almacenar este repo en un Servicio de Administración de Repositorio. Para propósitos de este tutorial, no vamos a hospedar nuestro repo en ningún lugar, para que puedas concentrarte en realmente usar control de versión. Si quieres, sin embargo, puedes leer sobre estos servicios de administración de repositorio, y deberías poder aplicar este conocimiento a estos si lo deseas.

Unos cuántos ejemplos de estos son GitHub, Bitbucket, GitLab, y Coding, y estos son ampliamente usados por desarrolladores a lo largo de todo el mundo. Yo, y muchos otros, usamos GitHub porque este hospeda una enorme cantidad de proyectos de código abierto. Los repositorios GitHub son públicos por defecto, pero puedes crear repositorios privados por una cuota mensual.

Comenzando

Creando una Aplicación

Para comenzar, necesitarás crear una nueva aplicación en Xcode. Para esta aplicación, puedes usar cualquier plantilla que quieras, y si tienes una aplicación actual que tenga un repositorio Git, puedes usarlo también para este tutorial.

Aquí está cómo debería lucir el IDE justo después de que finalmente creas tu proyecto (cuando necesitas decidir la ubicación para almacenar el proyecto):

Figure 1 Creating an Application

Asegúrate de que la caja que dice Crear repositorio Git en mi Mac está marcada, ya que esto asegurará que tu proyecto tendrá el repositorio de manera interna. Después, si eliges usar un sistema de administración de repositorio, podrás empujar todo este código, y cada commit que alguna vez hayas hecho se mostrará.

Abriendo la Terminal

Para llegar a la línea de comando, necesitarás abrir la Terminal. Puedes hacer esto de dos maneras. Puedes abrir Launchpad, y ahí puedes encontrar el icono de Terminal en la carpeta Otros sobre la primera página del Launchpad. O puedes presionar Comando-Espacio en tu teclado y buscar Terminal en Spotlight.

Una vez que abres la terminal, deberías ver algo como lo siguiente.

Figure 2 Blank Terminal Window

Esto es llamado la "línea de comando"---verás el directorio actual, después tu nombre de usuario seguido por un $.

¡Muy bien! Ahora estás listo para aprender sobre cómo usar control de versión sobre la Terminal.

Hoja de Trucos de Comandos de Terminal

Aquí están algunos de los comandos básicos que escribí en mi tutorial sobre comenzar con la Terminal. Necesitarás conocerlos para poder usar la terminal de forma efectiva.

Ayuda

  • help---como el nombre sugiere, puedes teclear este comando en la Terminal para obtener una lista de diferentes comandos.
  • man <nombre del comando>--similar al comando anterior, este comando te dice exactamente lo que hace un comando (y te da documentación completa) sin que tengas que buscar en Google.

Administración de Archivos

  • ls---lista todos los contenidos del directorio actual. Este comando resulta útil si no quieres usar el Buscador para navegar archivos---puedes simplemente listarlos usando este comando en tu Terminal.
  • cd <nombre de directorio>---este comando es usado para cambiar directorios. Si escribes solo cd, te moverás fuera del directorio actual. Después de usar ls (para ver los directorios), puedes escribir el nombre del directorio al que quieres entrar.

Cambiando Preferencias

  • defaults <ajuste a cambiar>---este comando es usado para modificar ajustes por defecto del sistema, algunos de los cuales no pueden ser cambiados sin usar la terminal.
  • caffeinate---como el nombre sugiere, este comando es usado para prevenir que tu Mac se atenúe, apague, o duerma. Para terminar esto, todo lo que tienes que hacer es presionar Control-C.

Edición de Texto

  • vim <nombre de archivo>---este es uno de mis favoritos. Puedes editar archivos de texto usando el TextEdit por defecto (o cualquier editor basado en GUI), pero vim es básicamente un editor de texto de línea de comando---esto es, funciona completamente con la terminal.

Trabajo en Red

  • ping <URL o Dirección IP>---este comando te permite revisar el tiempo de respuesta del servidor de una URL o dirección IP específica. Esto podría no ser útil para todos los desarrolladores, pero es bueno saberlo.

Admin

  • sudo <acción a realizar>---una manera de sobrescribir los privilegios de tus usuarios y volverse un super usuario de la computadora. Se te pedirá una contraseña de administrador cuando lo uses.

Diferentes Comando Git

Ahora que has visto algunos comandos básicos de terminal, aprendamos sobre las diferentes cosas que puedes hacer con Git. No los estaré cubriendo todos, pero te enseñaré sobre los principales que usarás en tu desarrollo diario. Si alguna vez necesitas más información, puedes solo ejecutar git help en tu terminal para detalles, y si eso no es suficiente, para documentación completa, puedes ejecutar man git para obtener la página de manual.

Aquí está cómo lucen las páginas de ayuda:

Figure 3 Help Page

Creando un Proyecto

  • git clone {remote-repo-link}---si quieres clonar un repositorio desde un servicio de administración de repositorios, puedes usar este comando junto con la URL para obtener una copia local en tu computadora.
  • git init---si estás creando un nuevo repositorio desde una carpeta existente, puedes usar este comando. Este iniciará la carpeta actual para que sea un nuevo repositorio. Usualmente, harías esto cuando creas un proyecto por primera vez.

Comprometiendo Cambios

  • git status---te dice qué archivos en tu directorio de trabajo han sido cambiados. Si has cambiado archivos, ¡sería tiempo de hacer commit!
  • git commit -am "{mensaje útil de commit}"---cuando has hecho algunos cambios a tu proyecto (por ejemplo, cuando has completado una característica o reparado un error), deberías comprometer tu cambio. Asegúrate de proporcionar un mensaje de commit claro y conciso, ya que esto ayudará a otros desarrolladores a entender lo que has hecho y por qué.
  • git add {nombre de archivo} o git add --all—si agregas un nuevo archivo a tu repositorio, tendrás que agregarlo a este antes de hacer un commit. Usa el comando add.

Ramas de Repositorio

  • git branch {nombre de la rama?}—con este comando, puedes listar las ramas actuales o crear una nueva.
  • git merge {nombre de rama}—fusiona la rama actual con la rama indicada. Esto combinará el código en la rama actual con la nombrada.
  • git checkout {nombre de rama}—cambia a la rama indicada. Esto simplemente hará a un lado la rama actual y hará a la otra rama activa.

Sistemas de Administración de Repositorio

  • git push—actualiza el repositorio en el sistema de administración de repositorio. Después de que has terminado de hacer cambios y estás seguro de que tu código está funcionando bien, puedes empujar tu código de manera que otros miembros puedan ver el código y jalarlo.
  • git pull—actualiza tu copia local de trabajo del repositorio para reflejas los últimos cambios que han sido empujados al sistema de administración de repositorio. Es una buena idea hacer esto antes de que hagas cualquier cambio si estás trabajando en un equipo.

Esos son algunos de los comandos principales que estarás usando en control de versiones para comenzar, pero antes de que terminemos este tutorial, echemos un vistazo a unos cuantos de estos a profundidad con el proyecto Xcode que creamos anteriormente.

Ejemplo de Usar Git Con un Proyecto Xcode

Ahora, echemos un vistazo a unos cuantos ejemplos de cómo usar la linea de comando Git con el proyecto Xcode que creamos anteriormente en este tutorial. Nota que estaremos usando los comandos de terminal de arriva, así que asegúrate de que haces referencia a estos o los memorizas.

Navegando al Directorio de Proyecto

Antes de que comencemos, necesitarás navegar al directorio de proyecto usando los comandos que están mencionados arriba(pista: usa los comandos cd y ls). Una vez que estás ahí, ejecuta ls y asegúrate de que tienes algo como esto:

Figure 4 File Navigation

¡Ta-da! Ahora estás en tu directorio de proyecto y listo para hacer cualquier cosa que necesites con tu proyecto. Simplemente sígueme mientras hacemos commit y ramas.

Commit

Comprometer tu código es lo que harás más frecuentemente en la programación. Tan pronto como hagas algún cambio, la mejor práctica es hacer commit junto con los comentarios detallados.

Haciendo un Cambio

Para comenzar, haz un cambio al proyecto Xcode. Para el mio, solo agregaré la siguiente línea de código de prueba en mi método viewDidLoad():

Obteniendo el Estado

Después de que has terminado de agregar (o substraer) una línea o dos de código, estás listo para verificar el estado de tu proyecto. Para hacer esto, pega el siguiente comando (menos el cursor $) en tu ventana de Terminal:

Verás algo como esto:

Figure 6 Modified File

El archivo que modificaste está resaltado en rojo, lo cuál te dice que tiene cambios sin comprometer.

Agregando Archivos al Área de Trabajo

Si solo quieres comprometer ciertos archivos, puedes hacerlo usando un "área de trabajo" en donde solo esos archivos serán comprometidos. Para agregar todos los archivos modificados al "área de trabajo", todo lo que necesitas hacer es ejecutar la siguiente línea de código:

La bandera -A que ves significa que todos los archivos que has modificado serán agregados (-A es para todos, y también puedes escribir git add --all).

Para ver que tus archivos ya están listos para hacer commit, simplemente ejecuta de nuevo lo siguiente:

Verás algo como esto:

Figure 7 Staging-Area File

¿Ves? El mismo archivo que era rojo ahora es verde, lo cuál indica que lo has preparado de manera exitosa para hacer commit.

Comprometiendo Tu Código

Por último, para finalmente comprometer tu código, todo lo que necesitarás hacer es ejecutar el siguiente comando en tu terminal, y entre las comillas, agregar un mensaje.

La bandera -m le dice a la Terminal que estarás agregando un mensaje a tu archivo, y es muy importante ser claro con este mensaje. Estos mensajes son cruciales para mllevar seguimiento de los cambios a tu proyecto.

Ahora, ¡has hecho tu primer commit! Estás en el camino correcto para hacer tu código más sencillo y seguro.

Ramas

La segunda cosa más común que harás como desarrollador es crear, fusionar, y usar ramas para ordenar tu código y aislar características antes de que las entregues a los clientes.

Creando una Nueva Rama

Por defecto, estás en lo que llamamos la rama “maestra”. Esa es la rama principal en la cual, eventualmente, todo debería aterrizar. La mejor práctica, especialmente trabajando con un equipo, es trabajar sobre características nuevas principales en sus propias ramas, las cuales serán fusionadas con la maestra cuando estén completas.

Para practicar trabajar con ramas, creemos una nueva rama. Para hacer esto, ejecuta el siguiente comando:

Puedes nombrar la rama como quieras.

Para ver la nueva rama, puedes teclear:

Cuando ejecutas ese comando, verás algo como esto:

Figure 8 Branches

Nota que puedes ver dos ramas: master y my-first-branch (o como hayas nombrado a tu rama). Adicionalmente, verás que hay un asterisco en la rama master, lo cual indica que actualmente estás en esa rama.

Revisando una Rama Actual

Si alguna vez necesitas cambiar a otra rama existente, necesitaras hacer checkout a esa rama. Cuando haces esto, estás dejando la rama actual, y todo su código permanecerá intacto (junto con tus cambios locales), pero tu directorio de trabajo será poblado con el código de la rama a la que hiciste checkout.

Pruébalo con el siguiente comando:

Deberías obtener una confirmación que luce algo como esto:

Figure 9 Switched Branches

Ahora, has cambiado a esta rama, y debería ser una pizarra en blanco, Para confirmar esto, ejecuta git status para revisar si hay algún archivo modificado.

Fusionando Ramas

Después de que hayas terminado de hacer cambios, normalmente fusionarías la rama a la rama maestra. No hemos hecho ningún cambio, así que hagamos eso antes de fusionar las dos ramas.

Haz otro cambio al proyecto Xcode. Para el mío, solo agregaré la siguiente línea de código de prueba en mi método viewDidLoad():

Puedes hacer cualquier cambio que quieras. Solo asegúrate de que sabes a qué archivo y qué cambio hiciste.

Después de hacer eso, ejecuta la siguiente línea de código otra vez:

Ahora, deberías ver el nombre de archivo en rojo, y necesitarás hacer commit antes de fusionar  Confío en que sabes cómo hacer eso, así que continuemos al siguiente paso. Revisa dos veces que el commit fue exitoso con git status.

Por ahora, deberías haber comprometido el código, así que prepárate para fusionar las dos ramas. Primero, ejecuta el siguiente comando:

Este comando cambia a la rama master para prepararla para fusionar con la otra rama que creamos. Finalmente, para fusionar, ejecuta el siguiente comando:

Deberías recibir una confirmación que luce así:

Figure 11 Merging with Master

Ahora tus cambios de la rama de característica han sido fusionados a master. Si la rama master ha cambiado desde que fue creada, Git tratará automáticamente de combinar tus cambios de rama de característica con master. Si no puedes hacerlo de forma automática, te pedirá resolver de manera manual cualquier conflicto.

Ahora que sabes cómo fusionar ramas, créalas, ¡y cambia entre ellas usando la Terminal!

Conclusión

Como ves, no es demasiado difícil hacer control de versiones con tu proyecto, y las recompensas bien lo valen. El control de versiones es una mejor principal del desarrollo, y deberías estar familiarizado con esta si quieres trabajar en un contexto profesional.

Espero que este artículo te haya dado la confianza para usar control de versiones diariamente. Si quieres aprender más sobre Git, revisa algunos de nuestros videos instruccionales animados aquí en Envato Tuts+.

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.