Introducción a Git

1

¿Por qué usar un sistema de control de versiones como Git?

2

¿Qué es Git?

3

Instalando Git y GitBash en Windows

4

Instalando Git en OSX

5

Instalando Git en Linux

6

Editores de código, archivos binarios y de texto plano

7

Introducción a la terminal y línea de comandos

Comandos básicos en Git

8

Crea un repositorio de Git y haz tu primer commit

9

Analizar cambios en los archivos de tu proyecto con Git

10

¿Qué es el staging y los repositorios? Ciclo básico de trabajo en Git

11

¿Qué es branch (rama) y cómo funciona un Merge en Git?

12

Volver en el tiempo en nuestro repositorio utilizando reset y checkout

13

Git reset vs. Git rm

Flujo de trabajo básico en Git

14

Flujo de trabajo básico con un repositorio remoto

15

Introducción a las ramas o branches de Git

16

Fusión de ramas con Git merge

17

Resolución de conflictos al hacer un merge

Trabajando con repositorios remotos en GitHub

18

Cambios en GitHub: de master a main

19

Uso de GitHub

20

Cómo funcionan las llaves públicas y privadas

21

Configura tus llaves SSH en local

22

Conexión a GitHub con SSH

23

Tags y versiones en Git y GitHub

24

Manejo de ramas en GitHub

25

Configurar múltiples colaboradores en un repositorio de GitHub

Flujos de trabajo profesionales

26

Flujo de trabajo profesional: Haciendo merge de ramas de desarrollo a master

27

Flujo de trabajo profesional con Pull requests

28

Utilizando Pull Requests en GitHub

29

Creando un Fork, contribuyendo a un repositorio

30

Haciendo deployment a un servidor

31

Hazme un pull request

32

Ignorar archivos en el repositorio con .gitignore

33

Readme.md es una excelente práctica

34

Tu sitio web público con GitHub Pages

Multiples entornos de trabajo en Git

35

Git Rebase: reorganizando el trabajo realizado

36

Git Stash: Guardar cambios en memoria y recuperarlos después

37

Git Clean: limpiar tu proyecto de archivos no deseados

38

Git cherry-pick: traer commits viejos al head de un branch

Comandos de Git para casos de emergencia

39

Git Reset y Reflog: úsese en caso de emergencia

40

Reconstruir commits en Git con amend

41

Buscar en archivos y commits de Git con Grep y log

Bonus sobre Git y Github

42

Comandos y recursos colaborativos en Git y GitHub

43

Tu futuro con Git y GitHub

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Fusión de ramas con Git merge

16/43
Recursos

El comando git merge nos permite crear un nuevo commit con la combinación de dos ramas o branches (la rama donde nos encontramos cuando ejecutamos el comando y la rama que indiquemos después del comando).

Cómo usar Git merge

En este ejemplo, vamos a crear un nuevo commit en la rama master combinando los cambios de una rama llamada cabecera:

git checkout master
git merge cabecera

Otra opción es crear un nuevo commit en la rama cabecera combinando los cambios de cualquier otra rama:

git checkout cabecera
git merge cualquier-otra-rama

Asombroso, ¿verdad? Es como si Git tuviera superpoderes para saber qué cambios queremos conservar de una rama y qué otros de la otra. El problema es que no siempre puede adivinar, sobre todo en algunos casos donde dos ramas tienen actualizaciones diferentes en ciertas líneas en los archivos. Esto lo conocemos como un conflicto.

Recuerda que al ejecutar el comando git checkout para cambiar de rama o commit puedes perder el trabajo que no hayas guardado. Guarda siempre tus cambios antes de hacer git checkout.

Comandos básicos de GitHub

  • git init: crear un repositorio.
  • git add: agregar un archivo a staging.
  • git commit -m “mensaje”: guardar el archivo en git con un mensaje.
  • git branch: crear una nueva rama.
  • git checkout: moverse entre ramas.
  • git push: mandar cambios a un servidor remoto.
  • git fetch: traer actualizaciones del servidor remoto y guardarlas en nuestro repositorio local.
  • git merge: tiene dos usos. Uno es la fusión de ramas, funcionando como un commit en la rama actual, trayendo la rama indicada. Su otro uso es guardar los cambios de un servidor remoto en nuestro directorio.
  • git pull: fetch y merge al mismo tiempo.

Comandos para corrección en GitHub

  • git checkout “codigo de version” “nombre del archivo”: volver a la última versión de la que se ha hecho commit.
  • git reset: vuelve al pasado sin posibilidad de volver al futuro, se debe usar con especificaciones.
  • git reset --soft: vuelve a la versión en el repositorio, pero guarda los cambios en staging. Así, podemos aplicar actualizaciones a un nuevo commit.
  • git reset --hard: todo vuelve a su versión anterior
  • git reset HEAD: saca los cambios de staging, pero no los borra. Es lo opuesto a git add.
  • git rm: elimina los archivos, pero no su historial. Si queremos recuperar algo, solo hay que regresar. se utiliza así:
    git rm --cached elimina los archivos en staging pero los mantiene en el disco duro.
    git rm --force elimina los archivos de git y del disco duro.

Comandos para revisión y comparación en GitHub

  • git status: estado de archivos en el repositorio.
  • git log: historia entera del archivo.
  • git log --stat: cambios específicos en el archivo a partir de un commit.
  • git show: cambios históricos y específicos hechos en un archivo.
  • git diff “codigo de version 1” “codigo de version 2”: comparar cambios entre versiones.
  • git diff: comparar directorio con staging.

Aporte creado por: Pedro Alejandro Silva.

Aportes 1266

Preguntas 244

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

es absurdo lo buen profesor que es freddyyyy que haga mas cursoooos

Comparo mis apuntes hasta el momento

Hola compañeros, les comparto una página donde pueden practicar con diferentes retos y ver de una manera gráfica los que se está haciendo, espero que les ayude.

https://learngitbranching.js.org/
Saludos.

Dejo esto por aquí. Nota relacionada al tema de la clase:

¡Nunca pares de aprender! (Y practicar)🦄

Quiero mostrarles esta extensión de Vistual Studio Code donde se ve graficamente todo el proceso de merge y las diferentes ramas.

**Comparto mis apuntes **😃

Slds,

Este es un pdf bien chido con los comandos de Git para imprimirlo y tenerlo a la mano.

https://education.github.com/git-cheat-sheet-education.pdf

un tip

git log --graph

eso nos da una vision de grafico de las ramas y como se fusionaron, recomiendo hacer eso despues de fusionar

Estoy utilizando VSC y al hacer el merge me sale esto en el código, alguien mas le sale?

Mis apuntes 😃

Extructuta

Directorio de trabajo | preparacion o staing | repositirio local || repositirio remoto

  1. git init [iniciar el repositorio]
  2. git add biografia.txt [añadir el archivo]
  3. git commit -m “version 1” [guardar en la base de datos del repositorio]
  4. git add . [añadir todos los cambios hechos a la base de datos del repositorio]
  5. git commit -m “Cambios a v1” [guadar los cambios en la db del repositorio]
  6. git status [muestra el estado de los archivos de la base de datos]
  7. git show [cambios que se han hecho]
  8. git log biografia.txt [muestra el historial de cambios de un archivo]
  9. git push [enviar hacia otro repositorio remoto lo que yo estoy haciendo]
  10. git pull [permite traer de cualquier repositorio remoto combinando dos comandos 28. y 29.]
  11. git status [estado del proyecto en este momento]
  12. git rm historia.txt [devolver el comando 2. y 13. ]
  13. git rm --cached historia.txt [descachearlo lo de debaja en la ram “ya no 😃” ligado al comando 12.]
  14. git commit -m “primer commit” [realizar un cambio, ya para guardar]
  15. git config [todas las configuraciones de git]
  16. git config --list [ver la configuracion de git]
  17. git config --list --show-origin [ver donde esta ubicado los archivos de configuracion]
  18. git config --global user.name “Andres Leon” [colocarle un nombre para saber quien esta haciendo cambios]
  19. git config --global user.email "[email protected]" [colocarle un email para saber quien esta haciendo cambios]
  20. git log historia.txt [ver el historial de este archivo]
  21. git show historia.txt [ver las modificaciones que han existido]
  22. git commit [cuando se va sin mensaje el lo pide y la forma de salir es "comandos 17. " y para empezar a escribir dentro de “vi” 18. ]
  23. git diff 3f9221603091ac205cea6fa2f88710da3857a482 e549b6799aa407cfbb7034c22b817577c85c44dc [compara dos commit]
  24. git reset effa0d5de0734e75a7aa0186a36d36b218c45865 --hard [la version a la que quiero volver]
  25. git log --stat [ver los cambios del historial mas detallado, con la letra “q me pueda salir si lo que se muestra es muy largo”]
  26. git checkout e549b6799aa407cfbb7034c22b817577c85c44dc historia.txt [checar un commit anterior y se quiere se hace un reeemplazo con el comando 04. y 05.]
  27. git checkout master [checar el ultimo commit]
  28. git fetch [actualizar mi repositirio local con los cambios subidos en el remoto]
  29. git merge [combinar lo del repositorio remoto con mi directorio de trabajo || combinar ramas]
  30. git commit -a -m “se modifico algo” [aplicar 04. y 05. en un solo comando]
  31. git branch cabecera [crear una rama]
  32. git checkout cabecera [cambiar entre ramas]
  33. git branch [saber que ramas existen]

------------------------comandos en la consola y navegacion----------------------

  1. pwd [en donde estoy parado]
  2. mkdir [crear una carpeta]
  3. cat nombre_del_archivo.txt [ver el contenido de un archivo]
  4. cd [navegar entre carpetas]
  5. rm [borrar una carpeta o archivo]
  6. ls [listar todo en donde este parado en el sistema]
  7. ls -al [listar con argumentos]
  8. clear [limpiar la consola de git]
  9. cd [entrar a una carpeta]
  10. cd … [devolverme o salir de esta carpeta]
  11. cd /c [ir a un disco en especifico]
  12. history [ultimos comandos que he ingresado]
  13. para escoger alguno de la lista que aparece !25
  14. touch vacio.txt [crear un archivo vacio]
  15. rm --help [ayuda de como funciona cada comando “rm” puede ser diferente]
  16. code historia.txt [iniciar este archivo con vs]
  17. esc pausa y ingresar shif + z + z [para guardar y salir de “vi”]
  18. espace + i [para poder empezar a escribir en “vi”]

Amigos hice un resumen bien chido con emojis y todo
Link de resumen

Estos son mis apuntes un resumen, una referencia corata para repasar

COMANDOS BÁSICOS
git init: crear un repositorio.
git add: agregar un archivo a staging.
git commit -m “mensaje”: guardar el archivo en git con un mensaje.
git branch : crear una nueva rama.
git checkout: moverse entre ramas.
git push: mandar cambios a un servidor remoto.
git fetch: traer actualizaciones del servidor remoto y guardarlas en nuestro repositorio local.
git merge: tiene dos usos. Uno es la fusión de ramas, funcionando como un commit en la rama actual, trayendose la rama indicada. El otro uso es guardar los cambios de un servidor remoto en nuestro directorio.
git pull: fetch y merge al mismo tiempo.

COMANDOS PARA VOLVER O CORREGIR
git checkout “codigo de version” “nombre del archivo”: volver a la ultima version commiteada.
git reset: vuelve al pasado sin posibilidad de volver al futuro, se debe usar con especificaciones.
git reset --soft vuelve a la versión en el repositorio pero guarda los cambios en staging, así podemos aplicar actualizaciones a un nuevo commit.
git reset --hard TODO VUELVE A LA VERSIÓN ANTERIOR
git reset HEAD saca los cambios de staging pero no los borra, es lo opuesto a git add.
git rm: elimina los archivos pero no su historial, si queremos recuperar algo solo hay que regresar, se usa así:
git rm --cached elimina los archivos en staging pero los mantiene en el disco duro.
git rm --force elimina los archivos de git y del disco duro.

COMANDO PARA REVISAR Y COMPARAR
git status: estado de archivos en el repositorio.
git log: historia entera del archivo.
git log --stat: cambios específicos en el archivo a partir de un commit.
git show: cambios históricos y específicos hechos en un archivo.
git diff “codigo de version 1” “codigo de version 2”: comparar cambios entre versiones.
git diff: comparar directorio con staging.

