Herramientas de usuario

Herramientas del sitio


clase:daw:daw:1eval:tema05

5. Control de versiones

En este tema vamos a ver tareas básicas en Git.

Mas información

Instalando Git

Al instalar Git en Windows hay varias opciones a tener en cuenta que explicaremos en clase.

Una vez instalado Git, hay que indicar cual es nuestro nombre y nuestro correo.

git config --global user.name "juan"
git config --global user.email juan@micorreo.com

Por último , si estás en el instituto , habrá que configurar el proxy:

git config --global http.proxy http://172.16.0.9:8080
git config --global https.proxy http://172.16.0.9:8080

Para instalar Git en Linux y que sea la última versión usaremos los siguientes comandos (Ya que por ejemplo en Ubuntu 18.04 la versión e un poco vieja):

sudo add-apt-repository ppa:git-core/ppa
sudo apt update
sudo apt install git

El inicio de Git

Los comandos básicos de Git son:

  • Para iniciar un directorio y que se pueda usar Git
git init



  • Para descargar un repositorio que ya existe
git clone https://github.com/lgonzalezmislata/prueba.git



Estados de un fichero

  • untracked o archivos sin seguimiento: Son ficheros que existe en el área de trabajo pero no existen para git
  • staged o cambios a ser confirmados: Son ficheros modificados que se añadirán al siguiente commit.
  • committed: Son ficheros que se guardaron en el ultimo commit y que no han sido modificados desde dicho commit.
  • modified o cambios no rastreados para el commit: Son ficheros que se han modificado desde el último commit pero que aun no se han añadido para el próximo commit.

  • Por defecto el comando commit solo se hace "commit" de los ficheros que estén en la staging area.
git commit -m "mensaje"



  • Para añadir un fichero a la staged area usamos el comando
git add fichero



  • Podemos hacer que el comando commit incluya ademas de los ficheros que están staged se incluya ademas todos aquellos ficheros que están modified , usaremos el parámetro -a ( o --all )
git commit -a -m "mensaje"



  • Para quitar un fichero de la staged area. Es como lo opuesto a git add.
git reset fichero



  • Para borrar un fichero y que ya no esté a partir de ahora en "git". Se usa --cached para que no se borre del área de trabajo.
git rm --cached fichero.



  • Para deshacer los cambios de un fichero que hay en el area de trabajo y se cambie por la versión que hay en el último commit.
git checkout fichero



  • Para ver el estado de cada uno de los ficheros
git status

En la rama master
Cambios a ser confirmados:
  (usa "git reset HEAD <archivo>..." para sacar del área de stage)

	nuevo archivo:  facturas.html

Cambios no rastreados para el commit:
  (usa "git add <archivo>..." para actualizar lo que será confirmado)
  (usa "git checkout -- <archivo>..." para descartar los cambios en el directorio de trabajo)

	modificado:     main.js

Archivos sin seguimiento:
  (usa "git add <archivo>..." para incluirlo a lo que se será confirmado)

	cliente.html



Para simplificar el uso de Git se recomienda hacer el git add justo antes de hace el git commit ya que sino hacemos los siguiente:
  • modificar un ficherio
  • git add
  • modificar el fichero de nuevo
  • Si hacemos ahora un git status. El fichero modificado está a la vez en el estado staged y modified 8-o 8-o 8-o 8-o
  • git commit

En el commit solo se guardan los primeros cambios y no los segundos. Ya que al hacer el git add , git se guarda como está el fichero en ese momento y en el git commit solo se hace como está en ese momento.Aunque si hiciéramos el git commit -a si que se guardaría el segundo cambio.

Sincronización de Git

Una misma rama en git puede estar en varios sitios a la vez. El repositorio es el historio donde están todos los commits que se han hecho.

