post thumbnail

Git desde Cero: Registrando cambios.

Publicado Por: Alberto Grespan, El 27/06/2013


Detalles del Curso:

Dificultad: Novato

Duración: 30 min


Hemos habilitado un repo en GitHub para que puedas descargar el código de esta entrada:

Échale un vistazo aquí.

Bienvenidos a un nuevo capítulo de Git desde cero en este tutorial hablaremos sobre los siguientes comandos:

  • git clone
  • git status
  • git diff
  • git rm
  • git mv

nota: hemos creado un repositorio en Github con el tutorial para que te puedas descargar lo que realizamos y le eches un vistazo.


Clone

El comando git clone lo utilizaremos para literalmente realizar una copia de seguridad de lo que se encuentra en el servidor remoto. Como se explicó en el capítulo pasado cualquiera puede copiar un repositorio completo y hospedarlo en su computador por si ocurre algún imprevisto con el servidor remoto, si se desea contribuir o distribuir un proyecto como es nuestro caso para esta serie de totorales.

¿Cómo realizamos una "clonación" de un repositorio? Pues es bastante sencillo. Primero nos dirigimos al directorio donde queremos que se descargue la copia de seguridad (Lo creamos sino existe) y luego utilizando el siguiente comando:

$ cd ~/CodeHero/tutorial-git
$ git clone https://github.com/codeheroco/tutorial-git.git # Clonación del repositorio.

Posterior a la ejecución del comando podemos observar que se nos descargaron los archivos en nuestro directorio utilizando el comando ls para listar directorios .


Status

El comando git status nos identifica si existe un archivo modificado o no en nuestro repositorio. Esto es importante ya que si hacemos memoria del capítulo anterior hay que ubicar los archivos en el escenario antes de consolidarlos en la base de datos.

Cuando el repositorio no presenta modificaciones y corremos el comando, obtenemos la siguen salida:

$ git status
On branch master
nothing to commit, working directory clean

Pero si ahora agregamos un nuevo archivo y le copiamos texto podemos ver que la salida es bastante diferente:

$ touch Archivo2.txt
$ echo 'Texto para el segundo archivo' >> Archivo2.txt
$ git status
 On branch master
 Untracked files:  #<-- Nos está indicando que tenemos archivos nuevos.
   (use "git add <file>..." to include in what will be committed)
    Archivo2.txt #<-- El archivo nuevo del que git no conoce.
nothing added to commit but untracked files present (use "git add" to track)

Si observamos con detenimiento nos pide que utilicemos el mismo comando de git add que aprendimos en el primer capítulo para comenzar a seguir los cambios de este archivo. Vamos a realizarlo!

$ git status
 On branch master
 Changes to be committed:
   (use "git reset HEAD <file>..." to unstage)
    new file:   Archivo2.txt #<-- Archivo nuevo

Ahora podemos apreciar que Git ha subido al escenario al Archivo2.txt y lo conoce como archivo nuevo.

nota: Antes de consolidar los cambios en el Archivo2.txt vamos a comenzar a ver el siguiente comando.


Diff

El comando git diff nos identifica todos los cambios de un archivo con respecto a su versión anterior, o mejor dicho nos identifica los cambios de un archivo entre diferentes versiones. Es aquí donde podemos apreciar los cambios realizados que vamos a consolidar en esta nueva versión.

Ahora realizando la continuación de lo que venimos realizando utilicemos el siguiente comando:

$ git diff --cached # comando utilizado para archivos en el escenario.
diff --git a/Archivo2.txt b/Archivo2.txt
new file mode 100644
index 0000000..aeaed15
--- /dev/null
+++ b/Archivo2.txt # Archivo con más líneas.
@@ -0,0 +1 @@
+Texto para el segundo archivo # líneas nuevas

Al utilizar el comando observamos que una vez que tenemos el Archivo2.txt en escenario podemos revisar sus diferencias con respecto a una versión anterior (en este caso no existe) pero de igual manera nos indica que al archivo se le agregaron líneas nuevas y nos dice cuales fueron.