![](

Cuando Freddy ve que no estás practicando lo que aprendes en las clases
Posdata: Nunca pares de aprender

Podemos ver un árbol de ramas en nuestra consola con el comando

git log --oneline --graph

los flags que acompañan al comando pueden ejecutarse individualmente.

Sin conocimientos de html, traté de hacer un pequeño html con todos los comandos, a continuación les dejo la imagen de como queda y un poco más abajo el código tanto html como css.

![](

html

<html>
    <head>
        <title>Curso GIT</title>
        <link rel="stylesheet" href="css/styles.css">
    </head>        
    <body>
        
        <div id="container">
            <div id="cabecera">
                TodoGit <span id="tagline">Tools</span>
            </div>
            <div id="post">
                <h1>Comandos</h1>
                <p align="center">Información sobre los comandos vistos en el curso</p>
                
                
                <table class="t-comands"  align="center">
                    
                    <thead>
                        <tr>
                            <td>Comando</td>
                            <td>Detalle</td>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td>git init</td>
                            <td>Ubicado dentro de un folder, se inicia el directorio de trabajo</td>
                        </tr>
                        <tr>
                            <td>git status</td>
                            <td>Ver el estado del folder</td>
                        </tr>
                        <tr>
                            <td>git add %nombrearchivo%</td>
                            <td>Agregar un archivo al staging</td>
                        </tr>
                        <tr>
                            <td>git rm %nombrearchivo%</td>
                            <td>Remover un archivo del staging</td>
                        </tr>
                        <tr>
                            <td>git rm --cached %nombrearchivo%</td>
                            <td>Removerlo completamente del staging</td>
                        </tr>
                        <tr>
                            <td>git rm --force %nombrearchivo%</td>
                            <td>Removerlo completamente del staging y el disco</td>
                        </tr>
                        <tr>
                            <td>git commit -m "Mensaje especifico"</td>
                            <td>Enviarlo al master</td>
                        </tr>
                        <tr>
                            <td>git config
                                git config --list
                                git config --list --show-origin
                            </td>
                            <td>Ver la configuración de git</td>
                        </tr>
                        <tr>
                            <td>
                                git config --global user.name "NombreUsuario"
                                <br />git config --global user.email "[email protected]"
                            </td>
                            <td>Agregar usuario y email</td>
                        </tr>
                        <tr>
                            <td>git log %nombrearchivo%</td>
                            <td>Ver cambios o historia de un archivo</td>
                        </tr>
                        <tr>
                            <td>git show  %nombrearchivo%</td>
                            <td>Mostrar más información de las modificaciones del archivo</td>
                        </tr>
                        <tr>
                            <td>git reset  -alfanumerico-   --hard o --soft</td>
                            <td>Devolver un archivo a un punto en la historia
                                <br />Tener mucho cuidado porque este comando borra todos los cambios adicionales que se hicieron</td>
                        </tr>
                        <tr>
                            <td>Permite visualizar los bits por commit</td>
                            <td>git log --stat</td>
                        </tr>
                        <tr>
                            <td>
                                      Permite visualizar un archivo con la información de ese momento
                                <br />se debe tener cuidado de no hacer commit en ese momento,
                                <br />porque se perderia la información
                            </td>
                            <td>git checkout -alfanumerico- %nombrearchivo%</td>
                        </tr>
                        <tr>
                            <td>si quiero volver al archivo</td>
                            <td>git checkout master %nombrearchivo%</td>
                        </tr>
                        <tr>
                            <td>Pararse en la rama</td>
                            <td>git checkout %nombrerama%</td>
                        </tr>

                    </tbody>    

                </table>


            </div>
        </div>
        
        
    </body>

</html>   

css

body
{
    color: #333;
    text-align: center;
    font-family: Arial;
    font-size: 16px;
    margin: 0;
    padding: 0;
}



#cabecera
{
    background: #33A;
    box-shadow: 0px 2px 20px 0px rgba(0, 0, 0, 0.5);
    color: white;
    font-weight: bold;
    margin: 0;
    padding: 0.5em; 
}

#cabecera #tagline
{
  
    padding: 0 0 0 1em;
    font-weight: normal ;
    font-size: 0.8em;
}

#container
{
    width: 70%;
    padding: 1em;
    text-align: left;
    border: 1px solid #DDD;
    margin: 0 auto;

}

#container h1
{
   font-size: 20px;
   text-align: center;
}

.t-comands thead td{
    border: none;
    text-align: center;
    font-weight: bold;
    width: 50%;
    padding: 10px 0;
    margin: 1em;
    background-color: rgb(133, 133, 133);
    box-shadow: 0px 2px 20px 0px rgba(0, 0, 0, 0.5);
    color: white;
}

.t-comands tbody td{
    border: none;
    text-align: left;
    width: 50%;
    padding: 10px 0;
    margin: 1em;
}


tr:nth-child(odd) {
    background-color:#f2f2f2;
}
tr:nth-child(even) {
    background-color:#fbfbfb;
}

Hasta este punto estaba un poco perdido con los comandos y la lógica de las ramas cuando me movía en el tiempo con los checkout, pero con algo de práctica y repetición logré tenerlo un poco más claro. También me ayudó descubrir que dentro de git existe una interfaz que permite ver de forma gráfica cual ha sido el historial de cambios, en que punto me encuentro y cuales ramas existen junto con todos los detalles que brinda el mismo comando log.
Dejo una imagen de como se puede acceder a ella por si a alguien le interesa y no la ha descubierto.

Les dejo mis apuntes que se encuentran en la nube y pueden hacer mejoras para que tengamos unos super apuntes para todos

https://docs.google.com/document/d/1wZNYJtQmxOo7vqvtKozfFoOzKiwfgjXvjzRYvF9UCTg/edit?usp=sharing

Apuntes !

lINEA DE COMANDO

COMANDOS:
cd = Siempre que escribamos la palabra cd, iniciamos en la carpeta de archivos c/users/ManuelR
cd … = es para ir a la carpeta anterior
mkdir “nombre de la carpeta” = Es para crear una nueva carpeta
cd “nombre de la carpeta” = Es para entrar en una carpeta
pwd = Es para saber en que carpeta estamos actualmente
touch “Nombre del archivo” = Es para crear un archivo vacío
cat “nombre de archivo” = Es para entrar al contenido de un archivo.
rm “nombre del archivo” = Es para eliminar archivos.
ls =mostrar lista de todos los elementos que hay en la ubicación en la que estas.
ls -al = muestra la lista de todos las carpetas con sus respectivos elementos que hay en la ubicación incluios los ocultos.
ls -a muestra los elementos que hay en la ubicación pero en carpetas.
ls -l = muestra los elementos en lista que hay en la ubicación.

Comandos Git
git init = Es para iniciar a usar Git
git add . “or” “nombre del archivo” = Es para agregar el archivo que deseamos a la fase de tracked o stadding
git status = Nos permite saber en que fase nos encontramos actualmente
code = Podemos entrar directamente a VSCode y modificar el codigo que qeurramos
git rm “Nombre del archivo” = Nos permite remover el archivo wue esta en stadding
git rm --cached “nobre del archivo” = Nos permite remover el archivo de la ubicacion en memoria en la que
se encuentra, es como si le quitaramos el add.
git commit -m “mensaje o descripcion” = Nos permite enviarlo a la fase de repositorio, a la rama Master.
git show “nombre del archivo” = Nos permite poder mirar la ultima modificacion que se la ha realizado al archivo
git log “nombre del archivo” = Nos permite poder observar todos los commits que se han, quien los realizo y en que fecha.
git diff “codigo del archivo” “space” “nombre del otro archvi a comparar”= Nos permite poder comparar 2 archivos y
mirar que cambios se han echo en cada uno.Ademas de que si escribimos solo
git diff, podemos observar y comparar los cambios que se han echo
al archivo en el directorio con los del archivo en stadding.
esc + shif + z,z = Nos permite poder salir del editor de texto de Git.
esc + i = Nos permite poder intsertat un mensaje en el edtior de texto de Git, llamado VIM.
git log --stat : Podemos ver todos los cambios que se han realizado junto con los commits.
git checkout “codigo del commit” “nombre del archivo” = Nos permite poder regresar una version del archivo pero solo
en el directorio, en el master aun sigue estando el archivo master, pero si hacemos un commit los archivos
se reemplazaran por el del directorio. Perderiamos todo lo que estaba en el HEAD, pero queda en el historial
de Git, podriamos volver de nuevo a realizar un checkout con la version que cambiamos y recuperar el master head que teniamos.

Git reset y git rm son comandos con utilidades muy diferentes, pero aún así se confunden muy fácilmente.
git rm
Este comando nos ayuda a eliminar archivos de Git sin eliminar su historial del sistema de versiones. Esto quiere decir que si
necesitamos recuperar el archivo solo debemos “viajar en el tiempo” y recuperar el último commit antes de borrar el archivo en cuestión.

Recuerda que git rm no puede usarse así nomás. Debemos usar uno de los flags para indicarle a Git cómo eliminar los archivos que ya no
necesitamos en la última versión del proyecto:

git rm --cached: Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.
git rm --force: Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder
al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).
git reset
Este comando nos ayuda a volver en el tiempo. Pero no como git checkout que nos deja ir, mirar, pasear y volver.
Con git reset volvemos al pasado sin la posibilidad de volver al futuro. Borramos la historia y la debemos sobreescribir.
No hay vuelta atrás.

Este comando es muy peligroso y debemos usarlo solo en caso de emergencia. Recuerda que debemos usar alguna de estas dos opciones:

Hay dos formas de usar git reset: con el argumento --hard, borrando toda la información que tengamos en el área de staging
(y perdiendo todo para siempre). O, un poco más seguro, con el argumento --soft, que mantiene allí los archivos del área de staging
para que podamos aplicar nuestros últimos cambios pero desde un commit anterior.

git reset --soft: Borramos todo el historial y los registros de Git pero guardamos los cambios que tengamos en Staging, así podemos aplicar las últimas actualizaciones a un nuevo commit.
git reset --hard: Borra todo. Todo todito, absolutamente todo. Toda la información de los commits y del área de staging se borra del historial.
¡Pero todavía falta algo!

git reset HEAD: Este es el comando para sacar archivos del área de Staging. No para borrarlos ni nada de eso, solo para que los últimos
cambios de estos archivos no se envíen al último commit, a menos que cambiemos de opinión y los incluyamos de nuevo en
staging con git add, por supuesto.
¿Por que esto es importante?
Imagina el siguiente caso:

Hacemos cambios en los archivos de un proyecto para una nueva actualización.
Todos los archivos con cambios se mueven al área de staging con el comando git add.
Pero te das cuenta de que uno de esos archivos no está listo todavía. Actualizaste el archivo pero ese cambio no debe ir en el próximo commit
por ahora.

¿Qué podemos hacer?

Bueno, todos los cambios están en el área de Staging, incluido el archivo con los cambios que no están listos.
Esto significa que debemos sacar ese archivo de Staging para poder hacer commit de todos los demás.
¡Al usar git rm lo que haremos será eliminar este archivo completamente de git! Todavía tendremos el historial de cambios de este archivo,
con la eliminación del archivo como su última actualización. Recuerda que en este caso no buscábamos eliminar un archivo, solo dejarlo
como estaba y actualizarlo después, no en este commit.
En cambio, si usamos git reset HEAD, lo único que haremos será mover estos cambios de Staging a Unstaged.
Seguiremos teniendo los últimos cambios del archivo, el repositorio mantendrá el archivo
(no con sus últimos cambios pero sí con los últimos en los que hicimos commit) y no habremos perdido nada.

git branch “nombre de la nueva cabecera” = Me permite poder crear otra rama adquiriendo los archivos desde
donde se ha realizado el ultimo commit de la rama en la que me encuentre.
git checkout “nombre de la rama” = Nos permite poder navegar y pasar de una rama y apuntar a otra.

git merge “nombre de la rama que se quiere fusionar” = Nos permite poder unir dos ramas y el merge se realiza donde se quiere tener el resultado o archivo final.

Pueden guardarlas en evernote
- git merge “cabecera”: Estando en la rama master, escribo git merge nombre rama, en este ejemplo la rama se llama cabecera y se trae la rama cabecera.
- git checkout “nombre”: Para cambiar entre ramas, log, o el archivo master
**- git branch: **Para crear una rama del documento
- git commit -a: Igual que git commit -am “Comentario” pero este dispara una interfaz donde coloco el comentario, y para guardar esc+shift+z
- git commit -am “Comentario”: Para hacer commit a archivos a los que ya le he realizado el add
- git clone url_del_servidor_remoto: Nos permite descargar los archivos de la última versión de la rama principal y todo el historial de cambios en la carpeta .git.
- git push: Luego de hacer git add y git commit debemos ejecutar este comando para mandar los cambios al servidor remoto.
- git fetch: Lo usamos para traer actualizaciones del servidor remoto y guardarlas en nuestro repositorio local (en caso de que hayan, por supuesto).
- git merge: También usamos el comando git fetch con servidores remotos. Lo necesitamos para combinar los últimos cambios del servidor remoto y nuestro directorio de trabajo.
- git pull: Básicamente, git fetch y git merge al mismo tiempo.
- git reset HEAD: Este es el comando para sacar archivos del área de Staging. No para borrarlos ni nada de eso, solo para que los últimos cambios de estos archivos no se envíen al último commit, a menos que cambiemos de opinión y los incluyamos de nuevo en staging con git add, por supuesto.
- git reset --soft: Borramos todo el historial y los registros de Git pero guardamos los cambios que tengamos en Staging, así podemos aplicar las últimas actualizaciones a un nuevo commit.
- git reset --hard: Borra todo. Todo todito, absolutamente todo. Toda la información de los commits y del área de staging se borra del historial.
- git rm --cached: Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.
- git rm --force: Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).
- git checkout master nombredearhivo.extensión: Ver la versión del master, y ya no la primera versión. Es decir la última versión
**- git checkout “código log” nombredearhivo.extensión: **Ver primera versión del archivo, si no se hace commit no se graba el cambio, pero lo puedo visualizar mientras
- git log --stat: Para observar cambios específicos que se hicieron y en cuales archivos a partir del commit (se ve los cambios en bite y/o carpeta)
- git reset “Código de un log” --hard: Para volver a una versión del archivo de forma literal a como estaba antes. Se borran las otras modificaciones
- git reset “Código de un log” --soft: Para volver a una versión del archivo dejando  lo que que está en el staging (comando add, ubicado en la RAM)
- git reset “Código de un log”: Para volver a una versión anterior.
- git diff “código de un log” “código de otro log”: Es para identificar los cambios que hay entre una versión y otra. El código del log se ubica con git log nombredearchivo.extensión. El orden importa, según el orden en que coloque el log me va a indicar si se agrega una línea o si se quita. El primero en colocar es el que va a tomar como original
- VIM: El editor de texto, la pantalla que aparece cuando se hace commit sin comentar
**- Esc + shift + zz **(para salir y guardar de la pantalla que aparece cuando no se hacen comentarios) + zq (para salir sin guardar de la pantalla que aparece cuando no se hacen comentarios)
- git show nombredearchivo.extensión:: Muestra todos los cambios realizados al archivo
- git log nombredearchivo.extensión: Trae todos los commit realizados en el archivo
- git add . : Añadir todos los cambios al stage (RAM)
- git config --global user.email "[email protected]": Para identificar el nombre y el correo de la ersona que va a hacer los cambios
- git config --global user.name “Tu Nombre”

  • Con un solo- se usan las letras, con dos – se usan palabras
    - git config: Ver toda la configuración de git
    - git config --list: La lista de los elementos configurados
    - git config --list --show-origin: Para ver donde están las configuraciones guardadas
    ****- git commit -m “”: para subir un commit con un mensaje
    - git rm --cached: Para borrar un archivo cuando ha sido añadido sólo con el comando add rm --cached nombrearchivo.extensión saca al archivo de la ram que la mantiene si no hay commint
    - git status: Para chequear el estado de una carpeta respecto a los cambios del control de versiones
    **- git ini: **Para iniciar una carpeta con el control de versiones de repositorio
    **- pwd: **Nos muestra la ruta de carpetas en la que te encuentras ahora mismo.
    - mkdir: Nos permite crear carpetas (por ejemplo, mkdir Carpeta-Importante).
    - touch: Nos permite crear archivos (por ejemplo, touch archivo.txt).
    - rm: Nos permite borrar un archivo o carpeta (por ejemplo, rm archivo.txt). Mucho cuidado con este comando, puedes borrar todo tu disco duro.
    - cat: Ver el contenido de un archivo (por ejemplo, cat nombre-archivo.txt).
    - ls: Nos permite cambiar ver los archivos de la carpeta donde estamos ahora mismo. Podemos usar uno o más argumentos para ver más información sobre estos archivos (los argumentos pueden ser – + el nombre del argumento o - + una sola letra o shortcut por cada argumento).

    - ls -a: Mostrar todos los archivos, incluso los ocultos.

    - ls -l: Ver todos los archivos como una lista.

  • cd: Nos permite navegar entre carpetas.

    - cd /: Ir a la ruta principal:

    - cd o cd ~: Ir a la ruta de tu usuario

    - cd carpeta/subcarpeta: Navegar a una ruta dentro de la carpeta donde estamos ahora mismo.

    - cd … (cd + dos puntos): Regresar una carpeta hacia atrás.

    • Si quieres referirte al directorio en el que te encuentras ahora mismo puedes usar cd . (cd + un punto).
  • history: Ver los últimos comandos que ejecutamos y un número especial con el que podemos repetir su ejecución.

  • ! + número: Ejecutar algún comando con el número que nos muestra el comando history (por ejemplo, !72).

  • clear: Para limpiar la terminal. También podemos usar los atajos de teclado Ctrl + L o Command + L.