Vamos a explicar cada uno de ellos suponiendo que estamos en la rama master.

  • Carpeta local o área de trabajo o árbol de trabajo: Es donde están los ficheros con lo que trabajamos nosotros directamente mientras programamos.
  • Repositorio local: Es el repositorio que tenemos en nuestro ordenador.
    • Rama master:Es donde se guardan al hacer commit
    • Rama origin/master: Es una copia que hay del repositorio remoto. El nombre de la rama se llama origin/master. Hay que fijarse que hay va todo junto y no con un espacio en medio. Ya es es simplemente el nombre de una rama local nuestra. Solo que es una copia de un remoto llamado origin de su rama master.
  • Repositorio remoto: Es un repositorio que está en otra máquina.
    • Rama master: Es donde queremos copiar los commits de nuestra rama master. Al hacer referencia a una rama de un repositorio remoto, se usara la expresión origin master con un espacio en medio. Ya que por separado está el nombre del remote llamado origin y de la rama llamadamaster

  • Para poner en el área de trabajo una copia del último commit de master.
git checkout master



  • Para copiar los commits que hay en nuestro repositorio local al repositorio remoto (y también a la copia del repositorio remoto origin/master)
git push
o
git push origin master



  • Para copiar lo que hay en el repositorio remoto en la copia del repositorio remoto, es decir en origin/master.
git fetch
o
git fetch origin master



  • Para copiar lo que hay en el repositorio remoto en nuestra rama loca, es decir en master y origin/master. Como en nuestra rama puede ser distinta, se hace un merge sobre nuestra rama.
git pull
o
git pull origin master 
El problema es que si hacemos git pull origin master y estamos en otra rama , se hace un merge de origin/master en la rama que estemos y eso no suele ser lo que queríamos hacer. Así que mi recomendación es nunca usar git pull y usar siempre git fetch.
Recuerda: Nunca uses git pull y usa siempre git fetch.



  • Para mergear lo que hay en la rama origin/master en la rama master.
git merge origin/master



Remotes

El Git un "remote" hace referencia a un servidor de Git donde subimos el código. Por defecto cuando hacemos git clone se crea un remote llamado origin.

  • Para ver la lista de remotes.
git remote -v

origin	https://github.com/lgonzalezmislata/prueba.git (fetch)
origin	https://github.com/lgonzalezmislata/prueba.git (push)



  • Para añadir un nuevo remote
git remote add otroservidor https://www.otroservidor.com/lgonzalezmislata/prueba.git

Una vez creado el remote otroservidor ya podremos usarlo en los comandos git push, git fetch o git pull además de usar origin

Borrado de commits

El comando git reset <commit> vuelve a un commit anterior y borrando todos los siguientes.

  • Volver a un commit anterior y borrando todos los posteriores pero modificando el área de trabajo al dejar ahí los ficheros del commit y vaciando la staged area.
git reset --hard 0d588ed



  • Volver a un commit anterior y borrando todos los posteriores pero sin modificar ni el área de trabajo ni la staged area.
git reset --soft 0d588ed



  • Volver a un commit anterior y borrando todos los posteriores , sin modificar ni el área de trabajo pero vaciando la staged area.
git reset --mixed 0d588ed



  • Si queremos deshacer el último commit (es decir como si no hubiéramos lanzado el comando git commit) se usa la siguiente orden. Ya que HEAD es el nombre del último commit y HEAD~1 el del penúltimo commit.
git reset --soft HEAD~1


La siguiente tabla resume lo que hace cada modificador:

Borra los commits siguientes Se modifica área de trabajo Modifica staged area
--hard Si Si Si
--mixed Si No Si
--soft Si No No


Ejemplos de como hacer un commit y lo que se necesita hacer después de borrarlo

soft mixed hard
Hacer el commit
vi fichero
git add fichero
git commit -m "mensaje malo"
vi fichero
git add fichero
git commit -m "mensaje malo"
vi fichero
git add fichero
git commit -m "mensaje malo"
Borrar el commit
git reset --soft HEAD~1
git reset --mixed HEAD~1
git reset --hard HEAD~1
Rehacer el commit
git commit -m "mensaje bueno"
git add fichero
git commit -m "mensaje bueno"
vi fichero
git add fichero
git commit -m "mensaje bueno"



Mas información en:

Moverse por commits

