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

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

38/43
Recursos

Git Cherry-pick es un comando que permite tomar uno o varios commits de otra rama sin tener que hacer un merge completo. Así, gracias a cherry-pick, podríamos aplicar los commits relacionados con nuestra funcionalidad en la rama master sin necesidad de hacer un merge.

Para demostrar cómo utilizar git cherry-pick, supongamos que tenemos un repositorio con el siguiente estado de rama:

a -b - c - d   Master
         \
           e - f - g Feature

El uso de git cherry-pick es sencillo y se puede ejecutar de la siguiente manera:

git checkoutmaster

En este ejemplo, commitSha es una referencia de confirmación. Puedes encontrar una referencia de confirmación utilizando el comando git log. En este caso, imaginemos que queremos utilizar la confirmación ‘f’ en la rama master. Para ello, primero debemos asegurarnos de que estamos trabajando con esa rama master.

git cherry-pick f

Una vez ejecutado, el historial de Git se verá así:

a -b - c - d - f   Master
         \
           e - f - g Feature

La confirmación f se ha sido introducido con éxito en la rama de funcionalidad

Atención

Cherry-pick es una mala práctica porque significa que estamos reconstruyendo la historia, usa cherry-pick con sabiduría. Si no sabes lo que estás haciendo, mejor evita emplear este comando.

Aporte creado por: Carlos Eduardo Diaz.

Aportes 268

Preguntas 32

Ordenar por:

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

When sabes de Cherry-pick

But luego de enteras que es mala práctica

Cherry Pick

Este comando permite coger uno o varios commits de otra rama sin tener que hacer un merge completo. Así, gracias a cherry-pick, podríamos aplicar los commits relacionados con nuestra funcionalidad de Facebook en nuestra rama master sin necesidad de hacer un merge.

Para demostrar cómo utilizar git cherry-pick, supongamos que tenemos un repositorio con el siguiente estado de rama:

a - b - c - d   Master
         \
           e - f - g Feature

El uso de git cherry-pick es sencillo y se puede ejecutar de la siguiente manera:

git checkout master

En este ejemplo, commitSha es una referencia de confirmación. Puedes encontrar una referencia de confirmación utilizando el comando git log. En este caso, imaginemos que queremos utilizar la confirmación ‘f’ en la rama master. Para ello, primero debemos asegurarnos de que estamos trabajando con esa rama master.

git cherry-pick f

Una vez ejecutado, el historial de Git se verá así:

a - b - c - d - f   Master
         \
           e - f - g Feature

La confirmación f se ha sido introducido con éxito en la rama de funcionalidad

Apuntes !! ✌

Paré el video para hacer una prueba rápida en mi proyecto y estuve sufriendo por el conflicto que me dio. Justo terminé de arreglar todo, le doy play nuevamente al video y ¡PUM!, Freddy habla del conflicto, jaja.

LES ENSEÑAMOS GIT REBASE Y GIT CHERRY-PICK, PERO NO DEBERÍAN DE USARLOS PORQUE SON MALA PRÁCTICA

Freddy: usar git rebase y git cherry-pick son malas prácticas

El pibe en las oficinas de git que los programó:

Nunca nada se borra en Git.

¿Qué hacer sin en un comentario de un archivo de programación insulto a mi jefe?

¿Hay alguna forma de eliminar ese commit?

jaja nos ofreciste la manzana, para decirnos al final que estaba mal comerla 😂😂😂

Resumen de la clase:

  1. Crear una nueva rama y pasarse para esa rama.

  2. Realizar los cambios en el código y realizar todos los commits necesarios.

  3. Antes de ejecutar el comando git cherry-pick, se debe anotar el id del commit que queremos traer al master.

  4. Para ello vamos a la rama donde esta el commit requerido (git checkout nombre_rama), ejecutamos el comando git log --oneline,
    copiamos el id del commit y nos regresamos a la rama master (git
    checkout master).

  5. En la rama master, ejecutamos: git cherry-pick id_commit.

  6. Git agregará al master el código requerido del commit indicado.

  7. Después, de ser necesario, se ejecutan los comandos git pull
    origin master y git push origin master para subir los cambios al
    repositorio de github en la nube.

  8. Si se necesitan traer todos los cambios de la rama de donde tomé el commit, se ejecuta desde master, git merge nombre_rama.

  9. De haber conflictos al hacer merge, se resuelven dejando las líneas de código necesarias o utilizando las opciones de Vscode.

