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 un 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

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Analizar cambios en los archivos de tu proyecto con Git

9/43
Recursos

El comando git show nos muestra los cambios que han existido sobre un archivo y es muy útil para detectar cuándo se produjeron ciertos cambios, qué se rompió y cómo lo podemos solucionar. Pero podemos ser más detallados.

Si queremos ver la diferencia entre una versión y otra, no necesariamente todos los cambios desde la creación del archivo, podemos usar el comando git diff commitA commitB.

Recuerda que puedes obtener el ID de tus commits con el comando git log.

Comandos para analizar cambios en GIT

  • git init: inicializar el repositorio
  • git add nombre_de_archivo.extensión: agregar el archivo al repositorio
  • git commit -m “Mensaje”: Agregamos los cambios para el repositorio
  • git add: Agregar los cambios de la carpeta en la que nos encontramos agregar todo
  • git status: visualizar cambios
  • git log nombre_de_archivos.extensión: histórico de cambios con detalles
  • git push: envía a otro repositorio remoto lo que estamos haciendo
  • git pull: traer repositorio remoto
  • ls: listado de carpetas en donde me encuentro. Es decir, como emplear dir en windows.
  • pwd: ubicación actual
  • mkdir: make directory nueva carpeta
  • touch archivo.extensión: crear archivo vacío
  • cat archivo.extensión: muestra el contenido del archivo
  • history: historial de comandos utilizados durante esa sesión
  • rm archivo.extensión: Eliminación de archivo
  • comando --help: ayuda sobre el comando
  • git checkout: traer cambios realizados
  • git rm --cached archivo.extensión: se utiliza para devolver el archivo que se tiene en ram. Cuando escribimos git add, lo devuelve a estado natural mientras está en staging.
  • git config --list: muestra la lista de configuración de git
  • git config --list --show-origin: rutas de acceso a la configuración de git
  • git log archivo.extensión: muestra la historia del archivo

Aporte creado por: Stefania Ortega

Aportes 970

Preguntas 217

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Tomen compañeros! 😄

Comparto con ustedes por si les interesa los comandos de los que he tomado nota. junto con su descripción

$ git init //inicializar el repositorio
$ git add nombre_de_archivo.extencion //Agregar el archivo al repositorio
$ git commit -m “Mensaje”// Agregamos los cambios para el repositorio
$ git add .// Agregar los cambios de la carpeta en la que nos encontramos agregar todo
$ git status // visualizar cambios
$ git log nombre_de_archivos.extencion //historico de cambios con detalles
$ git push //envia a otro repositorio remoto lo que estamos haciendo
$ git pull //traer repositorio remoto
$ ls //listado de carpetas en donde me encuentro es decir dir en windows
$ pwd //ubicacion actual
$ mkdir //make directori nueva carpeta
$ touch archivo.extencion//crear archivo vacio
$ cat archivo.extencion//muestra el contenido del archivo
$ history //historial de comandos utilizados durante esa sesion
$ rm archivo.extencion //eliminacion de archivo
$ comando --help //ayuda sobre el comando
$ checkout //traer cambios realizado
$ git rm --cached archivo.extencion//se usa para devolver el archivo que se tiene en ram cuando escribimos git add lo devuleve a estado natural mientra esta en staging
$ git config --list //muestra la lista de configuracion de git
$ git config --list --show-origin//rutas de acceso a la configuración de git
$ git log archivo.extencion //muestra la historia del archivo

En Ubuntu normalmente edita en “nano” o "vim"
En el minuto 3:20 para salir de la opción de ingresar un mensaje se debe ingresar los siguientes comandos

nano

Ctrl + o
Enter
Ctrl + x

VIM

Esc
:wq
Enter
****************
:w = escribir o cuardar
:q = Guardar o salir

Para no hacer el copiar y pegar en la consola, puede hacer lo siguiente:

  1. digitar el comando git diff (espacio)
  2. buscar y escoger la linea a copiar y subrayar
  3. Dar clic en la rueda del scroll en el mouse e inmediatamente realiza la copia de lo subrayado

Mis apuntes:

Una lista de los comandos utilizados:

Para mostrar los diferentes estados de los archivos en tu directorio de trabajo y área de ensayo (staging):

git status

Para ver los cambios entre tu entorno de trabajo y tu área de ensayo (staging):

git diff