Ahora si consolidamos el archivo y lo modificamos podemos apreciar como la salida es algo distinta:

$ git commit -m "Agregar Archivo2"
[master 9322f84] Agregar Archivo2
 1 file changed, 1 insertion(+)
 create mode 100644 Archivo2.txt

Si ahora modificamos de nuevo el Archivo2.txt y utilizamos git diff nuevamente veamos lo que sucede:

$ echo 'Cambiando la primera linea' > Archivo2.txt
$ echo 'Agregando una segunda linea' >> Archivo2.txt
$ git diff
diff --git a/Archivo2.txt b/Archivo2.txt #diferencia entre versiones
index aeaed15..4564504 100644
--- a/Archivo2.txt # Versión anterior con menos líneas
+++ b/Archivo2.txt # Versión actual con más lianas
@@ -1 +1,2 @@
-Texto para el segundo archivo # Eliminamos ésta línea
+Cambiando la primera linea # Agregamos estas dos
+Agregando una segunda linea

Los signos + y - nos indican los cambios realizados sobre el archivo y funciona únicamente como indicativos visuales. Aún así vemos lo útil y fundamental que es éste comando para conocer los nuevos cambios realizados.

Ahora vamos a subir estos nuevos cambios al escenario y posteriormente consolidarlos en la base de datos.

$ git add Archivo2.txt
$ git commit -m "Modificaciones sobre el Archivo2"
[master 2e37d7f] Modificaciones sobre el Archivo2
 1 file changed, 2 insertions(+), 1 deletion(-) # resumen de cambios

Aquí también apreciamos un pequeño resumen de los cambios ocurridos. Un archivo cambió, tuvo 2 líneas insertadas y una borrada.


Rm

El comando git rm es un comando particular, a mi juicio poco utilizado pero importante conocer sobre él. Al igual que el comando Rm de Unix sirve para borrar un archivo pero en este caso sirve para agregar al escenario el archivo que vayamos a borrar. Veamos el siguiente ejemplo:

$ rm Archivo1.txt # borramos el archivo.
$ git status
# On branch master
# Changes not staged for commit: # NO se encuentra en escenario
#   (use "git add/rm <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   deleted:    Archivo1.txt # Archivo eliminado pero no en escenario
#
no changes added to commit (use "git add" and/or "git commit -a")

Podemos observar que al utilizar el comando rm de Unix (en mi caso) hemos borrado satisfactoriamente el Archivo1.txt pero esto aún no se encuentra en escenario.

$ git rm Archivo1.txt
$ git status
# On branch master
# Changes to be committed: # En escenario
#   (use "git reset HEAD <file>..." to unstage)
#
#   deleted:    Archivo1.txt
#

Ahora utilizamos el comando git rm automáticamente confirmamos que realmente queremos eliminar dicho archivo. lo último que nos resta es consolidar los cambios.

$ git commit -m "Eliminar el Archivo1"
[master 0f8a083] Eliminar el Archivo1
 1 file changed, 1 deletion(-)
 delete mode 100644 Archivo1.txt

Mv

El comando git mv funciona de la misma manera que el comando git rm, confirma cualquier cambio de nombre o movimiento de un archivo. En esta oportunidad vamos a simplificar un paso no utilizando el comando mv del sistema operativo sino directamente iremos por el comando de Git.

$ git mv Archivo2.txt Archivo2_cambio_de_nombre.txt # Cambio de nombre
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   renamed:    Archivo2.txt -> Archivo2_cambio_de_nombre.txt
#
$ git commit -m "Cambio de nombre del archivo 2" # Consolidar en BD
[master 5a13514] Cambio de nombre del archivo 2
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename Archivo2.txt => Archivo2_cambio_de_nombre.txt (100%) # resumen

Este comando realiza el cambio de nombre a nivel de sistema operativo y a su vez confirma los cambios subiendo el archivo al escenario. Para consolidarlos posteriormente.


¿Te ha gustado esta publicación?

Compártela:

Por Alberto Grespan

Conoce más sobre este autor aquí


comments powered by Disqus