Cherry-pick es un poder demasiado grande pero de mala practica, hay que usarlo con demasiada responsabilidad, y aun así es una MALA PRACTICA.

cherry-pick literalmente se traduce del ingles como agarrar cerezas, entonces lo que esta haciendo uno es agarrar esas cerecitas que son los commits de las ramas de mi proyecto

Antes del git cherry-pick:

Después de ejecutar git cherry-pick commitF desde la rama master:

Aporte…
Si te equivocas y haces el git cherry-pick en el mismo branch que lo estas sacando te sale un error de versiones, puedes deshacer el cherry-pick con git cherry-pick --abort

Cherry-pick es el copia y pega de commits en otras ramas, alert-spoiler al momento de hacer un merge de la rama donde copiaste ese commit con la rama donde la pegaste, se duplicara ese cambio y tendrás que eliminar uno de ellos.

Tan feliz aprendiendo el cherry-pick y para que sea mala practica ):

Apuntes 😊

Queridos compañeros, encontré una manera para que sigan practicando de forma didáctica git sin miedo a romper nada, esta super bueno para poner en practica todo lo aprendido en el curso Profesional de Git y GitHub, espero les sirva Saludos Practica Git sin romper nada

✨ git cherry-pick nos permite seleccionar uno o varios commits de otra rama sin tener que hacer un merge completo.

# estando en master modifico readme.md
# guardo los cambios en memoria
$ git stash

# creo una rama con estos cambios
$ git stash branch readme-mejorado

# se crea la rama pero los cambios no se han guardad
$ git status
$ git commit -am "primer cambio"

# hago mas cambios
$ git commit -am "segundo cambio"
$ git commit -am "tercer cambio"

# Ahora me piden traer el primer commit de readme-mejorado
# copio el codigo del commit que quiero traer
$ git log --oneline

# cambio a master y hago el cherry-pick
$ git checkout master
$ git cherry-pick [codigo del commit]

# como lo que me estoy trayendo es un commit, no hay que hacer commit en master con los cambios, ya estan hechos
$ git status
$ git pull origin master
$ git push origin master

Me he sentido como Adán cuando le ofrecieron la manzana y después resulto ser pecado 😭

-Aunque recuerda que en git todo se puede recuperar, esa es la magia de Git.

yo: Disculpen, alguien sabe en qué rama puedo recuperar mi Disco Duro? 😦

Cherry-pick: Sirve para traerme un commit y todo lo guardado en ese commit de una rama diferente a donde se quiere agregar.

Git cherry-pick: Traer commits viejos al head de un branch
Cherry-pick sirve para cuando estás avanzando en una rama pero necesitas en Master uno de esos avances (commits) de la rama, cherry-pick es una mala práctica porque significa que estamos reconstruyendo la historia.

Para usar el cherry-pick se usa el siguiente comando: $ git cherry-pick <commit id> , este comando se debe ejecutar desde el lugar a donde quieres llevar los cambios (Master). Una vez ejecutado no es necesario hacer un commit, porque lo pega inmediatamente.

cherry-pick es una mala práctica porque significa que estamos reconstruyendo la historia,

al usar git stash branch… esto guardando la rama completa solo el cambio que realiza?

El siguiente ejemplo que encontré en el sitio web de Atlassian Bitbucket ilustra perfectamente el funcionamiento de cherry-pick:

Mis apuntes
git log --online -> muestra un resumen con el ID commit y comentario de la historia de las ramas con una linea.
git cherry-pick IDcommit -> trae los cambios hechos por el commit hecho posiblemente en otra rama a la deseada.

NOTA: es una mala practica, ya que es una reconstruccion de la historia, puede generar muchos conflictos si no se sabe utilizar.

en realidad no se trata de commit viejos… lo que hace el comando cherry-pick es traer a la rama master un commit especifico sin necesidad de mezclar o hacer un merge.

Tuve que volver a este curso solo para ver este comando. Algunos creen que no es util pero en mi caso si tuve que usarlo y me parece excelente. Yo habia creado una rama con un origen equivocado (debia haberla creado desde master y no lo hice). Y cuando me di cuenta ya habia avanzado mucho y lo que hice fue precisamente eso, hice un commit, me fui a master, cree la nueva rama desde mater y desde esa rama hice el cherry-pick.