El comando git checkout <commit> vuelve a un commit anterior pero sin modificar los commits siguientes. Su utilidad es ver como estaba el código en estados anteriores.

  • Volver a un commit anterior, no se borran los siguientes commits pero obviamente si que de modifica el área de trabajo para poner los ficheros de ese commit.
git checkout 0d588ed



Si ahora lanzamos el comando git status se mostrará lo siguiente

HEAD detached at 0d588ed
nothing to commit, working tree clean

El significado de HEAD detached es que ahí no podemos trabajar, no pudiendo hacer nuevos commits desde ahí aunque si que podríamos hacer una nueva rama.

  • Para volver al commit último de la rama solo hay que poner el nombre de la rama en vez de un commit
git checkout master

reset vs checkout

Veamos ahora una pequeña tabla que compra ambos comandos.

Ámbito
Orden Fichero Commit Rama
git checkout Descartar los cambios del fichero Ir hasta el commit Moverse a la rama
git reset Quitar el fichero de la staged area Ir hasta el commit, borrando los siguientes a él ---

Configuración

.gitkeep

Por defecto Git no sube las carpetas vacías, por lo que si queremos que las suba hay que añadir algún fichero. Por convención se suele crear un fichero llamado .gitkeep y al ya haber algún fichero, git subirá esa carpeta.

.gitignore

El fichero .gitignore permite indicar que carpetas no se deben subir a git. El fichero debe estar en el raíz del proyecto de git.

  • Por ejemplo para que no se suba el fichero node_modules hay que crear el fichero .gitignore con la siguiente línea:
/node_modules

Almacenando contraseñas

Normalmente trabajamos siempre en nuestro ordenador y no queremos todas las veces volver a poner la contraseña. En ese caso se puede decir a git que la almacene y no nos la vuelva a pedir:


  • No te vuelve a pedir la contraseña en 15 min
git config --global credential.helper cache


  • Almacena la contraseña en el disco en texto plano y nunca mas te la vuelve a pedir.
git config --global credential.helper store

Log

El comando git log permite ver el histórico de commits

  • Ver los commits en una única línea cada commit
git --no-pager log --pretty=oneline



git --no-pager log --pretty=tformat:"%h %cn %cd %s" --date=format:"%d/%m/%Y %H:%M:%S"



Campos a mostrar

Formato de Fechas

Mensajes de commit

Los mensajes de commit deben seguir el siguiente formato:

type(#issue):titulos

Explicación (opcional)

Siendo

  • type
    • feat: Si se añade una nueva funcionalidad (feature)
    • fix: Si se arregla (fix) un error
    • docs: Si solo cambia cosas de la documentación
    • style: Si solo se cambia el estilo del código como tabuladores, puntos y comas, formateo, etc.
    • refactor: Si se cambia el código para mejorar su calidad pero sin modificar la funcionalidad. Eso se llamada refactorizar.
    • test: Si se cambian cosas relacionadas con test automáticos.
    • chore: Si se cambian cosas relacionadas con el despliegue.
  • #issue: Es el Nº de la incidencia a la que hace referencia. Mas información sobre los issues de GitHub: aquí

Vamos ahora unos ejemplos:

  • Se arregla el fallo 45 que se llama "Falla si la fecha está vacía"
fix(#45):Falla si la fecha está vacía



  • Se añade la nueva funcionalidad llamada "Mostrar el listado de los pacientes" con Nº 456
feat(#456):Mostrar el listado de los pacientes

El listado se ha hecho en HTML en vez de generar un PDF.



Mas información:

Ejercicios

Para todos los ejercicios de este tema, se usarán los comandos de Git siempre que sea posible y los mensajes de los commits deberán seguir el formato explicado en clase.

Ejercicio 1

  • En tu ordenador instala Git y configura el usuario y el correo que usará Git.
  • En una carpeta vacía inicializala para poder usar Git.
  • Crea 3 ficheros y haces un commit con ellos. Los ficheros se llamarán
    • index.html
    • index.js
    • main.css
  • Haz otro commit con lo siguiente:
    • Modificación de index.html
    • Nuevo fichero cal.js
  • Modifica 3 ficheros pero que en el commit solo sea con dos de los ficheros modificados.
  • Deshaz los cambios del fichero que estaba modificado pero que no se incluyó en el commit.Y mira como está el estado de Git
  • Crea un nuevo fichero , modifica otro y haz que si se hiciera un commit se incluyeran esos ficheros (pero no hagas el commit). Y mira como está el estado de Git
  • Haz que los dos ficheros anteriores ahora no se incluyan si se hiciera el commit (pero no hagas el commit). Y mira como está el estado de Git
  • Haz que el fichero index.html se borre de git
Siempre antes de cada commit deberás lanzar el comando git status para ver el estado de los ficheros.

Ejercicio 2

En este ejercicio vamos a tener 2 carpetas que estarán "apuntando" al mismo repositorio de Git. Las carpetas las vamos a llamar "A" y "B".

  • Crea una cuenta en Github
  • Crea un repositorio llamado "banco" y al crearlo, indica que haya un fichero README.
  • Desde la carpeta "A", clona el repositorio.
  • Desde la carpeta "B", clona el repositorio.
  • Desde la carpeta "A", crea 2 ficheros y haz un commit. Sube el commit a GitHub.
  • Desde la carpeta "B", comprueba que no están los ficheros.
  • Desde la carpeta "B", baja los cambios con "pull" y comprueba que ya están los cambios en el área de trabajo.
  • Desde la carpeta "A", crea otros 2 ficheros y haz un nuevo commit. Sube el commit a GitHub.
  • Desde la carpeta "B", baja los cambios con "fetch y merge" y comprueba que ya están los cambios en el área de trabajo.
  • Desde la carpeta "A", crea otros 2 ficheros y haz un nuevo commit. Sube el commit a GitHub.
  • Desde la carpeta "B", baja los cambios UNICAMENTE con "fetch" y comprueba que NO están los cambios en el área de trabajo.
  • Desde la carpeta "B", ves a la rama "origin/master" y comprueba que ya están los cambios en el área de trabajo.
  • Desde la carpeta "B", ves a la rama "master" y comprueba que NO están los cambios en el área de trabajo.
  • Desde la carpeta "B", haz un merge de "origin/master" a "master" y comprueba que ya están los cambios en el área de trabajo.

Ejercicio 3

  • En una carpeta vacía inicializala para poder usar Git.
  • Crea otros 2 ficheros y haz un nuevo commit.
  • Crea otros 2 ficheros y haz un nuevo commit.
  • Crea otros 2 ficheros y haz un nuevo commit.
  • Crea otros 2 ficheros y haz un nuevo commit.
  • Muestra el histórico de commits haciendo que solo salga el hash abreviado ,la fecha del commit en formato "YYYY-MM-DD", el nombre de la persona que hace el commit y el mensaje del commit.
  • Borra los dos últimos commits. Y muestra ahora de nuevo el histórico como en el paso anterior.
  • Haz que en el area de trabajo se muestren los ficheros del primer commit que hiciste.
  • Haz que en el area de trabajo se muestren los ficheros del último commit que hay.
  • Crea otros 2 ficheros y haz un nuevo commit.
  • Modifica el commit que acabas de hacer para cambiar el mensaje del commit (deberás borrar el commit pero sin tocar los ficheros del area de trabajo).
  • Modifica un fichero , añade un fichero y y haz un nuevo commit.
  • Modifica el commit que acabas de hacer para añadir un tercer fichero.

Ejercicio 4

Crea un nuevo proyecto de NodeJS y haz lo siguiente:

  • Que esté el index.js
  • Instala alguna librería en la carpeta node_modules
  • Crea la carpeta dist pero que esté vacia.
  • Que sea un proyecto de Git

Modifica el proyecto de Git de forma que no se suba la carpeta node_moules y si que se suba la carpeta dist

clase/daw/daw/1eval/tema05.txt · Última modificación: 2021/10/29 12:17 por admin