Mis apuntes:

No invoqué a los Dioses del desarrollo 😦

Algunos comandos para uso de VIM (editor de texto por defecto en línea de código):

tecla i: para entrar en modo de edición en el cual podrás escribir los cambios requeridos.
Esc + Shift (sostenido) + z + z: Para guardar cambios realizados.
Esc + : + w + q: También utilizado para guardar cambios, aunque no se hayan hecho cambios.
Esc + : + x: Para salir del editor sin guardar cambios.
Esc + : + q + !: Finaliza el editor sin guardar cambios y tampoco alertar sobre ellos.

Mis pocos apuntes para al que le sea de utilidad
cd //Muestra el home
pwd //Muestra la direccion actual
ls //Archivos dentro de la direccion actual sin listar
ls -al //Listado de Archivos dentro de la direccion actual ocultos y visibles
mkdir //Crea una carpeta en la direccion actual
touch //Crea un archivo ejem: .txt
cat //Lee un archivo plano de arriba a abajo
tac //Lee el archivo de abajo hacia arriba
vim //Permite modificar el archivo
:w //Guarda los cambios en el archivo
:q //Cierra el archivo
:q! //Fuerza el cierre del archivo sin guardar cambios
code //Abre el Visual Studio code
history //Muestra el historial de comando utilizados
git init //Inicia un master en la carpeta donde estemos ubicados
git status //Muestra el status del proyecto, si hay archivos que sufrieron alteraciones y si se les esta dando seguimiento a estas
git add //Agrega un archivo al Staging
git commit //Lo manda al repositorio
got commit -m “Comentario” //Deja un comentario en el cambio, buena practica
git rm --catch //Elimina los archivos del área de Staging
git rm --force // Elimina los archivos de Git y del disco duro.
git config //Todas las configuraciones de git como funcionan
git config --list //La configuracion por defecto de el git
git config --list --show–origin //Donde estan las configuracion guardadas
git config --global //Vamos a cambiar todos los usuarios globales

  • //Usas las letras
    – //Usas la palabra completa
    git config --global user.name “Elio Tapia” //Darle nombre al usuario del git
    git confi --global user.email "[email protected]" //Darle un correo al usuario del git
    git add . //Añade todos los archivos con cambios dentro de la carpeta del git al Staging
    git log NombreDelArchivo //Muestra el historial del archivos
    git show NombreDelArchivo //Muestra la ultima version del archivo y lo compara con la version anterior
    git commit //Te va a pedir un mensaje, lo pones y para salir es Esc Shift Z Z
    git diff VersionActual VersionAComporar //Compara dos versiones
    git reset //Permite volver a un reset anterior
    git reset Numerodelarchivo --hard //Vuelve en el tiempo elimina todo lo que se haya agregadp
    git reset NumeroDelArchivo --soft //Vuelve a la version anterior
    git reset HEAD //Este es el comando para sacar archivos del área de Staging.
    git log --stat //Muestra los cambios del archivo se sale con q
    git checkout NumeroDelArchivo ArchivoDeRegreso //Para ver como era el archivo antes
    git show //Muestra informacion del ultimo cambio realziado
    git commit -am “Comentario” //Manda directamente al repositorio
    git checkout NombreRama //Movernos entre ramas
    //Respaldo master
    git merge NombreDeLaRama //Fuciona dos ramas, se debe estar en la rama principal
    git log --graph --all //Se dibura una reprensentacion grafica de las ramas

Mis apuntes de comandos GIT hasta ahora:
git init -> inicia el repositorio, deberia correrse este comando sobre la carpeta principal del proyecto o donde deseamos llevar el control de versiones.

git add <nombre del archivo> -> agregamos al staging area los archivos que deseamos traquear con git.

git add . -> agrega al staging area solo los archivos que han sido modificacos recientemente.

git rm <nombre del archivo> -> borra del repositorio un archivo en especifico.

git rm --cached <nombre del archivo> -> borra los archivos que se encuentran en el staging area.

git rm --force <nombre del archivo> -> Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).

git commit -m “mensaje o explicacion de que se modifico” -> pasa los archivos del staging area al repositorio de git, llevando asi el control de todas la modificaciones.

git status -> nos indica si se han modificado los archivos que se encuentran trackeados desde el ultimo commit.

git log -> nos muestra un historico de todos los commit que se han realizado en el proyecto.

git show <nombre del archivo> -> nos muestra la modificaciones sobre el archivo desde el ultimo commit.

git diff <codigo del commit1> <codigo del commit2> -> nos muestra la diferencia entre un commit y el otro linea por linea del archivo o archivos afectados.

git reset <codigo del commit> -> Nos permite regresar en el tiempo a commit anteriores hay dos metodos (–soft) regresa el area de trabajo al commit indicado pero deja en staging los cambios realizados y (–hard) regresa todo el tiempo tanto el area de trabajo como el staging como el repositorio.

git reset HEAD -> Este es el comando para sacar archivos del área de Staging. No para borrarlos ni nada de eso, solo para que los últimos cambios de estos archivos no se envíen al último commit, a menos que cambiemos de opinión y los incluyamos de nuevo en staging con git add, por supuesto.

gir checkout <codigo del commit> <nombre del archivo> -> Nos permite regresar en el tiempo un archivo en particular respetando los demas se puede volver a su ultimo estado colocando git checkout master <nombre del archivo> o si lo deseo proceso un nuevo commit manteniendo el archivo en su estado anterior.

git branch <nombre de la nueva rama> -> Crea una nueva rama desde el commit en el cual nos encontremos en ese momento.

gti checkout <nombre de la rama> -> Nos permite movernos entre las ramas del proyecto.

git branch -> Nos dice las ramas que existen en el repositorio y nos marca en cual estamos en ese momento.

git merge <nombre de la rama a fucionar> -> Nos permite fucionar dos ramas para ello debemos colocarnos en la rama princial o en la rama que queremos quede despues de la fucion y ejecutamos el comando con la rama que deseamos unir.