Descargue el libro gratuito en la página de Git. Toda la documentación para ir más allá! Revísenlo...

La magia de git es saber corregir los errores que se puedan presentar, sólo se puede estar a la altura experimentando mucho con nuestros repos

Notas de las últimas sesiones

  • git --rebase branch: Agrega cambios de branch a la “historia” de mi rama actual = Pega (Ojo con posibles conflictos) los cambios de branch a la rama actual. El historial copiado aparecen ‘a nombre’ de la rama actual = Deja el registro como si rama actual partiera del último estado de branch .: Si rama actual partió del último HEAD de branch, no se modifica nada (Up to date).

  • git stash branch branchName stashHash: make a new branch with the given stash

  • git chery-pick hashCommit: útil para cuando ocupas pasar un commit de una rama a otra (commits local). Agrega el commit a la rama donde estas.

Puede que sea considerado una mala práctica pero es súmamente útil se puede usar para hacer arreglos urgentes, por ejemplo pasando temporalmente a una rama intermedia desde la rama de producción ya sea master o la que sea, esta será donde tienes los cambios que estas pasando sin que estén completos, pero funcionan para ese momento en específico y cuando termines en la otra rama, lo que haces ahí es fusionar en la rama de producción real, es como dejar de usar por un tiempo la rama de producción real para usar una temporal que funcione para ese momento, te da tiempo para cumplir con el requerimiento de algún cliente y aún así hacer el release completo a la rama de producción, luego volver a públicar la rama de producción real y no es traumático, la otra temporal se puede dejar ahí o borrarla, o sea si no se planea bien y se hace así como así si es mala práctica, muy mala, pero si se sabe como usar puede ser muy, muy útil.

Importante tener en cuenta y no lo veo en los temas que faltan Creo que ademas de usar git cherry-pick para traer lineas de codigo especificas, seria importante y ulti buscar el commit en el que fueron añadidas o modificadas a través del comando git blame

git cherry-pick <commitA>^…<commitB> -> Realiza el CherryPick incluyen el commitA y commitB
git cherry-pick <commitA>…<commitB> -> Realiza el CherryPick incluyendo solo el commitB
git commit -am "Comentario Cuando de Corrigen Conflictos"
git cherry-pick --continue -> Continuar al siguiente Commit.

Ya lo utilice y wow!
me produjo un conflicto que supe arreglas muy facilmente gracias a esa clse.
Me encanto!!!
Quiero seguir aprendiendo cosas nuevas 😃

Cherry-pick hace algo muy parecido a rebase pero con un commit no con toda una rama. Al modificar el historial se considera una mala practica.

Comprendido, entonces usare únicamente este comando para experimentación y no para las actividades comunes al trabajar en los repositorios. Gracias por la clase Platzi Team y Freddy.

Si queremos traer sólo uno de los cambio de una rama(new_branch) a la otra rama(master_branch), primero copiamos el hash del commit que queremos(new_branch) despues estando en (master_branch) ejecutamos: (git cherry-pich hash_branch)

Cherry-pick selecciona un commit donde se realizó un cambio en particular para agregarlo a la historia de nuestro proyecto, es como colocar un parche de una rama a otra.

Es molesto por el tipo de conflictos que se presentan ya que se está cambiando la historia. Acá andan el artículo oficial de git donde se habla del Cherry pick.


****¿Como traer un solo commit de otra rama? ****


git cherry-pick “commit”


****¿Como traer un solo commit de otra rama? ****


Git cherry-pick: traer commits viejos al head de un branch
Existe un mundo donde vamos avanzando en una rama pero necesitamos en master uno de esos avances de la rama para esto se usa un comando llamado cherry pick.

Para esto primero hacemos un git log --oneline y tomo el tag del commit que quiero traer (esto se hace en la rama donde esta ese commit), volvemos a master y desde master ejecutamos git cherry-pick #examplecommittag, damos ‘Enter’ y esto nos trae los cambios precisos de ese commit que estaba en otra rama a la rama master. (Esto es traerme un commit viejo de otra rama a mi rama master)