Para agregar cambios de tu entorno de trabajo a tu área de trabajo (staging):

git add .

Para remover cambios agregados a tu área de trabajo (staging):

git rm --cached <archivo>

Para registrar una nueva instantánea permanente en la base de datos del repositorio.

git commit -m "Comentario"

Traer una imagen de un archivo de una instatánea de la base de datos al entorno de trabajo. Se puede reemplazar el <commit-id> por el nombre de la rama, ejemplo “Master”.

git checkout <commit-id> <archivo>

Se utiliza sobre todo para deshacer las cosas,

git reset 

Presenta un registro de commits de la base de datos.

git log

Lo mismo del punto anterior, pero aplicado a un archivos específico.

git log <archivo>

Presenta los cambios específicos de los archivos a partir del commit. Ante muchos cambios, se usan las fechas “up/donw” para moverse en la pantalla y la tecla “q” para salir.

git log --stat

Importante, a GIT no le interesa la carpetas, solo los archivos. Las carpetas son consideradas rutas de los archivos…

Otra forma para grabar en Vim es usar ESC y luego escribir :wq
Me parece más práctico que Shift + z+ z-

Si quieren practicar y entender un poco mas git, les recomiendo esta pagina.

https://learngitbranching.js.org/

⚡⚡⚡

Para editar un archivo en Vim:

  1. Presionar la tecla I para **entrar ** al modo INSERTAR
  2. Presionar **Esc ** para **salir ** del modo INSERTAR
  3. Escribir :w para **guardar ** los cambios
  4. Escribir :q para **salir ** de Vim

Se pueden omitir los pasos 3 y 4 escribiendo en su lugar :x que lo que hace es guardar y cerrar en un solo paso.

A mi no me funcionaba el Esc+Shift+Z+Z. Asi que usé los comandos que aparecen en la parte de abajo: Ctrl+X para salir, después Y para aceptar los cambios y Enter para finalizar.

Al usar los comandos git log y git show caí en la cuenta de que en mi caso no me mostraba la información en la misma pantalla del terminal como a Freddy, sino con el visor de archivos del terminal, con lo que era necesario pulsar “q” para salir,
A la hora de usar el comando diff y copiar los hash númericos de cada commit era un poco molesto.

Si alguien tiene este mismo problema, basta cambiar la variable global core.pager, para que utilice el comando cat

git config --global core.pager cat

git show me cambia la vida

Mis apuntes de los comandos . junto con su descripción de esta clase

$ git init //inicializar el repositorio
$ git add nombre_de_archivo.extensión //Agregar el archivo al repositorio
$ git commit -m “Mensaje”// Agregamos los cambios para el repositorio
$ git add .// Agregar los cambios de la carpeta en la que nos encontramos agregar todo
$ git status // visualizar cambios
$ git log nombre_de_archivos.extensión //histórico de cambios con detalles
$ git push // Envía a otro repositorio remoto lo que estamos haciendo
$ git pull // traer repositorio remoto
$ ls // Listado de carpetas en donde me encuentro es decir dir en windows
$ pwd // Ubicación actual
$ mkdir // make directory nueva carpeta
$ touch archivo.extensión// Crear archivo vacío
**$ cat archivo.extensión// **Muestra el contenido del archivo
$ history // Historial de comandos utilizados durante esa sesión
$ rm archivo.extensión // Eliminación de archivo
$ comando --help // Ayuda sobre el comando
**$ checkout // **Traer cambios realizado
$ git rm --cached archivo.extensión// Se usa para devolver el archivo que se tiene en ram cuando escribimos git add lo devuelve a estado natural mientra esta en staging
$ git config --list // Muestra la lista de configuración de git
$ git config --list --show-origin// Rutas de acceso a la configuración de git
$ git log archivo.extensión // Muestra la historia del archivo
espero sirva mis apuntes a alguien (y si hay errores me comenta y si falta algo mas) madre mia!! creí que no iba a terminar jajajaja y valla que me es dificil pero no me rindo #NuncaParesdeAprender ❤️

En Ubuntu 18.04 al poner commit sin referencias, en lugar de abrir el editor VIM, me llevó al editor NANO. en ese caso, se escribe directamente. Luego, se guarda con Control + O + Enter , y luego se sale con Control + X

Estos son algunos comandos que pueden utilizar para salirse del VIM:

:q – quit
:q! – quit without saving, even if modified
:cq – quit always without writing
:wq – write / save the current file and exit
:wq! – write the current file and exit always
:wq (name) – write to file (name) and exit
:wq! (name) – write to the file (name) and exit always, even if modified
ZZ – save the current file if modified, then exit
ZQ – quit and exit without saving

Genial !!! acabo de encontrar como se relacionan los comandos que ejecutamos en la cónsola, con lo que realizamos en la interfaz de Atom.

Con el siguiente comando :

git log --oneline --decorate

Puedes ver los commits y los merge de manera gráfica.

Ademas, por comodidad, git te permite guardar “alias” para que crees tu secuencia de comandos y la puedas usar de manera rápida.

git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"

Casi que no salgo, después del intento 50 encuentras la solucion.

(ESC + Shift + Z + Z)```

Increíble este poder de Git. El resumen de la clase en términos de comandos es el siguiente:

$git show _archivo_ (Muestra los cambios que han existido en el archivo)
$git commit (Va a crear un mensaje pero para eso abrirá VIM ya que es necesario un mensaje:
**Comando VIM:**
++Escribir:++ ESC+I
++SALIR:++ ESC+SHIFT+Z_Z
en VIM se escribe el mensaje y después se sale para hacer el commit)
$git diff _tag1_ _tag2_ (Hace la comparativa de cambios entre el archivo en su etapa en el commit del tag1 y del tag2. Considera al más reciente como tag2 y al original como tag1, SI IMPORTA EL ORDEN DE LOS TAGS)

Espero que sea de utilidad.

Si presionas ctrl y haces doble click con el botón derecho lo que tienes seleccionado, automáticamente te escribe en la terminal lo que quieres copiar

Algo que había aprendido del curso antiguo…
Git diff [referencia del commit escogido]: Al solo poner un solo parámetro (commit), comparara la versión inicial con la actual.

si queremos hacer dos cosas a la vez:

git commit -a -m “descripcion del cambio”

agrega los archivos que hemos trackeado
hace el commit con el comentario

“Como así que no va a mandar un mensaje…Usted está loco??” Si te ries aprendiendo…nunca lo olvidas. Genial como siempre señor Vega

Vim - Modo Insert / Editar

i

Salir de Vim

Esc Para salir del modo editar

:q    // quit - salir sin guardar
:q!   // quit important - salir forzado sin guardar
:wq // write & quit - guardar y salir
:x    // igual a :wq

Con comandos
Esc Para salir del modo editar

Shift + Z Z // guardar y salir
Shift + Z Q // salir sin guardar

Más comandos de Vim

Vim Commands Cheat Sheet

Aprende VIM mientras juegas.

En Mac para salir de vim y guardar: ESC + : + wq + enter

GIT SHOW
Muestra:

  • SHA(Secure Hash Algorithm) de último commit
  • Quién y cuándo realizó el último commit.
  • Mensaje de último commit
  • Hace un diff (comando) de la versión anterior(a) con la versión nueva(b) para mostrar las diferencias entre versión a y versión b

En uno de los cursos anteriores de Git en Platzi configuramos otro editor de texto para escribir el texto de nuestros commits. Para añadir Atom por ejemplo simplemente ejecuten la siguien línea:

$ git config --global core.editor atom --wait

Con el --wait lo que hacemos es que se quede esperando a que confirmemos los cambios.

Espero que les sirva !

LES COMPARTO COMPAÑEROS

Cuando escribimos git commit y le damos Enter se abre una consola, es un editor dentro de la linea de comandos se llama VIM. Todo lo que aparece seguido de un # son comentarios. Para comenzar a escribir texto se presiona esc + i. Para regresar a Git se presiona esc + shit + zz y

  • Cuando hacemos commit sin comentario te va abrir automaticamente VIM;.
    para configurar otro editor de texto realizamos el siguiente comando:

git config --global core.editor “code --wait”

  • Lo que hace el comando es configurar de manera predeterminada el Visual Studio Code y cuando coloquen un commit sin comentarios automaticamente les va abrir el Visual Studio Code

Para salir de vim hay que soltar Esc para luego hacer “shift + z z”

Si queremos usar los hash y se nos hace incómodo que sean tan largos. Pueden usar --oneline al hacer log. Sirven igualmente a la hora de chequear los diffs 😄

¿Cansado de que cuando le das commit sin -m “mensaje” te abra el feo editor vim? (2:40 en el video de esta clase)
Puedes cambiarlo al editor nano, emacs, o incluso code simplemente con:

git config --global core.editor nano 

Por si lo necesitan, puede que les sirva:
Git Bash
pwd: Tu ubicación actual en carpetas, archivos, etc…
ls: Archivos que tengo en la carpeta"X";
cd: Abrir carpetas/archivos
git init: Crear repositorios dentro de la carpeta de mi proyecto
git -al: Archivos ocultos
git status: Ver estado del proyecto
git add: Añado cambios
**git commit -m"Aquí va tu mensajito"😗*Añado commits + mensaje
car archivo.extencion: Ver contenido del archivo pero no editarlo
git log archivo.extencion: historia del archivo
git show archivo.extencion: comprar cambios
git diff: comprar versiones que desee

Si cometí algún error corrigelo en las respuestas, espero que les sirva

Si no tienen acceso a visual estudio desde la linea de comando, consulten lo siguiente:

https://code.visualstudio.com/docs/setup/mac

Lanzamiento desde la línea de comando
También puede ejecutar VS Code desde la terminal escribiendo ‘code’ después de agregarlo a la ruta:

Lanzamiento VS Code.
Abra la Paleta de comandos ( Ctrl + Shift + P ) y escriba ‘comando de shell’ para encontrar el comando de Shell: Instalar el comando ‘código’ en el comando PATH .
comandos de shell de macOS

Reinicie el terminal para que el nuevo $PATHvalor surta efecto. Podrá escribir ‘código’. en cualquier carpeta para comenzar a editar archivos en esa carpeta.
Nota: Si aún tiene el antiguo codealias en su .bash_profile(o equivalente) de una versión anterior de VS Code, elimínelo y reemplácelo ejecutando el comando Shell: Instale el comando ‘código’ en el comando PATH .

Para agregar manualmente el código VS a su ruta, puede ejecutar los siguientes comandos:

cat << EOF >> ~/.bash_profile

<h1>Add Visual Studio Code (code)</h1>

export PATH="$PATH:/Applications/Visual Studio Code.app/Contents/Resources/app/bin"
EOF
Comience una nueva terminal para recoger sus .bash_profilecambios.

Nota : La barra diagonal inicial \es necesaria para evitar que se $PATHexpanda durante la concatenación. Elimine la barra diagonal inicial si desea ejecutar el comando de exportación directamente en un terminal.

Apuntes hasta el momento:
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.

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 [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

Brutal la forma de enseñar de Fredy !!! Gracias.

git log

Te muestra el historial de los commits que has hecho

git log # Muestra todos los commits con la información default
git log -3 #ultimos tres commits
git log --oneline #Resumido
git log --oneline --graph #Te lo muestra Resumido y bonito

git show

Es como log, pero con la diferencia de que muestra los cambios precisos que se hicieron en el commit

git diff

Nos compara y muestra los cambios sufridos entre los dos commits. Los id de los commit se pueden encontrar ejecutando git log.

git diff <referenci sha1> #
git diff <referencia2> <referencia1> <archivo>

Cómo puedo hacer para que me mantenga la milea de comandos y seguir editando? ya le dí Ctrl Z pero lo quie quiero es verlo como a Freddy que puede copuar los id de los commit

Para que se tenga un comando que permita ver mas comodamente los commits se ejecuta en la terminal:

git config --global alias.superlog "log --graph --abbrev-commit --decorate --date=relative --format=format:'%C(bold blue)%h%C(reset) - %C(bold green)(%ar)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(bold yellow)%d%C(reset)' --all"

y cada que se quieran ver la lista de commits se escribe git superlog

Comandos de VIM.

  • :q para quitar sin guardar.
  • :q! para quitar sin guardar (forzando).
  • :wq para guardar y quitar.

“w” significa “write” (escribir).
“q” significa “quit” (quitar).

Para acceder se presiona ESC y escriben los dos puntos ( : )

Siento que esta herramienta , la voy a utilizar way too much más adelante.
Gracias Freddy.
Aprovecharé esta cuarentena al 100.

Desde Ubuntu es un poco diferente el tema de los commits, me costo un poco encontrar como salir de VIM. 😂

😄 Por si quieren aprender un poco de VIM jugando:

vim-adventures

esc + shift + zz = esc + : +wq! + enter

Para salir de la interfaz de mensajes hace falta presionar

Esc + Shift + z + z

Vi el video 3 veces, ya lo entendi!

  • La vida y su log.
    .

Los dias que pasan constan de cientos de commits irremplazables,
mas no puedes usar un reset o un rebase,
sin embargo, este repositorio de hoy,
tu y yo en este instante… en este directorio,
formamos un log entrelazandose,
showing cada version… cada commit… incluido este.

git show: con el se visualizan los cambios realizados a un archivo específico con el correr de los commits
git diff : Se comparan dos archivos commiteados, identificados con su tag, sirve para ver la diferencia y las modificaciones que sufrió el archivo entre estos commits
**OJO=>**git no permite enviar un commit sin mensaje, en caso que se intente hacerlo, git abre automáticamente el VIM(editos de códigos de git) para poder cargar un mensaje, con ESC+I se edita el mismo, y pulsando ESC+SHIFT+ZZ se guarda el mensaje, se cierra VIM y se fuerza el envío del commit pendiente

Es lo que entendí

Comandos GIT vistos hasta ahora

git config --list //Lista las configuraciones
git config --global user.name "Mr Internauta"
git config --global user.email "[email protected]"
git init //Inicializar un directorio como un proyecto git
git add nombreArchivo.txt //añadir un archivo al staging
git add . //añadir todos los archivos al staging
git commit -m "mensaje (version1)" //Añadir los cambios a la rama master(Se puede realizar el commit sin el mensaje pero es mala practica)
git commit
	*Presionar ESC, I
	*Escribir el comentario
	*Salir ESC + Shift, zz (fuerza el comentario)
git status //ver el estado actual del proyecto
git log //ver los cambios del proyecto
git log nombreArchivo.txt //Se pueden ver los cambios de un archivo en particular
git show //cambios que han existido sobre el repositorio
git show nombreArchivo.txt //cambios que han existido sobre un archivo
git diff 1a8c87e791862aff011108a94882c25cfab42add dfb3cac1daa4e8e6cdaabb987015894d4e32ba18 //nueva vieja
git diff 1a8c87e791862aff011108a94882c25cfab42add dfb3cac1daa4e8e6cdaabb987015894d4e32ba18 //vieja nueva

Estoy haciendo mis ejercicios mientras veo el video, y los cambios que estoy haciendo son los apuntes que tomo con el editor de texto ocupando Markdown se los recomiendo, así generas documentación y posteriormente la puedes agregar a la wiki de GitHub, con los temas aprendidos =D

🎈 git show nos permite ver detalles ampliados de los objetos de Git, como árboles, etiquetas y commits en un proyecto…

Si están en WSL y no salen de la interfaz de vin con
Esc + Shift + Z + Z
usen Ctrl + X luego le dan Yes con “y” y luego Enter y listo.

Recomendación: Mientras Freddy explica, tu en tu PC ve siguiendole los pasos y como el dice al final: Ve creando tu propia historia 👍
Aca les comparto la mia jejeje

Esta es la historia de Thonny Gonzalez.

Thonny Gonzalez tiene 23 años y nació en Venezuela,
pero vive en Colombia.

En camara parece gruñon, pero en realidad es amable.

Hoy es un muy entusiasta alumno de Platzi.

Si estas usando Ubuntu como tu sistema operativo principal, un método sencillo de copiar los commits es:

git show > log: esto almacena el output del git show en un archivo llamado log.

cat log: imprime el contenido de log en terminal.

De esa manera sera mucho mas sencillo copiar los commits y comparar todas sus versiones.

También se puede usar el comando git log --oneline, para que muestre los log mas cortos.

### Ver cambios realizados en un archivo

git show NOMBRE_ARVHIVO

### Comparar los cambios de un archivo

git diff commitA commitB.

//Se deben comparar los tags del mas viejo, al mas nuevo

Para cambiar el editor a nano podemos ejecutar el siguiente comando:

$ git config --global core.editor “nano”

Personalmente me gusta mas usar nano por que desde cuando empeze con Linux en Cent Os se me hacia super complicado entender el :wq.
En nano se ocupa el “CTRL + O” para guardar y el “CTRL + X” para salir.

Nano se puede seleccionar al instalar git.

Para los que no puedan salir al momento de hacer el commit sin comentarios , pueden intentar con con este comando: :q

Otra forma de realizar git commit y luego salir realizando el cambio es usa Esc luego nos dejara escribir en la parte inferior izquierda y escribimos :wq y damos enter.

El codigo con que se identifica un commit se conoce como SHA es posible y más comodo trabajar con tags.
Para agregar un tag escribes $git tag -a -m "mensaje del tag"
para ver la lista de tags escribes $git tag -l
y para ver las diferencias entre tags simplemente escribes: $git diff Tag#1 Tag#2

Compañeros mi resumen:

* git show archivo.txt "Nos permite visualizar la lista de cambios"

* "Cuando no agregamos un comentario (solo usamos commit) nos aparecerá un editor de código, para agregar el comentarios usar el siguiente comando:" Esc + I 

* "Para salir del editor de código usar el comando:" Esc + shift + z+ z

* "Para visualizar las diferencias entre las versiones del archivo usar el comando:" git diff _____(pegar el código de commit 1) _______ (pegar el código del commid 2)

Curiosidad: Se puede agregar y realizar el commit al mismo tiempo con el modificador -am
es decir se usa:

git commit -am "Mensaje del commit para el archivo"

En lugar de

git add .
git commit -m "Mensaje del commit"

CHICOS!!
Cuando dice que para salir de ese editor de texto en cual es muy rara la zona de escape, no se mareen, tranquilos.
La tecla “sky” (o algo así dice" es la tecla “ESC”. Para los que como yo, nacieron con una computadora en la que la tecla SHIFT era la de borrar, bueno, ya no es más la misma, ahora es una tecla que tienen a su izquierda con una flechita para arriba.
Y bueno, la Z, creo que todos sabemos cual es la Z y donde está… (se refiere a la letra Z)

No es necesario mantener las 3 teclas presionadas al mismo tiempo, no les va a dar la mano tampoco jajaja…
ÉXITOS

En el momento que sombrean los ID de los commits:

Copy = Ctrl + Ins (Insertar)
Paste = Shift + Ins

Consejo: Si sale error es probable que estés diferenciando un mismo ID de un commit😉

Creo que ya lo saben pero de todas maneras, asegurense que el “esc + shift +ZZ” sea en mayusculas para poder salir del editor de comentarios. Buen día.

Encontré de casualidad una forma de copiar y pegar los commits mucho mas rápido.
Cuando seleccionamos el commit que queremos copiar, en vez de darle copy, damos paste y queda pegado en donde lo necesitamos, sin necesidad de copiar y luego pegar.

Si a diff solo le pasamos un commit como argumento va a comparar nuestro estado inicial con el commit que le pongamos.

git log : historia de commits
git show +arch : ultimos cambios en el archivo
git diff +idcommit +idcommit : ver diferencias entre commits “el orden importa”

Git es genial, es como tener una maquina del tiempo y a la vez puedes viajar a través de realidades alternas jajaja

Los aportes de la cominidad son simepre interesantes.

Pueden apuntar la variable “core.editor” para que el editor predeterminado sea Visual Studio Code o el que mas les guste.

Si quieren usar los shortcuts de teclado para copiar y pegar desde la terminal tienen que agregar el “Shift”, es decir: Copiar (Ctrl + Shift + C) Pegar (Crtl + Shift + V)

ahora no necesitas usar esc+shift+z+z solo con ctrl+x luego darle y = de yes cuando abajo en la ultima linea te pregunta si deseas guardar los cambios

chicos!!! estoy descubriendo una herramienta mágica: prueben gitkraken https://www.gitkraken.com, con ella puedes hacer adds y commits con un solo click, ver cambios de manera visual, incluye terminal por si gustan hacer las prácticas de este curso, es excelente 👌

<h3>Configurar Git</h3>

El - indica que es una palabra recortada y el – indica que es una palabra completa.

  • git config: Muestra todas las configuraciones de Git.
  • git config --list: Muestra un listado de la configuración actual de git y lo que le falta.
  • git config --list --show-origin: Muestra la ubicación de la configuración de Git.
  • git config --global user.name "nombre usuario": Cambia el nombre de usuario de Git.
  • git config --global user.email "correo": Cambia el correo del usuario de Git.
<h3>Crear un repositorio local</h3>

Debemos ubicarnos en la carpeta donde están todos los archivos o donde vamos a trabajar y escribimos git init lo cual creará una carpeta llamada .git, esto es el repositorio, una base de datos con todos los cambios atómicos hechos en los archivos.

Con code archivo abres el archivo en Visual Studio Code y con solo code abres Visual Studio Code.

Si no funciona el comando code entonces sigue los siguientes pasos:

  • Abre Visual Studio Code
  • Presiona ctrl (cmd en mac) shift p
  • Busca una opción que diga lo siguiente: Shell Command: Install ‘code’ command in $PATH
  • Selecciónala

Y listo, podrás utilizar dicho comando.

  • git status: Muestra el estado de los archivos, si están en el staging o en el repositorio y especifica lo que debe hacer si no ha hecho commit o add.
  • git add . : Añadir todos los archivos al staging.
  • git rm --cached archivo: Elimina el archivo del staging.
  • git commit -m "mensaje": Envía el/los archivos al repositorio con un mensaje, es de buenas prácticas colocar un mensaje para saber qué se hizo.

Una buena practica es siempre con git status revisar el estado del repositorio y del estado de los archivos.

  • git log archivo: Muestra todos los cambios hechos en el archivo.
  • git show archivo: Muestra los cambios hechos en el archivo de una forma más detallada, incluyendo las versiones anteriores.

Si haces un commit sin un mensaje, entras al editor de código vim y debes escribir un mensaje para poder hacer el commit. Con esc shift z z sales de vim, con esc i puedes ingresar texto.

  • git diff códigocommit códigocommit: Compara a los dos commits y señala las diferencias. Lo mejor es colocar primero el commit más antiguo.

CAMBIAR DE EDITOR

Si el editor de texto que seleccionaste por defecto fue Vim y resulta un poco complejo para iniciar, puedes cambiarlo para usar otro de tú preferencia, en mi caso seleccione Visual Studio Code. Puedes realizarlo de estas dos maneras.

  1. Usa este comando para especificar el editor.
 git config --global core.editor "code"
  1. Abre el archivo de configuración y especifica el editor.
git config --global --edit

Si ya tienes tu terminal configurada con .zsh, Tilix y Oh-my-zsh y a la hora de ejecutar el comando:git log (archivo) les abre el log con less por defecto y no pueden copiar los identificadores de los commits, pueden cambiarlo a abrirlo con cat ejecutando el siguiente comando:

$ git config --global core.pager cat

y listo 😉

Para quienes no les funcione el esc + shift + z + z pueden escribir el mensaje y después hacer ctrl + x para salir, les pedirá si quieren guardar los cambios, colocan y.
y = yes

Para salir del modo de inserccion en el editor del commit, les dejo los pasos:
1- Presionar Escape - ESC una vez y soltar
2- Luego Presionar Shift + zz

Sin darme cuenta estaba haciendo un commit en vcode y en git, me dió conflicto y se me bloqueo. Desbloqueé haciendo
rm -f .git/index.lock
es decir, borrando el fichero de bloqueos, y haciendo de nuevo git commit -am “El texto”

Nunca había sufrido tanto en un curso jajaj pero lo amo

Tambien pueden guardar y salir con:

esc + :x

Si por alguna razon cuando ejecutan el comando “git log” no los deja hacer nada, presionen la tecla q para salir.

Si estan usando On My Zsh y quieren que el log/diff se imprima en la consola git config --global core.pager cat

Para los que al usar git log , git los envie a una sección o pagina en el bash y no puedan salir. para hacerlo digiten la letra q para que git los envíe de regreso a la ventana usual.

que bueno es el git diff

Para copiar directo en la terminal utiliza shif + ctrl + c
y para pegar en la terminal utiliza shif + ctrl + v

Cuando usamos atajos de teclado incrementamos enormemente nuestra productividad espero les sirva, puesto que utilizaremos la terminal como no tienen idea

genial iba practicando con fredy e igual iba haciendo todo, excelente :d sigamos

shift + ZZ

Hola muchachos alguien sabe como salgo de este buckle ? siempre se queda donde dice end y no me deja volver a bahs para poder continuar con mis comandos

Tengo que seguir practicando todos y cada uno de los comandos

Les recomiento este alias para generar un superlog de git, lo dieron en cursos anteriores aquí en platzi y merece la pena que le den un ojo, es genial, solo copien y peguen el comando del gist(crea un alias para un log más completo dentro de git), y despues pueden invocar el superlog con git superlog