git init - Convertir una carpeta en un repositorio (master)
git add . - agregar archivos al estado staying
**git status **- muestra el status del repositorio.
git rm --cached “nombre del archivo.xxx - saca al archivo del staying y lo devuelve al estado original (lo borra de la memoria del repo”
git commit -m “mensaje” - sube los cambios a la rama
**git commit -am “mensaje” **- sube los cambios sin necesidad de hacer git add .
git checkout - traer los cambios hacia la carpeta de trabajo.
git checkout “codigo del commit” archivo.xxx - permite traer una version vieja de commit
git checkout master archivo.xxx - permite traer a la carpeta de trabajo la version de master
git log: muestra los cambios de la rama
git config: muestra la configuración del repo
**git config --global user.name “Nombre” **- camibio el nombre del usuario
git config --global user.email “Email” - camibio el email del usuario
git show “nombre del archivo” - muestra los cambios sufridos en un archivo específico.
git diff “código commit 1” “codigo commit 2” - muestra la diferencia entre dos commit
**git reset “codigo de commit” --hard **- vuelve a la versión del commit y no deja nada en staying
**git reset “codigo de commit” --soft ** - vuelve a la versión del commit y deja en staying lo que estaba allí.
git log --stat - se ven los cambios de todos los archivos en el repo con detalles
git commit -am “mensaje del commit” - sue los cambios a la rama sin necesidad de hacer add al staging
git branch - muestra las ramas del repo
git merge “nombre de la rama que se quiere fusionar” - une dos ramas del repo

Notas:
Cada commit es una versión independiente del código y necesita un mensaje como buena práctica.
Branch : romper en diferentes líneas de tiempo el trabajo del grupo.

Freddy es simplemente un genio de la explicación, acá mi aporte con los apuntes tomados hasta el momento.

Mis apuntes los hice a modo de manual personal, y para mi uso están perfectos.
Espero que les sirvan, aunque no tengan un orden en específico:

INICIAR GIT:


git init
Le indicaremos a Git que queremos crear un nuevo repositorio para utilizar
su sistema de control de versiones. Solo debemos posicionarnos en la carpeta
raíz de nuestro proyecto y ejecutar el comando git init.

Recuerda que al ejecutar este comando (y de aquí en adelante) vamos a tener una
nueva carpeta oculta llamada .git con toda la base de datos con cambios atómicos
en nuestro proyecto.

Recuerda que Git está optimizado para trabajar en equipo, por lo tanto, debemos
darle un poco de información sobre nosotros. No debemos hacerlo todas las veces
que ejecutamos un comando, basta con ejecutar solo una sola vez los siguientes
comandos con tu información:

git config --global user.email "[email protected]"
git config --global user.name "Tu Nombre"
Existen muchas otras configuraciones de Git que puedes encontrar ejecutando el
comando git config --list (o solo git config para ver una explicación
más detallada).


Cambiar archivos de config:


git config --global --unset-all user.name

Ahora puedes configurar el dato que desees: ejemplo:
git config --global --add user.name <whatever>


Crear ramas:


git branch nombredelarama

Entrar a una rama:
git checkout nombredelarama
CUIDADO!! no cambiar de rama si los commits no se guardaron!
SE BORRARAN

git branch
muestra qué ramas hay

git merge nombredelarama -m "nombre del commit del merge"
git merge nombredelarama
fusionar la rama del comando hacia la rama en la que estoy
ejemplo: git merge cabecera
y estoy en la rama master
entonces: hará un merge con los datos
de cabecera en la rama master


Regresar en el tiempo


El comando git checkout + ID del commit ( número super largo ) + nombre de archivo
nos permite viajar en el tiempo.
Podemos volver a cualquier versión anterior de un archivo específico
o incluso del proyecto entero. Esta también es la forma de crear ramas y
movernos entre ellas.
EJEMPLO: git checkout 213123123123123123123 historia.txt
EJEMPLO2: git checkout master historia.txt
*También se puede regresar a los últimos cambios, poniendo
"master" en vez del número del commit


Analizar cambios en los archivos de tu proyecto con Git


git diff commitA commitB
Diferencias entre un commit antiguo (A) y uno reciente (B)

git log
Recuerda que puedes obtener el ID de tus commits con el comando git log.
También sus nombres y su fecha de modificación

git log --stat
Además te muestra el número de cambios y qué archivos se modificaron en
cada commit

git show
Muestra los últimos cambios hechos


BÁSICO:


git add NOMBRE DE ARCHIVO
ejemplo: git add historia.txt

git add .
Agrega todos los cambios de archivos al staging

git commit -m "mensaje del commit"
Agrega un nuevo commit (agrega versiones)

git commit -a / git commit -am "nombre del commit"
Agrega un commit sin tener que poner "add"
Solo para los archivos que ya han sido añadidos antes al proyecto

Branch y ramas:
Master (versiones actuales)
Development (versiones experimentales)
HotFix (Correcciones de bugs)

git commit --amend -m "nombre nuevo"
cambia el nombre del ultimo commit


¿Qué es el staging y los repositorios? Ciclo básico de trabajo en Git:


Archivos Tracked: son los archivos que viven dentro de Git,
no tienen cambios pendientes y sus últimas actualizaciones han sido
guardadas en el repositorio gracias a los comandos git add y git commit.
Archivos Staged: son archivos en Staging. Viven dentro de Git y hay registro
de ellos porque han sido afectados por el comando git add, aunque no sus últimos
cambios. Git ya sabe de la existencia de estos últimos cambios, pero todavía no
han sido guardados definitivamente en el repositorio porque falta ejecutar el
comando git commit.

Archivos Unstaged: entiéndelos como archivos “Tracked pero Unstaged”.
Son archivos que viven dentro de Git pero no han sido afectados por el comando
git add ni mucho menos por git commit. Git tiene un registro de estos archivos,
pero está desactualizado, sus últimas versiones solo
están guardadas en el disco duro.

Archivos Untracked: son archivos que NO viven dentro de Git, solo en el disco duro.
Nunca han sido afectados por git add, así que Git no tiene registros de su existencia.
Recuerda que hay un caso muy raro donde los archivos tienen dos estados al mismo
tiempo: staged y untracked. Esto pasa cuando guardas los cambios de un archivo en
el área de Staging (con el comando git add), pero antes de hacer commit para guardar
los cambios en el repositorio haces nuevos cambios que todavía no han sido guardados
en el área de Staging (en realidad, todo sigue funcionando igual pero es un poco
divertido).

Comandos para mover archivos entre los estados de Git:
git status: nos permite ver el estado de todos nuestros archivos y carpetas.

git reset HEAD: nos ayuda a sacar archivos del estado Staged para devolverlos a
su estado anterior. Si los archivos venían de Unstaged, vuelven allí. Y lo mismo
se venían de Untracked.

git commit: nos ayuda a mover archivos de Unstaged a Staged. Esta es una ocasión
especial, los archivos han sido guardado o actualizados en el repositorio. Git nos
pedirá que dejemos un mensaje para recordar los cambios que hicimos y podemos
usar el argumento -m para escribirlo (git commit -m “mensaje”).

git rm: este comando necesita alguno de los siguientes argumentos para poder
ejecutarse correctamente:

  • git rm --cached: Mueve los archivos que le indiquemos al estado Untracked.
  • git rm --force: Elimina los archivos de Git y del disco duro. Git guarda el
    registro de la existencia de los archivos, por lo que podremos recuperarlos si
    es necesario (pero debemos usar comandos más avanzados).

Git reset vs. Git rm


Imagina que tienes un archivo: archivo.txt
Hiciste commit, por lo que ya está en el repositorio.
Después añades una nueva línea al archivo, y haces git add archivo.txt
(lo pasas a staging).

En ese punto si hicieses git rm --cached borrarías el archivo de staging y
del commit siguiente (si haces commit se borrará del repositorio. Pero no se
borra del disco duro, por lo que aún podrías hacer git add antes del commit y
volverías al estado previo a hacer el git rm)

Si hicieses git rm --force borras de staging, del repositorio en el siguiente
commit, y del disco duro. Pierdes el archivo, pero podrías recuperar una versión
anterior del repositorio con git checkout.

Si haces git reset --hard “nombredelcommit” vuelves a ese commit, y borras los
cambios que se hubieran realizado posteriores a ese commit, así como los cambios
que tengas en staging. ESTO ES MUY PELIGROSO.

Si haces git reset --soft “nombredelcommit” es lo mismo que el hard, pero mantienes
los archivos en el estado actual en el disco duro, y en staging.
git reset HEAD: git reset sin modo (–soft, --hard, --mixed…) es equivalente a git
reset --mixed, que vuelve al commit indicado, manteniendo los archivos en disco,
pero sacándolos de staging. Por eso al aplicar git reset HEAD, volvemos al estado
HEAD, es decir al último commit, manteniendo los archivos en disco, pero fuera de
staging (dicho de otro modo, sacamos los archivos de staging y todo lo demás no
cambia, mantenemos los archivos y seguimos en el estado previo a hacer git add .)

Mis Apuntes:

git log --stat = muestra a detalle los cambios realizados despues del commint

git checkout urlDelArchivo NombreDelArchivo = para ver o regresa

git rm --cached = Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.

git rm --force = Elimina los archivos de Git y del disco duro.

git reset --soft = Borramos todo el historial y los registros de Git pero guardamos los cambios que tengamos en Staging, así podemos aplicar las últimas actualizaciones a un nuevo commit.

git reset --hard = Borra todo. Todo todito, absolutamente todo. Toda la información de los commits y del área de staging se borra del historial.

git reset HEAD = Este es el comando para sacar archivos del área de Staging. No para borrarlos ni nada de eso, solo para que los últimos cambios de estos archivos no se envíen al último commit

git log --oneline : para ver todos los commint con sus comentarios

git reset --hard #id:

git log -g #id: para ver todos todos todos los commint, incluso luego de regresar en el tiempo

git clone #url : para ir a traer un proyecto a un repositorio remoto, crea la base de datos de todos los commits

git push: para subir al servidor remoto los cambios hechos localmente a un proyecto que se aloja en un serv remoto

git fetch: trae las ultimas actualizaciones del proyecto en un server remoto. solo las ultimas act, pero no lo copia a los archivos.

git merge: copia los ultimos cambios del proyecto al directorio de mi disco duro

git pull: hace el git fethc y git merge al mismo tiempo. trae y actualiza al directorio los ultimos cambios.

++++++++++++++++++++++++++++++++
Ramas

git branch “nombre de la rama” : crea una rama.

Acá les dejo mis apuntes hasta el momento

/* CONFIGURAR ENTORNO */

git config --global user.name " "
git config --global user.email " "


/* CREAR REPOSITORIO */

**Para nuevos repositorios
git init        //en carpeta master
git remote add origin <dir-repo>

**Para repositorios existentes:
git clone <dir-repo>


-------
/* GESTIONAR CAMBIOS */

git add .                   //añadir archivos a Staging
git commit -m 'comentario'  //se confirman cambios


/* REVISAR CAMBIOS */

git log                         // muestra todos los commit
git log --stat                  // muestra todos los commit junto con el detalle
git show <nombre de archivo>    //muestra cambios del archivo
git diff #(old commit) #(new commit)        //compara commits


/* RESTAURAR CAMBIOS */

git checkout ### <archivo> | .      //permite ver un archivo en especifico como estaba antes
git checkout master <archivo> | .   //regresa al head de los commits


/* ELIMINAR CAMBIOS */
git reset HEAD <archivo> | .    //De Staging a Unstaged, les quita el add

**Cuidado Elimina archivos
git rm --cached <archivo>       //Elimina los archivos del área de Staging pero los mantiene en nuestro disco duro
git rm --force <archivo>        //Elimina los archivos de Git y del disco duro

**Cuidado Regres en el tiempo sin vuelta atras
git reset ### --hard    //regresa al commit indicado, sin guardar Staging
git reset ### --soft    //mantiene los cambios en el Staging


------
/* CREAR RAMAS */
git branch <nombre>         //Crea rama
git checkout -b <nombre>    //Crea rama y se mueve a ella

/* MOVERSE EN RAMAS */
git checkout <nombre>       //Se mueve a la rama indicada

/* MERGE RAMAS */
git merge <rama>        //Se realiza desde la rama principal
Comandos de Git

git config Muestra la configuracion que tiene

git --global user.name "NOMBRE" Asigna el nombre global(a todos) de la cuenta

git --global user.email "CORREO" Asigna la cuenta global(a todos) de la cuenta

git init Inicia un Repositorio nuevo!

git status Muestra los archivos agrgados y los que no

git add EJEMPLO.txt Agrega el archivo a la lista de espera para cambios en Carpeta Raiz

git add . Agrega todos los archivos a la lista de espera en Carpeta Raiz

git commit Hace los cambios de una version a otra

git rm --cached NOMBRE.TXT Borrar de git el archivo cuando esta en stage y de la memoria cache de git

git commit -m "cambioJS" Hace un commit con un nombre IMPORTANTE para diferenciar

git commit am "cambiosJS" Hace un commit y hace el add automaticamente
git log Muestra los commits

git log --oneline Muestra los commits resumidos

git log --stat Muestra los commits con los cambios

Q Para salir del git log

git show Muestra los cambios entre commits

git show NOMBRE.TXT Muesta los cambios entre commits y la version

Esc + i Para escribir en Vim

Esc + shift + zz Sale de Vim

git diff Compara el archivo que esta en stagin con el anteriores

git diff TAGVIEJO TAG NUEVO Compara los cambios entra los tags del diff

git reset TAG --hard Borra los cambios hasta el tag

git reset TAG --soft Borra los cambio hasta el tag y te pone en el stage

git chekout TAGVIEJO Chekea los antiguos commits
git checkout master Vuelve a Mater

git branch RAMA Crea una Rama

git checkout RAMA Chekea la rama

Master-----o             o-----o-----o
           |             |
           Otra Rama-----o




Comandos de la terminal de Linux

ls Muestra todos los archivos que estan dentro de la carpeta Raiz

ls -l Te mustra todos los archivos de la carpeta Raiz!
ls - al Mustra todos los archivos mas los ocultos

pwd Te dice donde esta ubicada la carpeta Raiz

cd c/RUTA/RUTA Te lleva a la ruta DOS PUNTOS : NO FUNCIONAN omitelos

cd / Te envia a la raiz de Linux

cd ..  de la ruta

clear Limpia la consola

Ctrl + l Limpia la consola

mkdir NOMBRE Crea una carpetas en la carpeta Raiz

touch NOMBRE.TXT Crea un archivo en la Carpeta Raiz

cat NOMBRE.TXT Muestra lo que hay dentro del archivo en texto plano

history Muestra los comandos que has usado EN TODA TU HISTORIA de la consola

rm NOMBRE.TXT borra el archivo TEN RESPONSIVILIDAD puedes borrarle la mente a tu pc

en master, el commit volvi a una tipografía menos controversial: https://github.com/freddier/hyperblog/tree/7ec1335a4f52478b6d486eb27c67f723f14d679f

Por si a alguno le sirve, hice un pequeño diagrama 😄 (disculpen la letra jeje)

  1. git init: Crear la carpeta .git en la que está la base de datos del repositorio local.

  2. git add: Agregar los cambios al área de preparación o staging. con el argumento –A o con punto agregamos todos los archivos con cambios. Si se especifíca un nombre de archivo se agrega solamente ese archivo.

  3. git commit: Guardar todos los cambios del área de preparación. Con el argumento ¬–m agregamos un mensaje sin entrar al editor vim que viene por defecto. Con el argumento –am¬ le decimos que agregue todos los cambios de área de staging y que haga commit inmediatamente.

  4. git log: Ver la lista de los commits realizados en el repositorio. Se puede agregar el argumento –-stat para ver la cantidad de cosas que se han agregado o quitado en cada commit. también se puede especificar un nombre de archivo para ver solo los commits donde dicho archivo aparezca.

  5. git show: Ver las diferencias entre los dos últimos commits. Se muestran en rojo las líneas borradas, en verde las agregadas y en blanco las que se mantienen. Se puede especificar un nombre de archivo para ver solo los cambios en dicho archivo.

  6. git diff: Comparar dos commit usando sus hash (código largo generado al hacer commit). Lo ideal es escribir primero el hash del commit más viejo para que salga en rojo. Con este comando podemos ver la diferencia entre el último commit y lo que tenemos en el área de staging.

  7. git status: Ver en qué estado se encuentran los archivos del repositorio, es decir, si están dentro o fuera del área de staging.

  8. git reset head: Sacar nuestros archivos de área de staging.

  9. git rm: Eliminar archivos. Con el argumento –-force se eliminan los archivos definitivamente, mientras que con el comando –-cached se elimina el archivo del próximo commit pero se mantiene en el disco duro como un archivo untraked.

  10. git branch: Ver las ramas que existen. También podemos crear ramas agregando un nombre para la rama al lado del comando.

  11. git checkout: Viajar entre ramas o entre commits. Para volver a un estado anterior del repositorio agregamos el hash del commit (o si queremos ir a master solo agregamos la palabra master). Si solo queremos ver el estado de un archivo en un commit anterior ponemos el hash y el nombre del archivo. Para crear una rama y acceder inmediatamente a ella usamos git checkout –b nombre_rama, para borrar una rama cambiamos la b por una d y para renombrar una rama cambiamos la b por una m. también podemos cambiar de rama indicando al lado del comando el nombre de da rama.

  12. git config: Todo lo relacionado a la configuración. Con el argumento –l podemos ver la lista de las configuraciones. Con el argumento --global user.email correo configuramos el correo de nuestra cuenta de github y con --global user.name nombre_usuario el nombre de la persona.

  13. git reset: Nos devuelve a un commit anterior borrando todo lo que hicimos después de ese commit. La diferencia radica en que si usamos el argumento --soft se conservará lo que tengamos en el staging, mientras que si usamos el argumento --hard¬ se borrará también lo que esté en el staging. Este comando es peligroso.

  14. git clone: Nos crea una copia de un repositorio de GitHub. Debemos indicar al lado del comando la URL del repositorio.

  15. git fetch: Trae confirmaciones y archivos de un repositorio remoto a nuestro repositorio local sin alterar nuestros archivos, de tal manera que podemos revisar lo que queremos fusionar con nuestros archivos.

  16. git merge: Fusionar ramas y dar el resultado en un nuevo commit. Para esto, desde la rama principal indicamos al lado del comando el nombre de la rama con la que vamos a fusionar.

  17. git push: Enviar el contenido de nuestro repositorio local al repositorio remoto.

  18. git pull: Hacer git fetch y git merge al mismo tiempo.

**git help **: Ayuda en comandos
git init: Iniciar repositorio
git clone : Clonar repo
*git add .c : añadir archivo con esta extensión
git status: el estado de las tres áreas de Git (working Area, Staging Area, Repository Area)
git add README: añadir un archivo específico
git log: cuantos commits tenemos en el repositorio
git branch: Indica que ramas tengo
git branch rama_nueva: Se crea una nueva rama
git checkout -b rama_nueva: Se crea una nueva rama y se sitúa en ella
git checkout rama: cambia a la rama que queramos
git checkout hash: Se puede investigar que se ha hecho en ese commit, pero si hacemos cambio se crea una rama
git merge rama: Indica fusión de una rama con otro, se debe situar en la rama que se requiere hacer merge
git branch --merged: indica que ramas se han fusionado

Les comparto un dato interesante.
Pueden crear alias para los comandos de git.
Por ejemplo:
git config --global alias.c "checkout"
De esta forma pueden solamente usar la letra c en vez de checkout. Ejemplo:
git c cabecera.
git c master.
Así pueden moverse mucho mas rápido por los comandos de git.

Ver cómo se están tus ramas:
$ git log --oneline --all --graph
No importa el orden de los comandos después de “log” 😃

por algo es el CEO se la rifa

No conozco nadie en mi completa vida de estudiante que haga una clase mas entretenida e interesante que Freddy de verdad este carajo es de otra galaxia! gracias!!!

esto de git se me hace como las lineas de tiempo de Avengers End Game, jejejej perdón pero así me es mas fácil verlo

[Git CheatSheet] (https://github.github.com/training-kit/downloads/github-git-cheat-sheet.pdf)

Desde Github podemos aprender un poco los comandos!

Perdón si algo esta mal escrito.

“git show” .- Te muestra el ultimo commit y los cambios hechos

¿Qué es staging?.- Es una area donde esta los archivos con cambios(trackeados), con commit se van a .git
"git config --list" .- Lista las configuraciones que tenemos
"git diff <commit ini> <commit fin>" .- compara el commit inicio(actual) con el commit fin(comparar)
“git reset <commit id> --hard”.- Volvemos en el tiempo
"git reset <commit id> --soft".- volvemos a la version anterior
"git checkout <commit id> <-nombre archivo->".- viaje en el tiempo, donde podemos volver al presente, archivo es opcional
"gitk <-nombre archivo->".- Para generar la interfaz grafica, parent es el commit padre and child es el commit hijo
"git merge <nombre rama>".- Traemos los cambios de la rama nombrada en la rama actual

Comandos básico

git init -> inicializa un repositorio (la carpeta donde estés).
git add biografía.txt -> añade un fichero al repositorio de git
git commit -m "versión 1" -> deja la versión en 
# si editas un fichero, puedes volver a hacer el git add biografía.txt o
git add . -> añade todo lo que se haya modificado en esa carpeta
git commit -m "cambios versión 1" -> cambia la versión
git status -> muestra lo que tienes pendiente de commit
git show -> muestra histórico de cambios
git log biografía.txt -> muestra el histórico de cambios del archivo.
git push -> lo manda a un repositorio remoto
git pull -> lo trae de un repositorio remoto

Instalación
Te lo bajas de https://git-scm.com/downloads
 git --version --> Para comprobar que está bien instalado

 git checkout -> sincronizas la rama master: todos los cambios, solo ciertos cambios, solo los hechos a un archivo...
Ramas
 master -> está en todos los repositorios, es la rama principal
 development -> para experimentos
 hotfix -> para parches

Cuando juntas varias ramas hacia el master se llama merge

Configurar Git
git config --> te dice cómo funciona
git --list -> te salen los parámetros configurados
git config --global user.name "David Lozano"
git config --global user.email "[email protected]"



Analizar cambios en los archivos de tu proyecto con Git
git log historia.txt -> te muestra de descripción de los cambios en el archivos
git show historia.txt -> te muestra los cambios en el archivo
git diff <commit1> <commit2> -> saca las diferencias entre 2 commits
gif diff -> sin ningún parámetro más muestra las diferencias entre lo que está en staging y el último commit 

Volver en el tiempo en nuestro repositorio utilizando branches y checkout
git reset <commit> --hard --> vuelve al commit que le digamos
git checkout <commit> historia.txt -> trae el fichero que hubiera en ese commit
git checkout master historia.txt -> trae el fichero que haya en ese momento en la versión más reciente de la rama master


Aclaración entre Git reset vs. Git rm

git rm --cached: Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.
git rm --force: Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).

git reset
Con git reset volvemos al pasado sin la posibilidad de volver al futuro. Borramos la historia y la debemos sobreescribir. No hay vuelta atrás. Este comando es muy peligroso y debemos usarlo solo en caso de emergencia. Recuerda que debemos usar alguna de estas dos opciones:


Flujo de trabajo básico con un repositorio remoto

git clone url_del_servidor_remoto -> Nos permite descargar los archivos de la última versión de la rama principal y todo el historial de cambios en la carpeta .git
git pull -> Básicamente, git fetch (trae actualizaciones del servidor remoto y las guarda en el repositorio local) y git merge (combina los últimos cambios en nuestro directorio de trabajo) al mismo tiempo.

Introducción a las ramas o branches de Git
Cuando hacemos una rama, hacemos una copia del último commit en otro lado, y estos cambios no los ve la rama master hasta que hacemos un merge.

git branch cabecera -> crea una rama llamada cabecera
git checkout cabecera -> te mueves a la rama cabecera. Mueve el "HEAD" a la rama cabecera, que equivale a ponerte en el directorio de trabajo todos los ficheros de esa rama
git status -> te dice en qué rama estás

Fusión de ramas con Git merge
Cuando se hace un Merge, la rama cabecera desaparece, ese es el final de su vida porque se une con la principal (master)
Pasos para el merge:
git checkout master -> pones el HEAD en la última versión de la master
git merge cabecera -> fusiona todos los ficheros 

git branch -> lista el listado de ramas

MIS APUNTES!!

“git init” es el comando utilizado para arrancar git y crear el entorno de trabajo o directorio.
“Staging” es el area donde se envian los cambios, luego de haber utilizado el comando “git add”, estos se almacenan en la memoria RAM.
“git add” es el comando utilizado para agregar los cambios realizados al “Staging”.
“git commit” es el comando utilizado para agregar los cambios realizados al repositorio. Se utiliza "git commit -m "mensaje que quieres dejar en el commit"
El “Master” es practicamente el repositorio principal de tu proyecto.
“git status” es el comando utilizado para verificar en que estado se encuentra nuestro archivo en el momento.
“git reset head” se utiliza para sacar de memoria RAM o del Staging los archivos agragados con cambios. Es parecido al comando “git rm --cached”
“git rm --cached” se utiliza para mover el archivo del Staging al estado Unstaged.
“git rm --force” se utiliza para eliminar el archivo de git y de disco.


Cuando utilizas “–” en un comando, ese comando se debe ser una palabra. el comando para utilizar letras es “-”.
“git config” se utiliza para ver una lista de los comandos que funsionan con git config.
El comando “git config --list” trae una lista de las configuraciones que ya estan establecidas.
El comando “git config --listo --show-origin” te muestra las carpetas en donde puedes acceder a las configuraciones y realizarlas manualmente.
“git config --global user.name” cambia o agrega el nombre de usuario de git.
“git config --global user.email” cambia o agrega el nombre del email de git.


“git show” es el comando utilizado para hacer una vista los commits.
“git diff” es el comando utilizado para hacer una vista de dos commits y diferenciarlo uno del otro. en este podemos ver los cambios realizado de uno en comparacion del otro.
“git log” es el comando utilizado para visualizar todos los commit realizado en un archivo.


“git reset +ID COMMIT --hard” se utiliza para borrar los commit, y este se sutiliza para volver al pasado, ya que si seleccionas un commit, te devuelve hacia el commit que seleccionaste.
“git log --stat” es el comando para visualizar los cambios realizados en cada commit.
"git checkout +ID COMMIT +“NOMBRE DEL ARCHIVO”, es el comando para regresar a un commit rea;izadp en el pasado.
"git commit master +“NOMBRE DEL ARCHIVO”, es el comando para regresar a loss ultimos cambios realizados.
NOTA: Si quieres realizar una actualizacion puedes utilizar checkout y luego sobre escribir el archivo para hacer un nuevo commit.


“git branch” te permite realizar una copia del archivo en el repositorio. se utiliza “git checkout + NOMBRE DE LA COPIA” para cambiar de la copia al archivo master.

También podemos saber en cuál rama estamos parados si hacemos:

git branch

Nos aparecerá marcada la rama con un *

Comados git

  1. git init = inicializar repositorio
  2. git add . = Añadir todos los archivos de la carpeta
  3. git add nombre_archivo= añadir solo el archivo
  4. git commit = enviar el los archivos al repositorio
  5. git commit -m “titulo para el commit” = envía el commit con un mensaje para poder diferenciarlo de otros
  6. git log nombre_archivo = muestra un historial de commits realizados en este archivo (historial)
  7. git show nombre_archivo = muestra los cambios en el archivo (mas especifico)
  8. git chckout master nombre_archivo = muestra el archivo en su versión de master
  9. git branch new_rama = Crear una rama
  10. git checkout nombre_rama = Cambiar de rama
  11. git branch = mustra las ramas existentes
  • git init - Crea/Inicia el repositorio

  • git add . - Manda los nuevos archivos a staging para que sean “trackeados” (el punto lo aplica a todos los archivos, si sólo querémos que se aplique a un archivo en específico, debemos poner el nombre del archivo en lugar del punto)

  • git status - Nos muestra en qué rama estámos y si hay algo pendiente to commit

  • git config --list - Muesta un listado del contenido del archivo de configuración (simple)

  • git config --global user.name "Bianca " - Agregar user al archivo de configuraciones para que no me traiga las variables de Windows

git config --global user.email "[email protected]" - Agregar correo al archivo de configuraciones para que no me traiga las variables de Windows

  • git config --list --show-origin - Ver el contenido del archivo de configuración global

  • git commit -m "Esta se el comienzo de la segunda parte de la historia" - Realiza commit guardando los cambios en el repositorio local

  • code + nombre de archivo - Abre nuestro archivo con Visual Code Studio

  • git log - Nos muestra el history de los commits realizados

  • git show - Nos muestra los cambios que se han hecho en nuestro archivo

  • git diff 2ebcfc51af6fa1afd90ddaacb7410e0a6074f0ba aad00bb54d5a062b3c76bd815f1dab8d104db94e - Nos muestra los cambios entre commits

-git reset aad00bb54d5a062b3c76bd815f1dab8d104db94e --hard - Este comando es peligroso por que eliminará todos los cambios sin poderlos recuperar si elejimos volver a una versión en específico;

  • git rm --cached - Elimina los archivos de staging pero los mantiene en el disco duro;
  • git rm --force - Elimina archivos de git y disco duro
  • git reset HEAD - Manda los archivos que están en Staging a Unstaged
  • git branch nombre_nueva_rama- Crea rama nueva
  • git checkout rama- Nos mueve a la rama que queremos
  • git log --stat - Muestra el estatus de los commits

-git checkout 840048e92701d9ddb3cc9504bf26a608101b365d historia.txt - Para hacer que un archivo regrese a un commit en específico

  • git checkout master historia.txt - Para que el archivo retome los cambios que hemos realizado hasta el último commit en la rama master
  • git merge - merge permite fusionar los cambios que se han hecho entre ramas, en el ejercicio que hicimos se fusionaron los cambios de la rama cabecera a la rama master

Dejo adjunto mis apuntes por si a alguiente le sirve 😉

$ git init //Inicia el repositorio
$ git add nombreArchivo.txt //agrega el archivo como cambio del repositorio en la estapa stage (repositorio local) puedo poner . para agregar todos los archivos que se encuentren en la carpeta en donde este parado.
//Si no se realiza el add a un archivo el mismo no se trackea como cambio a subir en un commit.
$ git commit -m “Version 1” //realiza el commit en el repositorio local y agrega un comentario con el comando -m, cada commit es
una nueva version de git.

$ git rm nombreArchivo.txt //realizo lo contrario al comando add, el archvio pasa a estar untrackted

$ git checkout <id de commit>//Chequea y trae los cambios de una version especifica a tu carpeta hacia tu carpeta.

$ git status //Puedo ver el estado del repositorio, si hay un cambio si subir, va a aparecer aca.
$ git show //Muestra todos los cambios historicos hechos. (Veo exactamente que cambios se realizaron en la version que estoy parado del archivo.)
$ git log nombreDeArchivo.txt //Puedo ver el historial de cambios sobre un archivo (Veo cada una de las versiones)

$ git push //Envia el repositorio local al repositorio remoto.

$ git pull //Obtiene el repositorio remoto en el repositorio local.

$ git diff codigoCommit1 codigoCommit2

/* COMO VOLVER A UNA VERSION ANTERIOR */

git reset codigoCommit --hard (Vuelve todo a una version anterior, es peligroso.)
git reset codigoCommit --soft (Vuelve a la version anterior, pero los cambios que se poseean en staging aun se mantienen.)

// Esto borra todo lo que se haya hecho antes, se pierde.

$ git commit -am “Escribo mi mensaje” // Esto realiza el commit con las modificaciones de los archivos que ya se encuentran trankeados.

//Crear nueva RAMA

$ git branch <Nombre de la rama>

//Para moverme a la rama puedo utilizar checkout
$ git checkout <nombre_de_la_rama>

//Mergear

git merge <nombre de la rama> // Para obtener el listado de ramas puedo usar $ git branch

Aprendí a utilizar los siguientes comandos:

  • git status: visualizar el estado de tus archivos, si se modificó alguno.
  • git add “nombre del archivo.extensión”: utilizado para agregar el archivo a temporales.
  • git add .: utilizado para agregar todos los archivos con modificación a temporales.
  • git commit: utilizado para guardar los archivos que están en temporal. Mostrando en terminal, el sistema vim, para ingresar los comentarios.
    • Combinación de teclas: ESC + Shift + Z + Z. Para salir del editor vim.
    • Combinación de teclas: EXC + Mayús + z + z. Para salir del editor vim.
  • git commit -m “mensaje”: utilizado para guardar los archivos que están en temporal agregando comentarios directamente desde terminal.
  • git show: visualizar el contenido del archivo.
  • git log “nombre del archivo.extensión”: visualizar el historial de versiones del archivo guardado. Mostrando un id con el que puedes referenciar cada cambio.
  • git log --stat: Revisar los cambios en cantidad por cada commit.
  • git diff “id” “id”: utilizado para comparar dos versiones.
    • El primer id lo tomara como la versión reciente a comparar.
    • El segundo id lo tomara como la versión anterior a comparar.
  • git checkout + id del commit: nos permite viajar en el tiempo.
  • git reset “id” --hard: todo vuelve al estado (id) colocado. Es el más peligroso ya que si te equivocas, puedes borrar todo lo que tenias después de el id colocado.
  • git reset “id” --soft: volvamos a la versión anterior, pero lo que tengamos en staging sigue en staging. Es decir, si le has hecho cambios y le das git add, eso sigue ahí, disponible para el siguiente commit, simplemente que el directorio de trabajo vuelve a la versión anterior.
  • git checkout “id” “nombre del archivo.extensión”: Cambiar a la versión del id.
  • git checkout master “nombre del archivo.extensión”: Cambiamos a la versión maestra.
  • git clone url_del_servidor_remoto: Nos permite descargar los archivos de la última versión de la rama principal y todo el historial de cambios en la carpeta .git.
  • git push: Luego de hacer git add y git commit debemos ejecutar este comando para mandar los cambios al servidor remoto.
  • git fetch: Lo usamos para traer actualizaciones del servidor remoto y guardarlas en nuestro repositorio local (en caso de que hayan, por supuesto).
  • git merge: También usamos el comando git fetch con servidores remotos. Lo necesitamos para combinar los últimos cambios del servidor remoto y nuestro directorio de trabajo.
  • git pull: Básicamente, git fetch y git merge al mismo tiempo.
  • git branch: muestra todas las ramas creadas.
  • git branch “nombre de la rama”: Crear una nueva rama.
  • git checkout “nombre de la rama”: Cambiar entre ramas.
  • git merge “nombre de la rama”: Fusiona la rama en la que estes actualmente, con la rama que ingreses.

DIRECTORIO - STAGING - REPOSITORIO

git init (untracked)
git add historia.txt (tracked en staging)
git rm hostoria.txt
commit -m “verion 01” (tracked en repositorio)
checkout (trae los ultimos cambios del repositiro al directorio)

rama MASTER
rama EXPERIMENTOS
rama BUGFIXING

PRINCIPALES COMANDOS

git init CREA UNA CARPETA GIT DE LA BASE DE DATOS DE CAMBIOS ATOMICOS
git show “nombre del archivo” MUESTRAR CAMBIOS
git status MUESTRA EL ESTADO DE MI PROYECTO
git add histotia.txt AGREGA GIT EN MEMORIA
git log <nombre del archivo> VERSIONES DE LOS COMITS
pwd PARA VER EN QUE CARPETA ESTOY
git diff <version 1> <version 2>
ls PARA LISTAS LOS ARCHIVOS DE MI CARPETA
git commit -am realiza un add y un commit a la vez solo funciona con archivos modificados no nuevos

Procedimiento:

  1. Crear el archivo:
  2. git add <nombre del archivo>
  3. git commit -m “archivo creado”
  4. git show “archivo.txt” MUESTRA LOS CAMBIOS

🐱‍💻 Git tiene dos formas para unir ramas, git merge y git rebase. La forma más conocida es git merge, la cual realiza una fusión donde crea un nuevo commit con los cambios mezclados.

TIP: para alternar rápidamente entre comandos previamente utilizados, solo hay que presionar las tevlas arriba y abajo.

Agreguen estas opciones al git log y vualá.

git log --graph --decorate --pretty=oneline --abbrev-commit --all

Les comparte todos mis anotaciones de este curso 😃 y que he utilizado en el trabajo espero les ayude.

https://gist.github.com/HeydyCH/8a2d5c54f329f348cf192796cbe58c22

Hacer click en el linmk para que vean todas mis anotaciones Saludos lml

Comparto mis apuntes hasta esta clase:

git add --all / git add .
git commit -m “Mensaje” (Crea un commit con los cambios en staging)
git commit -am “Mensaje” (Trackea los cambios untracked de archivos previamente commiteados y crea un commit con los cambios en staging)
git log nombre_archivo.extension/nombre_carpeta (Muestra un perfil de los commit de un archivo, carpeta o rama)
git log --stat (Muestra datos adicionales de lo modificado)
git show (Muestra todos los cambios realizados en el último commit)
git reset --hard numero_commit (Resetea a un commit y borra lo que está en el área de stating)
git reset --soft numero_commit (Resetea a un commit sin borrar los cambios tracked)
git reset HEAD (Saca todos los cambios en el área de staging)
git checkout nombre_branch/numero_commit nombre_archivo_nombre_carpeta
git diff (Muestra los cambios untracked)
git rm --cached (Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro)
git rm --force (Elimina los archivos de Git y del disco duro.)
git merge otro_branch (Es un commit a la rama destino con la que se esta fusionando)

Interesante:
git fetch = (trae los cambios de un repositorio remoto al local)
git merge = (fusiona los cambios del repositorio local con lo que está en el disco duro)
git pull = git fetch + git merge

Para enmendar un commit, es decir, si por alguna razón lo hice antes y quiero agregar cambios podemos usar el comando

git commit -a --amend

Con esto se abre la ventana de vim nano para que ingrese el nuevo mensaje y descripción del commit y bumm hemos reescrito el commit previo.

**-- ¿Cómo crear un repositorio git?
**
git init

**-- ¿Cómo configurar el repositorio?
**
git config --global user.name "Guillermo Pizarro"
git config --global user.email “[email protected]

**-- ¿Cómo añadir un archivo al repo?
**
git add <nombre_archivo>

O también puede ser si se agregan muchos archivos.

git add .

**-- ¿Cómo pasar los archivos de staging al repositorio local?
**
git commit -m “Versión inicial”

**-- ¿Cómo verificar los cambios entre versiones?
**
git diff <codigo_antiguo> <codigo_nuevo>

**-- ¿Cómo ver el versionamiento de un archivo?
**
git log <nombre-_archivo.txt>

– ¿Cómo verificar los cambios del archivo con respecto a la versión actual y la anterior?

git show

– ¿Cómo traer una versión antigua para trabajar en ella?

Se regresa al estado del commit señalado.

git reset <codigo_commit> --hard
git reset <codigo_commit> --soft

hard se elimina todo lo que se encuentra en staging y vuelve a la versión anterior
soft se mantiene lo que se encuentra en staging (es decir, siguen los archivos disponibles para el commit de la versión anterior)

**-- ¿Cómo ver los cambios por commit y en qué archivos?
**
git log --stat

– ¿Cómo regresar a un commit anterior (branch)?

git checkout <codigo_commit> <nombre_archivo>

**-- ¿Cómo regresar a la versión actual?
**
git checkout master <nombre_archivo>

Es importante mencionar que con checkout podemos ir y volver; sin embargo, con reset no hay posibilidad de retorno.

**-- ¿Luego de hacer un checkout cómo hacer permanente ?
**
git add.
git commit -m “Reemplazo de una versin”

**-- ¿Cómo crear una rama desde el master?
**
git branch <nombre_rama>
git checkout <nombre_rama>

**-- ¿Cómo regresar al master?
**
git checkout master

**-- ¿Luego cómo unificar las ramas?
**
Primero, uno debe estar en la rama desde donde desea unificar, en esta caso, se ubica en la rama master como se presentó en el ejemplo anterior.

git merge <nombre_rama>

Pueden existir conflictos en algunos archivos, que se pueden resolver utilizando visual studio code; luego de esto, se realizar el respectivo commit

git commit -am “Unificación de archivo”

**APUNTES
**

cd /d
mkdir git
touch vacio.txt
cat vacio.txt
history
rm --help

git config --global user.email "[email protected]"
git config --global user.name "Rafael"
git config --list - muetra todo las configuracion

git init - empezar un repositorio
git add biografia.txt - para hacerle saber del archivo
git add . - agrega todo los archivos que encuentre
git rm biografia.txt --cached - para quitar de la memoria
git commit -m “version 1” - guarda los cambios con un comentario
git diff version antigua version ultima - para comparar (commint)
git diff - puede ver los cambio sin guardar
git reset ****** --hard - restaura todo hasta ese punto
git reset --hard - restaura todo hasta el ultimo guardado

git status - ve el estado si guardaste o no
git show - muestra los ultimos cambios
git log biografia.txt - muestra todos los cambios realizados
git log --stat - muestra todos mas detallado

git checkout ****** archivo - regresa a este punto
git checkout master archivo - restablece el ultimo punto

git clone url(remoto) - para que descargue los repositorio
git add
git commit
git push - para subir mi archicos al repositorio remoto

git fetch - si es q hay una actualizacion que bajar al repositorio local
git merge - para pasar del repositorio local al directorio de trabajo
git pull - hace las 2 cosas en una sola

git commit -am “comentario” - agrega y comenta al mismo tiempo

git branch cabecera - se crea una rama con nombre cabecera
git checkout cabecera - me muevo a la rama cabecera

git branch - me muestra todas las ramas
pong la cabecera en el master. hay recien invoco el merger para fucionar
git merge cabecera - estoy creando un nuevo comit

`Linea de Comandos
Abrir Git Bash
. pwd -> Te muestra en que carpeta estas
. cd -> change director (navegar de directorio)
. ls -> Me muestra todos los archivos que estan en la raiz de la carpeta
. ls -al -> Me muestran todos los archivos ocultos en una lista
. ls -l -> Me muestra todos los archivos en una lista
. clear -> Limpia automaticamente la consola o Ctrl + l
. cd /c -> Entrat al disco c
. cd … -> Salir de la carpeta y regreso a la carpeta anterior
. Tab -> Autorrellena la palabra que desear buscar con la letra inicial
.mkdir name -> make directory (Crea una carpeta)
. touch name.txt -> Crea archivos vacios
. cat name.txt -> Muestra de manera rapida el contenido de tu archivo
. history -> Muestra el historial de comandos hasta el momento
. rm name.txt -> remove (Elimina tu archivo)
. rm --help -> help te muestra una serie de explicaciones de como funciona cada uno de los comandos

$git init -> Inicializa en tu carpeta un repositorio (Arranca el repositorio)
$git add . -> Git sabe que existe esos archivos creados (Arranca el archivo)
$git commit -m “Version 1” -> Envia los ultimos cambios de archivo a la bd del control de versiones (Repositorio remoto)
$git status -> Puedo ver el status de mi base de datos
$git show -> Muestra todos los cambios historicos hechos, fecha y que autor hizo el cambio
$git log name.text -> Ver historia entera de un archivo
$git log --stat -> Muestra los cambios especificos que se hicieron en el commit (q para salir)
$git push -> LLevar el archivo a un servidor remoto, a mi repositorio remoto

*Cuando escribo mi comando git init en mi directorio se crea una area Staging, funciona en memoria RAM. Es donde al principio estare agregando mis archivos. Con el comando git add . Mi archivo pasa a vivir en Staging y esta esperando a que lo envie a repositorio. Con el comando commit -m “” mi archivo se va al repositorio, su nombre es master (Estaran todos los cambios que realizo)

*Staging es la memoria RAM, es el estado temporal al que agregamos archivos que vamos cambiando y el repositorio real es cuando hacemos el commit.

Estados del archivo
name.txt ->untracked (Sin rastrear)
$git add name.txt -> tracked (Se esta rastreando) en staging
$git commit -m “” -> tracked en repositorio

$git rm --cached name.txt -> quitar el add de la memoria RAM

Configurar Git

$git config -> Todas las configuraciones que tiene git y como funciona
$git config --list -> Muestra las configuraciones por defecto de $git y ver que cosas te faltan.
$git config --list --show-origin -> Muestra donde estan las configuraciones guardadas
$git config --global user.name “Jose Minaya” -> Cambia la configuracion del usuario de git
$git config --global user.email "[email protected]" -> Cambia la configuracion del email de git

Para salir de la consola cuando te manda advertencia o error es con Esc + Shift + zz (Guardar en Bin)

$git diff xxx zzzz -> Ver la diferencia del cambio de un archivo con otro archivo
xxx,yyy -> indicadores del cual fue el commit
Color verder la version original
Color rojo la ultima version (como lo coloque)

$git reset xxx --hard -> Todo regresa a la version anterior sin poder volver a la version actual
$git reset xxx --soft -> Todo regresa a la version anterior pero menos lo que esta en el staging osea lo que tenias en el git add
$git reset HEAD -> Movemos los cambios del staging a Unstaged
$git reset HEAD name.txt -> Mueve del stage solo el archivo señalado

$git checkout -> Puedes regresar a cualquier version anterior (mirar, pasear y volver) y podemos volver a la version actual.

$git pull -> Saco una copia del repositorio remoto a mi repositorio local, actualizo los cambios que han subido otros usuarios ( git fetch + git merge)

Para la creacion de ramas tienes que estar en el master HEAD -> master
$git branch name -> Creamos una rama llamada name
$git checkout name -> Cambiamos a la rama name

HEAD -> Es un indicador de cual version de commit estoy viendo de los ultimos archivos.
$git branch -> Me indica cuantas ramas hay y en que rama me encuentro.

*Para realizar una fusion de ramas tengo que hacer un merge desde la rama master

$git merge name -> Estoy fusionando la rama master con la rama name`

Estos son mis apuntes por si alguien le es util

git init — Indicar a git que queremos utilizar su sistema de control de versiones.
git add / git add . — para que el repositorio sepa la existencia de un archivo y sus ultimos cambios (Staging Area).
git commit -m “comentario” — almacenar los cambios.
git status — revisar el estatus si tengo algun cambio no agregado me lo mostrara.
git show —- Mostrara todos los cambios históricos hechos.
git log — para revisar los cambios hechos
Git log —stat —para revisar inserciones y delete de cada documento
git push — Enviar nuestros commits a un servidor remoto.
Git checkout — cambiar de ramas en Git.
Git branch — revisar que ramas existen en mi proyecto git
Git merge “nombre del branch” — para fusionar cambios entre ramas

Cuando se desarrolla código, por lo general no se hacen cambio a mano en rama master. sino ser realizan nuevas ramas y a medida que se va avanzando, esta nuevas ramas se van pusheando a master (y los nuevos desarrollos se sacan otra vez de master )

Algunos comandos visto hasta aquí
git commit -am “mensaje”: hace un add y luego un comit a los archivos previamiente modificados, sin embargo solo funciona con archivos que se les hizo add la primera vez.

comando para las ramas o branchs
git branch nombre-rama: crear una nueva rama
git branch: ver las ramas existentes y donde estas
git checkout nombre-rama: para cambiar de una rama a otra
git show: ver los cambios y las ramas donde estamos

Comandos para servidor remoto
git clone url_del_servidor_remoto: Nos permite descargar los archivos de la última versión de la rama principal y todo el historial de cambios en la carpeta .git.
git push: Luego de hacer git add y git commit debemos ejecutar este comando para mandar los cambios al servidor remoto.
git fetch: Lo usamos para traer actualizaciones del servidor remoto y guardarlas en nuestro repositorio local (en caso de que hayan, por supuesto).
git merge: También usamos el comando git fetch con servidores remotos. Lo necesitamos para combinar los últimos cambios del servidor remoto y nuestro directorio de trabajo.
git pull: Básicamente, git fetch y git merge al mismo tiempo.

Comandos de movimiento o eliminación en commits
git rm --cached: Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.
git rm --force: Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos, de modo que podremos recuperarlos si es necesario (pero debemos usar comandos más avanzados).
git reset --soft: Borramos todo el historial y los registros de Git pero guardamos los cambios que tengamos en Staging, así podemos aplicar las últimas actualizaciones a un nuevo commit.
git reset --hard: Borra todo. Todo todito, absolutamente todo. Toda la información de los commits y del área de staging se borra del historial.
git reset HEAD: Este es el comando para sacar archivos del área de Staging. No para borrarlos ni nada de eso, solo para que los últimos cambios de estos archivos no se envíen al último commit, a menos que cambiemos de opinión y los incluyamos de nuevo en staging con git add, por supuesto.

git init"crea el repo"
ls - al"muestra archivos ocultos"
git status"estado del proyecto"
git add . "añade todo en el directorio a stage"
got commit -m"para mensaje"
git log "muestra los commit"
gi diff(…) (…)"muestra los cambios entre 2 ver"
git log --stat"muestra los comit y cambios"
git reset(…) --hard volver en el tiempo total
git reset(…) --soft volver en el tiempo dejando en staging
git show"muestra ultimo cambio"
git commit -am(para saltarse el add)
git clone url_del_servidor_remoto: Nos permite descargar los archivos de la última versión de la rama principal y todo el historial de cambios en la carpeta .git.
git push: Luego de hacer git add y git commit debemos ejecutar este comando para mandar los cambios al servidor remoto.
git fetch: Lo usamos para traer actualizaciones del servidor remoto y guardarlas en nuestro repositorio local (en caso de que hayan, por supuesto).
git merge: También usamos el comando git fetch con servidores remotos. Lo necesitamos para combinar los últimos cambios del servidor remoto y nuestro directorio de trabajo.
git pull: Básicamente, git fetch y git merge al mismo tiempo.
git branch nombrerama= crea rama
git checkout nombrerama: cambia a la rama
git merge nombrerama: une la rama con el master

Algunos comandos básicos de terminal para tener en cuenta en este curso:

  • cd: para moverse entre carpetas. Ej: cd carpeta_1.
  • cd …: para devolverse a una capeta anterior.
  • mkdir: para crear directorios o carpetas nuevas.
  • vim: Editar archivos de texto. Ej: vin archivo.txt (para guardar cambios en vim: tecla Esc + :wq).
  • rm: Eliminar archivos. Ej: rm archivo.txt.
  • rm -rf: Eliminar directorios o carpetas
  • touch: Crear archivos. Ej: touch archive.txt
  • ls: listar archivos en terminal
  • ls -a: listar archivos ocultos
  • clear: limpiar la vista (no te permite ver la historia desplazando la vista)
  • Crt + L: Limpia la vista del terminal (permite ver la historia desplazando la vista habia arriba)

mirando los números de los commits me di cuenta el merge fue así:

Los cambios quedan en el medio. Así se ve en gitkraken:

Interesante 😃

tambien se puede poner un -m al merge

git merge cabecera -m "fusiono cabecera y master"

git branch -> te permite ver tus ramas
git branch + nombre -> creas una rama nueva
git checkout -> se usa para cambiar entre ramas

Mis apuntes:

¿Y al hacer el merge, sólo queda la rama principal y la otra rama desaparece? ¿o la otra rama sigue ahí?

Dejo todo lo que tengo anotado sobre comandos de Git. (adjunto texto y un screen para que se vea mejor)

GIT:
• git log :: ver el historial de commits.
• git log —stat :: ver el historial de commits con sus específicos cambios en bytes.
• git add . :: inserta archivos cambios al Staging.
• git add nombre-archivo :: es para subir solamente un archivo pasándole el nombre del archivo.
• git branch :: mostrar la lista de ramas y ver en cual se está trabajando actualmente.
• git show :: muestra el ultimo commit hecho.
• esc + shift + Z + Z :: comando para salir de la entrega de mensaje a un commit al ejecutar ‘git commit’ sin mensaje.
• git fetch :: descargar actualizaciones de un repositorio remoto a mi repositorio local.
• git merge :: descargar actualización de un repositorio remoto a mi directorio de trabajo.
• git pull :: descargar actualizaciones de un repositorio remoto a mi directorio de trabajo a mi repositorio local.
• git commit -am “”mensaje :: es el add y commit juntos, (solo funciona con cambios en archivos ya subidos no con archivos nuevos).
• git merge nombre-rama :: fusionar la rama actual con la rama que se ingresó en el comando (nombre-rama).

• git diff :: muestra la comparación de la data actual en comparación con lo que esta en staged.
• git diff código-referencia1 código-referencia2 :: comparar cambios entre commits insertando ambos códigos de referencia de los commits.

• git checkout nombre-de-la-rama :: cambiar de una rama a otra.
• git checkout — . :: regresar al ultimo commit hecho (todos los cambios).
• git checkout codigo-referencia nombre-archivo :: regresar al commit del código que se insertó en nombre código, se puede ingresar un archivo en especifico o que haga el regreso de la data completa. (Se puede volver al futuro).

• git rm —cached :: elimina los archivos del área de Staging y del próximo commit, pero los mantiene en el disco duro.
• git rm — force :: elimina los archivos del git y del disco duro, git guarda todo, se puede acceder al registro de la existencia de los archivos, de modo que se podrán recuperar si es necesario.

• git reset HEAD :: comando para sacar archivos del área de Staging.
• git reset codigo-referencia —soft :: se inserta el código del commit al que se quiere regresar y borra todo pero dejando lo que esté en memoria ram guardado.
• git reset codigo-referencia —hard :: se inserta el código del commit al que se quiere regresar y borra todo lo posterior, incluyendo lo que esté tracked en memoria ram.

Publicare mis apuntes para repaso rapido tambien, ya que, hay muchas formas distintas de apuntar y para algunos, unas formas son mas faciles de seguir que otras. Ojala les guste mi desorden. :
{
-git init// inicia el repositorio

-git add biografia.txt// agrega el archivo a Staging y lo arranca en la RAM

-git add . // agrega todos los archivos que se encuentran en la carpeta

-git commit “cambios a v1”// nos permite agregar los cambios que hemos hecho
#Flag -m nos permite comentar los cambios
#Flag -am Nos permite hacer add y commit al mismo tiempo (solo en archivos ya commiteados anteriormente)

-git status// Se usa para saber si tenemos un archivo nuevo o borrado en el proyecto y en la rama que estamos a la vez sus commits.

-git show// nos indica todos los cambios historicos hechos, lineas codigos, quien lo hizo

-git log biografia.txt// nos permite ver la historia completa de un archivo.
#Flag --stat Muestra todo en detalle

-git push // nos permite enviar los cambios a otro repositorio remoto.

-git rm // Remueve los archivos añadidos

<h1>Flag --cached borra todo su rastro</h1>

-git config// muestras las configuraciones de git
#Flag -list enlista las configuraciones por defecto
#Flag --show-origina inhales muestra las configuraciones guardadas y su ubicacion
#Flag --global hace configuraciones a nivel global de nuestro Git
!#Uses of Git Config --global ""
user.name: cambia el nombre del usuario
user.email: cambia el email del usuario
color.ui true: Colorea la mayor parte de los comandos
–replace-all user.name “name” cambia de nombre el nombre
–unset-all user.name borra el nombre
–add user.name “Name”

-git diff [Commit1] [Commit2] //Funciona como un show, pero especifico y filtrado

-git reset [Commit] //Devuelve a una version anterior del archivo
#Flag --hard, devuelve absolutamente todo el repositorio a ese estado anterior, incluyendo en el staging.
#Flag --soft, devuelve solo el archivo al ambiente de trabajo a ese estado

git checkout //Muestra el archivo en base al tag o la rama que le pases
!#Uses of Checkout
[CommitTag][File] hace que el contenido del archivo vuelva a ser el del commit del tag, mas, es solo en el Staging
[Master][File] Para volver al Master del archivo
#Flag -b [BranchName] Crea una rama y hace un Checkout a esta

^¡WARNING! : No hacer Commit despues de volver a un estado anterior o se guardara Permanentemente en el Repositorio como master, perdiendo los datos posteriores !¡!¡!¡!¡!¡!^

-git clone [URL del servidor] //Nos permite descargar los archivos del URL a una carpeta fisica

-git push //Luego de guardar nuestros cambios de nuestros archivos en Git Local , se usa este comando para mandar los cambios al servidor remoto.

-git fetch //En el caso de que hayan actualizaciones en el servidor remoto, se usa este comando para traerlas al reposiorio local.

-git merge //Combina lo que hay en nuestro Repositorio local con el servidor remoto.

-git pull //Una combinacion de “git fetch” y “git merge”.

-git branch //Muestra todas las Ramas
#Flag -l Enlista los branch como “ls -l”
#… [BranchName] crea una rama con ese nombre

-git checkout [BranchName] //Cambia de branch

-git merge [BranchName] //Fusiona la Branch actual con la que le Coloques
##merge --Squash, como merge trabaja como un compilado de “Commits” al combinar una branch con otra (hacer merge) se concatenan tambien los logs de las dos branchs, esto se puede comprimir en solo el log o commit final con merge --squash
}

Como cuando te cambias al master sin hacer commit
y lo pierdes todo.

proceso de invocacion ante los dioses del desarrollo!!

Muy recomendado siempre andar un rosario de todos los innovadores y precursores de la tecnologia antes de hacer un merge 😄

Hola a todos les comparto un excel, donde llevo apuntando todos los comandos que hasta el momento han aparecido en el curso, con su respectiva descripción

https://docs.google.com/spreadsheets/d/10FxeFsKTIUcGkX7Aqoj_r1Pnbqr7RlnFZxPzrQMN3No/edit?usp=sharing

Espero les ayuda

Saludos

Este comando es excelente si quieren ver el camino que ha tomado con todas las ramas

git log --all --decorate --oneline --graph

Esta fue la solución que encontré para el conflicto al utilizar merge.

Por si a alguien le sirve.

Yo dañe mi código y ahora tengo conflictos, en cada clase daño algo y lo termino arreglando.
¿Ustedes son de los míos?

Haciendo caso al profe Freddy comparto mis apuntes hasta el momento:

Git
Ciclo básico de git:
Untracked área: el archivo no está rastreado, es totalmente desconocido.
Staging area: el archivo esta rastreado. Es temporal y nos muestra los cambios.
Commit área: el archivo se sube y se guarda modificando lo que se tenía anteriormente.

Configurar git:
git config → Muestra la ayuda para la configuración de git.
git config --global user.name “BarckCode” → Indicamos usuario.
git config --global user.email "[email protected]" → Indicamos email.
git config --list → Muestra la configuración actual de git en nuestro repositorio.

Iniciar git en el directorio donde estemos:
git init

Mandar o quitar ficheros del Staging area:
git add [fichero] → Manda solamente al fichero que le digamos al Staging area.
git add . → Manda todos los ficheros que hayan sufrido modificaciones.
Si queremos borrar ficheros que ya están en el Staging area:
git rm --cached [fichero] → Envía nuevamente los ficheros al Untracked área

Mandar o quitar ficheros del Commit área:
git commit → Manda los ficheros que están en Staging area a Commit area
Opciones de git commit
-m “mensaje” → Añade un mensaje para aclarar el cambio guardado.
git commit -am → Hace a la vez un git add . + git commit | Ahorrandonos un paso.

Consultar el estado de nuestros archivos en git:
git status → muestra en qué estado del ciclo de vida se encuentran los archivos
git show [fichero] → muestra los cambios sufridos por en el archivo.
git log [fichero] → muestra los commits guardados en el archivo.
git diff → Muestra las diferencias entre el último commit y las modificaciones actuales que se hayan hecho.
git diff [id del commit a comparar 1] [id del commit a comparar 2] → Nos compara y muestra los cambios sufridos entre los dos commits. Los id de los commit se pueden encontrar ejecutando git log.
Ejemplo de id: a52dae4a7b1181d45e356a6abc7f0b721511ee5a

Volver atrás en el tiempo.
git reset [id del commit] --hard → Se vuelve al estado del id commit indicado. Eliminando todos los cambios posteriores a este.
git reset [id del commit]

Repositorios Remotos:

→ 	|      git add .	 |     → 	      |	git commit	→  |       git push   	|	

Directorio de Trabajo → Preparación o Staging → Repositorio Local → Repositorio Remoto
| | git clone url ←
| ← git fetch | ←
| git fetch ←
| ← | git pull ←

Ramas y Branches:
Ejemplo de uso:
Tenemos 3 ramas. Master (Producción), Development (Desarrollo), BugFixing(Arreglos). En el ejemplo vemos había un producto en master. Pero que a su vez se ha ido desarrollando el producto en otra rama (Development) pero después de un tiempo descubrieron un fallo en su código que arreglaron en otra Rama (BugFixing).
Tras solventarlo fusionaron el trabajo donde habían reparado el error con el que estaban desarrollando. Tras desarrollar una versión estable y sin errores lo lanzaron a producción fusionando la rama Development con la rama Master.

O Master --O – -- – -- – O
\ /
O Development – O --O --O – -- O --O
\ /
O BugFixing – -- – O --O --O

Ver ramas disponibles:
git branch

Crear ramas:
git branch Development

Moverse entre ramas:
git checkout Development

Fusionar ramas:
Debemos asegurarnos antes de ejecutar el siguiente comando que el HEAD esté apuntando a master. En otras palabras que estemos situados en la rama master o en su defecto en la rama donde queramos continuar con los cambios.
git merge Development

![](

Soy de la vieja escuela, mejor, soy vieja, alguno me recomienda alguna herramienta para generar apuntes digitales? Gracias

Aqui la solución a mi pregunta del video anterior, sobre que pasaba a quí, faltaba colocar el fin de las comillas " y enter.

solución a consulta anterior. Excelente.

Con el comando:
git log --oneline --graph
vemos graficadas las ramas

Antes de hacer un merge a la rama master me invoco a los dioses del desarrollo Esto era lo que me falta 😂😂😂😂😂😂😂😂

Dato interesante para quienes quedamos con las dudas de cual pagina consulto freddy para hacer el efecto de sombra en la pagina fue esta: https://cssmatic.com/

Brujeria

buenisimo practicar, un tip:
1 podrian ver el video completo tomar apuntes.
2 luego intentar hacerlo solo con los apuntes tomados.

Si todo sale bien sus apunetes estan bien tomados, y si no ver el video verificar y corregir!!

mis apuntes de los git
GIT INIT ( sirve para indicar la carpeta “previamente selecccionada” en la que se creara un repositorio en el disco duro o staggng)
git add “e.g. Archivo.txt” (sirve para agregar un archivo especifico al area de stagging)
git add . (sirve para agregar todos los archivos al area de stagging)
GIT COMMIT -M “mensaje” (sirve para enviar todos los archivos del area de stagging al area del repositorio o “master”)
GIT SHOW ( me muestra los cambios que han sido realizados a traves de las versiones)
GIT LOG: ( me muestra las versiones que han sido guardadas en “Master”)
Git log –stat: sirve para mirar los cambios en cada versión

GIT CHECKOUT ( me permite devolver en el tiempo un archivo a una version anterior sin borrar la actual o simplemente toda la carpeta
para que me muestre la version anterior en un archivo en específico debo indicar al final el nombre del archivo) con checkout master y el nombre del archivo regreso a la ultima versión o a la versión actualizada
GIT DIFF (indicandole las versions que queremos, nos muestra las diferencias entre ellas)
GIT RESET XXXXXXXXXXXXXXXXXXXXXX --HARD (este devuelve en el tiempo el projecto y elimina todo lo realizado posteriormente a la version a la que estamos volviendo)
GIT RESET XX --SOFT (este elimina los archivos del commit pero mantiene los archivos del area de stagging)
GIT RESET XXXXXXXXXXXXXXXXXXXXXX HEAD ( sirve para pasar los archivos de staging a unstaged en caso de que queramos editar algun archivo o lanzar en otra actualizacion
algun cambio que no era para este commit sino para un commit futuro)
GIT RM --CACHED: (Elimina los archivos del área de Staging y del próximo commit pero los mantiene en nuestro disco duro.)
git rm --force: (Elimina los archivos de Git y del disco duro. Git siempre guarda todo, por lo que podemos acceder al registro de la existencia de los archivos,
de modo que podremos recuperarlos si es necesario
(pero debemos usar comandos más avanzados).)
GIT CLONE URL (sirve para clonar el proyecto de un repositorio ubicado en un servidor a mi repositorio y directorio de trabajo)
GIT PUSH (sirve para enviar todos los datos actualizados en mi repositorio al repositorio del servidor.)
GIT FETCH (Importas un archivo desde el servidor remoto de tu equipo, al repositorio)
GIT MERGE (Importa un archivo desde el repositorio hasta tu proyecto real del disco duro),
GIT PULL (La unión de trabajo del fecth y el merge importa al repositorio y al disco duro proyecto real.)
GIT COMMIT -A (sirve para agregar directamente a master sin pasar por el staging este nos evita el paso de add)
GIT BRANCH (sirve para ver las ramas creadas o sirve para crear una rama dependiendo de su uso, si usas el comando tal cual lo leiste,
solo te mostrara las ramas existentes, pero si lo usas de este modo e.g. (git branch "inserte aca nombre que le quiera proporcionar a la rama"
obviamente sin las comillas, crearas una rama nueva con el nombre que quieras.)
GIT COMMIT -AM (sirve para agregar al repositorio local los archivos que estas trackeando con un mensaje

La base y la teoria se aprende en el curso de Git y Github de LeonidasEsteban, buen curso,

Con éste curso se consolidan los conocimientos con mucho más práctica con Freddy.

git commit -am “mensaje” - Es una forma más sencilla de hacer commit (Solo funciona cuando el archivo ya fue trackedo)

git branch - Nos permite ver las ramas de nuestro repositorio
git branch ‘nombre_rama’ - Para crear una rama
git checkout ‘nombre_rama’ - Para movernos entre ramas
Nota: Si no hacemos commit antes de pasar a otra rama vamos a perder nuestros cambios

**Para hacer merge, nos vamos a la rama a la que queremos traer los cambios y hacemos git merge ‘nombre_rama’, con esto nos mandara al editor para darle un mensaje al commit (por que un merge es un commit) y listo tendremos nuestros cambios fusionados (si no existe ningun conflicto) **

Las cosas no salieron como esperaba 💔 jajaja a segir practicando

Lo que se me vino a la cabeza en el minuto 11:29 “Pero, ¿Qué pasa cuando hay un conflicto? ¿Qué pasa cuando dos programadores cambian las mismas líneas de código y son diferentes?”

![](