Si queremos fusionar los cambios hacemos un merge (parados en master la rama donde vamos a hacer la fusión hacemos git merge #examplebranch")

Cherry-pick es una mala practica porque significa que estamos reconstruyendo la historia, es mucho mejor hacer el trabajo duro haciéndolo con un merge.

Opino que nunca es mala practica el uso de esta o cualquier herramienta, siempre y cuando se sepa bien lo que se está haciendo y que esto aporte al desarrollo. Sin embargo usar estas herramientas sin conocerlas, sin haberlas probado y sin saber las consecuencias de el mal uso de estas si se puede considerar una mala práctica.

SI quieres abortar la opeación de cherry-pick utiliza:
- git cherry-pick --abort

esta cool ese comando 👍

La vida es un cherry-pick constante, úsalo con sabiduría.

Nuevamente, un comando útil para usar en local pero PELIGROSO para usar en producción…

por ej justo hoy en mi trabajo me encontre con un caso donde necesitabamos poder en el scope de pruebas 3 features diferentes (cada feature estaba en un commit), por lo que se me ocurrieron 2 soluciones:

  • la primera que pense fue en un cherry-pick donde en una rama nueva le meto los 3 commits de los 3 features con un cherry-pick
  • la segunda que al final fue por la que opte, fue en una rama nueva le hice git merge con cada una de las 3 ramas de los 3 features y listoi, ahi dejamos los 3 features listos para mandar a prod al mismo tiempo, sin alterar las branch originales con los PR independientes.

Notas 📒

✏️ Cherry pick

Cherry-pick permite escoger un commit de una rama para aplicarlo en otra.
Para ejecutarlo es necesario saber el HASH del commit que se quiere aplicar.

Comando

Trae un commit a la rama donde estás actualmente: git cherry-pick [HASH]

Trae un más de un commit a la rama donde estás actualmente: git cherry-pick [HASH] [HASH]

Estos dos comandos agregan directamente el commit a la rama, si se desea poder modificar el comentario del commit se ejecuta: git cherry-pick -e [HASH]

Si únicamente se desea traer los cambios y tenerlos en staging area se ejecuta: git cherry-pick -n [HASH]

Vaya plot twist

Este curso es de lo mas chimba que pude encontrar en platzi, y eso es decir mucho sabiendo que aca uno aprende cosas geniales

¿¡Usted está loco!? Hizo dos malas prácticas en una sola clase

“nunca nada se borra en git”

git reset: “i’m gonna end this man whole carrier”

"Recuerda que en git cualquier error se puede recuperar, porque nunca nada se borra en git, esa es la magia de git

Notes

  • git cherry-pick is a powerful command that enables arbitrary Git commits to be picked by reference and appended to the current working HEAD. Cherry-picking is the act of picking a commit from a branch and applying it to another. git cherry-pick can be useful for undoing changes. For example, say a commit is accidentally made to the wrong branch. You can switch to the correct branch and cherry-pick the commit to where it should belong.

    https://www.atlassian.com/git/tutorials/cherry-pick

Commands

  • Bring a specific commit from another branch to our current one

    git cherry-pick **commit**
    

Procedimiento:

  1. Cambios se guardan en otra rama alterna con git stash branch RamaAlterna o desde una nueva rama alterna creada
  2. desde nueva rama guardar varios cambios en repo local con git commit -am “message”
  3. Se requiere que en rama master se agregue un commit específico de la RamaAlterna con git cherry-pick IdCommit. Ya no es necesario hacer commits, pq se ha pegado el commit de la rama alterna en la rama master.
  4. Enviar repo local a remoto con git push origin master.
  5. Fusionar ambas ramas desde la rama master con git merge RamaAlterna. Aparece conflicto porque ambos commits (líneas de código) se repiten en ambas ramas.
  6. Accept both changes en VScode, porque ambos commits (líneas de código) son idénticos.
  7. Guardar cambios en repo local con git commit -am “message”
  8. Enviar cambios a repo remoto con git push origina master

Cherry-Pick

  • Trae commits especificos de otra rama
  • Para usar es con: git cherry-pick #id

Yo creo q Cherry-Pick solo puede ser autorizado por el encargado del proyecto inclusive tiene q ser evaluado por todo el team, porque de verdad puede romper el código si se usa mal

Lo más valioso de Platzi es como en todo momento evita formar profesionales con malas prácticas!

algo asi :v

algo así no olviden nunca parar de aprender ❤️

No me enseñen malas practicas que luego las aplico y me da ansiedad xd

Esto es ya es un nivel muy muy avanzado los que han llegado hasta aca tienen un poder grande en sus manos y claro una llave muy poderosa.

En el caso de que el jefe pida algo así tal vez es mejor crear otra rama en el commit que está lo que se quiere y hacer merge de esa?

De haber tomado esta clase unos dias antes jeje

  • git cherry-pick HASH_DE_LA_RAMA = traerse commit viejes a head de una rama ( Esto es una mala practica )

a pesar de ser una mala practica puede ser util en proyectos pqueños

Usa cherry-pick con sabiduría. Si no sabes lo que estás haciendo ten mucho cuidado 🙏

cherry-pick es una mala practica, tiene una gran funcionalidad, pero debemos limitarnos en su uso

git rebase & git cherry-pick, malas practicas que se deben usar solo en caso muy especificos

mala practica lo del cherry pick pero se puede encontrar varios casos de uso y entiendo que seria sabio solo usarlo en local en caso de ser necesario…

Me parece útil.

yo todo emocionado porque pensé que era de buen practica jajajajaja

Estoy en “master” resolviendo un hotfix… luego de ser desplegado y aprobado, necesito replicarlo a las branch de test y development … wujuuuuuuuuuuuu !!!

usar cherry-pick y listo

A seguir aprendiendo

Git Stash es como tener un avión.
Si lo sabes manejar, es una herramienta poderosa y muy útil.
Si no lo sabes usar bien, ni lo toques.

Yo todo desilusionado cuando se cierra cuadro y Freddy dice “cherry-pick es una mala practica”

Cherry pick en git

  • Qué es cherry pick en git

Cherry pick es una funcionalidad de Git que nos permite coger un commit de un branch y aplicarlo en otro branch.

Cuando hacemos cherry pick lo hacemos sobre un único commit, mientras que si hacemos merge o rebase ejecutaremos la acción sobre varios commits.

  • Cuando utilizar cherry pick en git

Antes de continuar debemos tener claro que la funcionalidad de cherry pick es muy útil en ciertos escenarios, pero en otros puede ser muy liosa, ya que puede generar commits duplicados lo que causará unos conflictos brutales.

soy el único que se sintió que este curso era del multiverso? mundos paralelos en los que haces cambios, puedes volver al pasado, arreglar algo que no sirve, unir los mundos y asi. creo que ya marvel y git me volaron la cabeza.

Me dejo frio el Cherry-Pick

Dato por si alguien peca con la misma inocencia, Freddy salva 3 commits distintos para cada línea en readme mejorado. Pero al aplicar el cherry se trae el commit de la primera (1 linea). Yo me traje el último commit pensando en traerme solo la última que yo añadi y PUM, me trajo las 3. Lo cancelé “git cherry-pick --skip”, probé con el segundo commit y me trajo la 1 y 2. Conclusión: Los commits son acumulativos, mantienen todos los cambios en los commits que le preceden, solo un dato por si asumen lo que yo pensé que iba a pasar y que lo práctiquen

JEJEJEJE EIGUAL HARE CHERRY-PICK 1500 veces

Esto podrá ser una mala práctica pero nos sirvió para una exigencia que tenia un cliente con urgencia, así que preserven ese comando en su arsenal de recursos de programación.

¡Apuntes!
Cherry-pick es un comando que permite agregar commits anitugos de una rama en otra rama.
Siendo así, este comando referencia algun commit previo, lo escoge y lo implementa directamente en otra rama.
Esta herramienta nos permite volver a cambios hechos anteriormiente, pero hay que usarla con cuidado puesto que es una re escritura del proceso de git.

/ clase 38 --> git cherry-pick /

git cherry-pick --> Trae un commit viejo de otra rama.
    [commitViejoOtraRama]

    Es una mala práctica.

cherry-pick algo nuevo que aprendo, pero un gran poder conlleva una gran responsabilidad. eso dijo el tio ben antes de morir

Cherry pick

“Un gran pder, conlleva una gran responsabilidad”

git cherry pick también se puede combinar con algunas opciones de ejecución.

-edit

Al combinar la opción -edit, Git solicitará un mensaje de confirmación antes de aplicar la operación cherry-pick.

--no-commit

La opción --no-commit ejecutará el comando cherry-pick, pero en lugar de hacer una nueva confirmación, moverá el contenido de la confirmación de destino al directorio de trabajo de la rama actual.

--signoff

La opción --signoff añadirá una línea de firma ‘signoff’ al final del mensaje de confirmación de cherry-pick.