---
# System prepended metadata

title: Git

---

# Git
![image alt](https://i.blogs.es/672fa7/git-logo/450_1000.png)
## Que es git 
_Git_ es un software de control de versiones diseñado para trabajar en equipo o individualmente. 
## Introduccion a git 
Lo primero que debemos hacer es crear un usuario y email para que nos identifiquen
```
$ git config --global user.name "John Doe"
$ git config --global user.email johndoe@example.com
```
## Inicio de un repositorio de git  (Git init )
Sabes que es un repositorio local? 
Este es el directorio de trabajo, donde se encuentran todos nuestros archivos, aquellos que editamos y modificamos.
Crea un nuevo repositorio de _Git_. Puede utilizarse para convertir un proyecto existente y sin versión en un repositorio de _Git_ o inicializar un nuevo repositorio vacío
```
$ git init 
```

## Clonar un repositorio existente (git clone "url")
Puedes clonar un repositorio con `git clone [url]`. Por ejemplo, si quieres clonar la librería de _Git_ llamada libgit2 puedes hacer algo así
```
$ git clone https://github.com/libgit2/libgit2
```
## Agregar archivos (git add <"Nombre del archivo" , git add .>)
Con `git add` podemos seleccionar el archivo para realizar un commit explicando el cambio hecho en el.  

```
$ git add archivo.py
```
## Hacer un mensaje para explicar los cambios de un archivo (git commit)
El comando `git commit` crea una instantánea de los cambios preparados en ese momento del proyecto. Las instantáneas confirmadas pueden considerarse como versiones "estables" de un proyecto:
```
$ git commit 
```
## Estado del repositorio (Git status)
Cada vez que se modifique un archivo que forma parte del repositorio,  este aoarecera como pendiebnte para realizar un commit.
```
git status 
```
## Historial de cambios (git log)
Después de haber hecho varias confirmaciones, o si has clonado un repositorio que ya tenía un histórico de confirmaciones, probablemente quieras mirar atrás para ver qué modificaciones se han llevado a cabo.
```
$ git log
```
## Lista de repositorios (git remote )
Para poder colaborar en cualquier proyecto _Git_, los repositorios remotos son los que se encuentran alojados en un servidor a los que se pueden subir cambios y de los cuales se puede bajar los cambios mas reciente.
Para poder ver los remotos que se tiene configurados se debe de ejcutar el comando 
```
git remote -v
```
Pero también se puede añadir mas de un remoto, esto para trabajar en dos o mas repositorios a la vez ,k es comando para agregar remotos es el siguiente 
```
git remote add [nombre] [url]
```
Para confirmar que se agrego volvemos a presionar el comando para ver remotos.
Tambien se  pueden boorraren caso de que ya no usemos ese remote, con el siguiente comando 
```
git remote rm upstream
```
## Bajar cambios existentes (git fetch)
Con fetch  puedes bajar cualquier cambio que se haya hecho y no este en tu equipo , normalmente se usa para bajr alguna rama que no tengas en tu proyecto pero si exista en el remote 
```
git fetch [remote-name]
```
## Subir los cambios del repositorio (Git push)
Cuando tienes un proyecto que quieres compartir o has modificado algo de ese mismo proyecto, debes enviarlo a un servidor para que se quede alojado y las demás personas tengan acceso a esos cambios
```
git push [nombre-remoto] [nombre-rama]
```
## Bajar cambios existentes (git pull)
Similar a el comando fetch se usa para traer y combinar automáticamente la rama remota con tu rama actual.
```
git pull [remote] [rama]
```
## Crear una nueva rama (git branch "nombre")
Cuando se trabaja en un proyecto de git normalmente existen  dos o más líneas de desarrollo aisladas, una para una función pequeña y otra para una función más extensa. Al desarrollarlas en ramas, no solo es posible trabajar con las dos de forma paralela, sino que también se evita que el código dudoso se fusione con la rama maestra.
```
$ git branch nuevoNombre
```
Para aprender mas acerca del workflow de git lee este [articulo](https://nvie.com/posts/a-successful-git-branching-model/)
## Lista de Ramas (git  branch)
Para poder ver todas las ramas existentes en el proyecto podemos usar 
```
$ git branch 
```
Normalmente en la rama que estámos esta de un color diferente 
## Cambiar de rama (git checkout "Nombre")
Al estar dentro del workflow de git podemos cambiar entre ramas para poder trabajar en característica diferentes
```
git checkout rama
```
## Borrar una rama 
Siempre que una rama ya no sea necesaria o ya se haya  fusionado  con otra , se puede borrar con el siguiente comando.
```
git branch -d "nombre"
```
## Fusionar ramas (git merge)
Cuando trabajamos en ramas paralelas y estas ya cumplen con la característica en que se estaba trabajando, llega el momento de hacerla parte de la rama principal
El merge debe de ser dentro de la rama en la que estemos, por ejemplo queremos hacer merge de la rama dev dentro de master, debemos asegurarnos que estamos en la rama master e introducir el siguiente comando
```
git merge [rama-a-fusionar]
```
## Regresar a un estado estable 
Una de los principales características que tiene git es poder regresar a una versión estable, esto es por si a la hora de trabajar en una nueva característica hay algún fallo y ya se hizo el comit y no se sabe en que momento empezó a fallar, existe una buena solución a esto.
- Introduce el comando git log: dentro de ese historial de cambios hay un id asociado a ese commit , solo copia ese id , normalmente ese numero es algo largo y esta compuesto por numero y letras.
- introduce el siguiente comando 
```
git checkout #
```
y es asi como se vuelve a un version anterior de git 
## Deshacer comit en git
Siempre nos podemos equivocar cuando creamos un comit, tal vez una mala redacción, archivos incorrectos, etc. Siempre podemos deshacer ese comit con este comando
```
git reset --soft HEAD~1
```

 Hacemos que la rama actual retroceda a la versión que le indicamos. En este caso le decimos HEAD~1 que significa: queremos volver a la versión inmediatamente anterior a la que estamos ahora, si cambiamos el numero sera los pasos en los que retrocedemos
 Existe otra alternativa la cual es
 ```
 git reset --hard HEAD~1
 ```
 Esto eliminará los cambios de los que habíamos hecho commit anteriormente
## Git ignore
Normalmente en el desarrollo de un proyecto hay algunas dependencias como puede ser en el caso de nodeJS la carpeta ***node_modules*** o los archivos ***.exe*** de c++, estos archivos o dependencias pueden ocasionar problemas dentro del servidor ya que normalmente esas carpetas pueden llegar a pesar GB y no son necesarias o simplemente no queremos que se incluyan en el repositorio remoto y que solo existan de forma local.  
Te preguntaras y ¿que comando hace eso?
No hay algún comando que haga eso, es un archivo que se llama ***.gitignore***
Este archivo es de texto por lo cual podemos editarlo con cualquier editor de texto plano, dentro de este archivo podemos especificar carpetas, archivos, extensiones de archivos, etc.
Para mayor informacion lee este [articulo](https://desarrolloweb.com/articulos/archivo-gitignore.html)
![image alt](https://markbrummel.files.wordpress.com/2019/09/gitignore.png?w=453)
## SSH
SSH o Secure Shell, es un protocolo de administración remota que le permite a los usuarios controlar y modificar sus servidores remotos a través de Internet a través de un mecanismo de autenticación.
para generar nuestra ssh 
```
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
```
## Actividad
Vamos a hacer un ejercicio completo con git.
### Seccion 1 
Vamos a instalar [git](https://git-scm.com/downloads)
Una vez que tengamos  el instalador , no importa si es para Windows, mac o linux , todos esos nos haran lo mismo lo cual es instalar git.
Una vez que tengamos linux instalado lo comprobaremos en linux y mac con el siguiente comando 
```
git --version 
```
si estamos en windows podemos checarlo  en panel de contro o escribir en el menu g

### Seccion 2
Antes de emepezar , abre una terminal en linux o mac, en windows abre el git bash.
Ahora falta identificarnos con git, para eso 
podemos checar la seccion [Identidicarse](https://hackmd.io/VTNnzKtkQ0m7o_1UhK-IKw?view#Inicio-de-un-repositorio-de-git-Git-init-)
Para ver que usuario y email tenemos podemos verlo con el siguiente comando 
```
git config --global user.name
git config --global user.email
```

### Seccion 3 
Creamos un directorio en el escritorio que se llame gitcurs, una vez que tengamos esa carpeta , abrimos algun IDE y la arrastramos a dicha ventana del IDE
En algunas ocaciones los IDE tiene una terminal integrada , per si en dado caso de que no haya aolguna terminal  procedemos a abrir alguna  del sistema , esto en  linux o mac ,  una vez que estemos dentro podremos inicar el repositorio de git con
```
$ git init 
```
Una vez que tengamos ese comando , en nuestro directorio nos creara unos archivos ocultos , para verlos usaremos 
```
ls -a 
```

Si vemos en la termianl que tenemos un archivo ***.git*** significa que hemps creado exitosamente nuestro repositorio local. 
### Seccion 4
Crearemos un archivo ejemplo.js y checaremos el status de nuestro repositorio con 
```
 git status  
```
Nos aparecera algo asi ![](https://i.imgur.com/Jjx882i.png)
El color rojo en un archivo significa que el archivo esta sin seguimiento y se han gecho cambios que no estan registrados dentro del repositorio.
### Seccion 5 
Para  deja un comit de un cambio primero debemos añadir ese archivo al cinjunto de cambios que estan esperando para ser documentados, para dicha accion ejecutamos el sigueinte comando 
```
git add ejemplo.js 
```
Ahora volvemos checar el estatus de nuestro repositorio ,nos deberia aparecer algo asi 
![](https://i.imgur.com/2zO2vQo.png)
El color verde significa que nuestro archivo esta ñisto para documentar
### Seccion 5 
Para realizar el comantario respectivo , introduciremos el siguiente comando 
```
git commit
```
Se nos abrira un editor de texto plano en el que podremos escribir un comentario , se recomienda que los comentarios sean precisos y no muy largos 
una vez que hayamos hecho el commit lo gaurdaremos y volveremos a ver nuestro estatus, ahora nuestro estatus nos dira que no hay nada por hacer ahora 
### Seccion 5.5 
Podemos ver todo el historial de cambios usando 
```
git log
```
En ese historial biene con fecha . nombre ,descripcion y un numero de commit , ese numero sera importante despues 
### Seccion 6 
Ahora crearemos un repositorio en linea
para eso nos dirgiremosa [Git Lab](https://gitlab.com/)
Crearemos un nuevo repositorio en blanco, el nombre puede ser cualquiera , lo  importante es que desmarques la casilla que dice ***Initialize repository with a README***
###  Seccion 7
Una vez creado el repositorio podremos seleccionar en la parte de clone , copiamos el url en la parte que dice HTTP , esa url la añadiremos a nuestro repositorio localmente 
para ver todos los repositorios remotos que tenemos usaremos el siguiente comando.
```
git remote -v 

```
nos daldra vacio por defecto ya que estamos en un repositorio que creamos localmente , para añadir el remoto usaremos el suignete comando 
```
git remote add [nombre] [url]

```
El nombre puede ser cualquiera pero el url sera el que copiamos de nuestro repositorio en Gitlab 
Volveremos a ver nuestro listado de remotesy ahora aparecera  nuestro remote con el nombre que le hayamos dado 
![](https://i.imgur.com/yIYZddC.png)

## Seccion 8 
Una vez que tengamosnuestron repositorio remoto añadido podemos ejecutar ek siguiente conmando para subir nuestros archivos a dicho servidor , nos pedira nuestra contraseña para hacerlo

```
git push [nombre-remoto] [nombre-rama]

```
Ese cambio severa reflejado en nuestro repositorio remoto![](https://i.imgur.com/CB5ZfXC.png)

Para evitarnos estar estar digitando nuestra contraseña a cada rato usaremos una ssh, esto nos ayudara a identificarnos mas rapido , usaremos el siguiente comando 
```
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"
```
Esa ssh key se genera en el directorio HOME/USER
Desde linux podemos ir en linux y mac con cd $HOME
en windows lo podemos encontrar como (/c/Users/you/.ssh/)

Una vez en esa ruta desde consola digitaremos el comando 
***ls -a*** esto para ver los archivos ocultos 
Sera un total de dos archivos llamdos ***id_rsa   y        id_rsa.pub***
El que a nosotros nos interesa es id_rsa.pub , abrimos ese archivo  y copiamos su contenido , una vez copiado iremos a gitlab y en preferences nos saldra un menu en la parte izquierda , en ese menu hay una seccion que se llama ssh keys![](https://i.imgur.com/fdbM2Xt.png)
Dentro de esa seccion en la parte que nos pide una key pegaremos lo que copiamos de ***id_rsa.pub***
y guardaremos , asi es como se agrega el ssh key para git 
### Seccion 9
Como hemos agregado nuestra ssh key debemos modificar el remote por que ese esta con un metodo http, asi que borraremos nuestro remote de prueba 
```
git remote  rm prueba
```
Ahora añadiremos el nuevo copiando por el metodo ssh, le pondremos prueba2 y ahora podremos hacer push sin ningun problema 
### Seccion 10
Siempre que trabajmos en git podemos tener ramas , estas ramas trabajan en paralelo con  la rama principal pero sin interferir directamente , en estas ramas se puede trabajar algunas caracteristicas, en nuestro caso crearemos una rama que se llama dev 
pero primero veremos lña listas de rama que hay con el comando 
```
git branch 
```
Veremos que solo existe una rama llamda *Master
Esta rama es la principal de todas, el asterisco es en que rama nos encontramos actualmente  , ahora si crearemos la rama dev 
```
git branch dev 
```
volveremos a listar las ramas y ahora aparecera 
- *master
- dev
### Seccion 11
Nosotros nos encontramos en la rama master y queremos ir a la rama dev asi que para dirigirnos sera con el siguiente comando 
```
git checkout dev 
```
Nos aparecera un mensaje de que hemos cambiado de rama 

### Seccion 12
Vamos a modificar nuestra rama dev , creando un nuevo archivo , a ese nuevo archivo le damos un commit y subimos la nueva  branch a nuestro repositori. Podremos ver la nueva rama en la seccion de branches ![](https://i.imgur.com/bL7Wvh9.png)
### Seccion 13
Cuando una caracteristica este lista , la debemos integrar con la rama principal , para esto dbemos estar en la rama  donde deseamos que se haga la fusion , en nuestro caso queremos fusionar dev con master asi que nos vamos a la rama master, la fusion la haremos con el siguiente comando
```
git merge dev
```

si ya no usamos esa branch la podemos borrar con 
```
git branch -D dev
```
### Seccion 14
Si queremos volver a una  version anterior podemos usar el hisotorial de cambios para póder saber a que version queremos volver, recordemos que cada comit tiene un numero , asi que copiaremos dicho numero y con el siguiente comando volveremos a una version anterior 
```
git checkout ###################
```
y asi volveremos a nuestra  version estable

### Seccion 15
En caso de que hayamos hecho algun commit por error siempre podemos des hacer ese commit con 
```

git reset --soft HEAD~1

```
El -1 significa el numero de pasos que retrocederemos , si ese numero se cambia , sera losnumeros de pasos que retrocederos

### Seccion 16
Hay cosas que no queremos que se incluyan para esto existe .gitignore , esto no es un comando es un archivo que nos ayudara a no incluir cosas cuando hacemos un commit 
crearemos un archivo llamdo ***.gitignore***
Lo abrimos y escribimos rutas relativas o absolutas de carpetas o nombres de archivos 
Ejemplo 
- Creamos un proyecto de npm con 
```
npm init 
```
Se nos creara un package.json 
- Instalamos una libreria 
```
npm i uuid
```
Esto nos creara una carpeta llamda ***node_modules***
![](https://i.imgur.com/mzBfIGf.png)
Esta carpeta es incesesaria para el remote ya qu pueden llegar a pesar GB y puede oacisonar errores , asi que la incluiremos , pero antes checa el estatus del repositorio , nos debe de aparecer algo asi 
![](https://i.imgur.com/cPZeAo4.png)

Ahora si excluiremos node/modules , unicamnte pondremos su ruta relativa dentro del .gitignore ya que estan en el mismo nivel, una vez añadido volveremos a checar nuestro estatus y saldra asi.
![](https://i.imgur.com/aksV9hJ.png)
Como vemos ya no esta node_modules para incluirse asi que si funciona nuestro ignore, ahora excluiremos a todos los archivos que tengan extension ***.json***
esto con el siguiente texto **.json* , el asterisco es para decir todos los que termine con .json , volvemos a checar el estatus y debe salir esto 
![](https://i.imgur.com/PVkLKbd.png)
Tu puedes modificar cada cosa en el ignore para saber que cosas incluir y cuales no.







