Comandos básicos de Git

Estos comandos los recopilé cuándo me decidí a entender y usar esto del control de versiones, espero sea de ayuda para más de una persona.  

Cómo empezar

Inicializando un nuevo repositorio local:

Se debe de crear la carpeta donde estará nuestro repositorio y nos movernos hacia ella

git init

Si se crea un repositorio local sin clonar y se necesita compartir los cambios, debemos agregar el alias remoto “origin” para facilitarnos esta tarea, este puede ser por SSH, HTTPS o por protocolo Git. Todo depende del lugar donde tengamos nuestro repositorio remoto.
Este alias nos servirá para evitar escribir la ruta de conexión remota cada vez que la necesitemos.

git remote add origin ssh://{usuario}@{servidor}:{ruta_hasta_proyecto}

Regularmente la ruta de conexión al repositorio se puede encontrar en el administrador web del repositorio remoto de dicho repositorio (GitHub, BitBucket, etc...)

Clonar un repositorio remoto

No es necesario inicializar un repositorio porque el proceso de clonación lo crea automáticamente, además la carpeta destino no debe existir

git clone ssh://{usuario}@{servidor}:{ruta_hasta_proyecto}
#la ruta debe ser desde la raíz como /var/www/html/mi_repositorio/
#Un ejemplo sería
git clone ssh://usuario@192.168.1.10:/var/www/html/mi_repositorio/
#Asumiendo que /var/www/html/mi_repositorio/ es un repositorio git
#El siguiente paso será ingresar el password del usuario en el servidor

Ramas [Branch]

Las ramas son una especie de copia de cierto momento de nuestro proyecto, en el que podemos hacer y deshacer todo lo que queramos sin ver comprometido nuestro proyecto principal. Yo siempre lo asocio con hacer una copia de la carpeta de nuestro proyecto y ponerle otro nombre para poder probar algún cambio sin perder lo que ya habíamos logrado.

Para poder ver qué ramas están en el repositorio local debemos usar lo siguiente:

git branch

Cómo hacer una nueva rama en el repositorio local:

git branch nueva_rama

Cómo hacer un checkout a una rama local existente:

git checkout rama_existente

Cómo crear una nueva rama y hacer checkout al mismo tiempo:

git checkout -b nueva_rama

Cómo borrar una rama

git branch -d rama_existente

Cómo unir dos ramas:

#primero se debe hacer un checkout a la rama destino y luego se ejecuta lo siguiente
git merge rama_fuente
#esto toma la rama_fuente y la une con la rama activa a la que hicimos el checkout inicialmente

Controlar cambios

Para poder llevar un control de los cambios se debe hacer cada cierto tiempo un “commit” de los cambios realizados, para esto primero se deben de agregar a la cola del commit los archivos.

Para ver el estado del proyecto (Si hay archivos nuevos, archivos modificados o borrados)

git status

Agregar archivos nuevos o modificados a la cola para preparar un commit

#Si se quieren agregar todos los archivos
git add .
#Si sólo se quiere agregar uno
git add nombre_archivo

Al eliminar archivos es necesario agregarlos a la cola del commit como una eliminación, esto se logra con la siguiente línea

git rm nombre_archivo

Para Hacer un commit para almacenar los cambios realizados en los archivos

#Si es un comentario pequeño se puede agregar de la siguiente forma
git commit -m "comentario"
#Si es más detallado se puede agregar de la siguiente forma
git commit
#El proceso nos pedirá un comentario para almacenarlo

Para hacer un “commit” de todos los archivos modificados podemos usar el siguiente comando que hace automáticamente un “git add .” antes de hacer el “commit” (también lo podemos unir con las otras variantes del comit como el -m)

git commit -a 

Compartir ramas

Para poder compartir una rama se debe de hacer un “push” de datos.
Dependiendo del tipo de repositorio al que haremos el push, no se puede hacer hacia la rama que esté seleccionada en la máquina remota (independientemente si es la master o es otra) a menos que la configuración del repositorio lo permita (tal es el caso de github, bitbucker o cualquiera parecido que por su naturaleza si permite hacerlo)

El push se hace desde la rama a la que le hicimos el último el checkout a menos que se indique lo contrario

git push origin rama_remota

Obtener cambios del servidor

Para poder obtener los cambios desde el servidor hay dos comandos “fetch” y “pull”. Los dos hacen lo mismo pero el fetch descarga todos los archivos y ramas del repositorio remoto (a menos que se especifique sólo una rama), y estas quedan en estado de “sólo lectura” y anteponiéndoles el texto "origin/" a cada rama, teniendo que hacer un merge con nuestras ramas para poder actualizarlas. En cambio, con el pull se puede obtener una rama en específico y se comporta como que hubieramos hecho un “git fetch” seguido de un “git merge” hacia la rama en la que estamos.
Lo más común y menos complicado es hacer un pull.

git pull origin rama_remota

Crear ramas en el repositorio remoto

En el caso que necesitemos compartir una rama local en el servidor remoto, pero esta no esté aún el comando es el siguiente:

git push origin {nueva_rama}

Como se puede observar no hay un cambio significativo, porque al hacer un push se verifica si la rama existe, y si no existe se crea

Borrar ramas remotas

Cuando ya no se necesite más una rama y se deba borrar, lo que debemos ejecutar es lo siguiente:

git push origin --delete {rama_remota}

Histórico

Para poder ver todos los commits que hemos hecho a lo largo del tiempo podemos usar el siguiente comando:

git log

---

Todo esto que han leído es lo básico para usar git en la consola. Claro que hay clientes con entornos gráficos que permiten administrar repositorios, el "Git Gui" es un ejemplo de ello, pero por experiencia sé que es mejor conocer los básico y luego se darán cuenta que podrán usar cualquier cliente con interfaz gráfica. Además de que hasta ahorita no he encontrado un cliente que haga todo sin que haya necesidad de ejecutar algunos comandos de vez en cuando.

Más información en http://gitref.org/

Control de versiones: Git

La primera vez que yo escuché acerca del control de versiones me pareció que era la forma de llevar los números de las versiones en una aplicación, en esos tiempos empezaba a programar y no le tomé mucha importancia. Mucho tiempo después, cuando ya debía trabajar con varios compañeros a la vez, me dí cuenta que sirve para controlar las versiones del proyecto que cada uno está haciendo.

Cuando varias personas trabajan en un mismo proyecto es bastante probable que toquen los mismos archivos (y a veces las mismas líneas). Debido a eso es necesario una herramienta que compare los archivos de varias personas, pero compararlos manualmente no es la solución porque es muy engorroso. Para esto yo elegí Git, luego de leer muchos consejos y comparaciones entre varios gestores.

Git es una herramienta de control de versiones diseñada para ser descentralizada, cada uno puede tener una copia del proyecto y trabajar todo lo que quiera con ella sin necesidad de estar conectado a un mismo lugar, y cuando todo esté listo se puede unir con los cambios que los otros compañeros hayan hecho para tener un producto terminado listo para entrar al testeo.

Se pueden hacer ramas para probar código o hacer nuevas características, correcciones, etc... Todo depende del ingenio que nosotros tengamos a la hora de trabajar con el.

Todo esto hace que nosotros trabajemos con toda confianza sin miedo de perder lo que hicimos, y todo se pone más entretenido si usamos un servidor para hostear nuestro repositorio como GitHub o Bitbucket (Yo uso más bitbucket, pero para mi son muy parecidos aunque GitHub sea más famoso)

Yo recomiendo empezar desde lo básico, la línea de comandos... Eso les permitiría aprender a usarlo bien (no soy muy fan de las interfaces gráficas para estas cosas)

Les dejo un link que me hubiera servido mucho cuando estaba aprendiendo, espero que a más de alguno le sirva. Es como una guía para aprender lo básico en 15 minutos. (Está en inglés)
http://try.github.io/levels/1/