mirror of
https://github.com/pcottle/learnGitBranching.git
synced 2025-08-28 05:54:34 +02:00
Se mejoran y añaden varios textos al idioma español de México
This commit is contained in:
Seth Karim Luis Martínez
parent
ecb97070eb
commit
5dc63e841a
13 changed files with 616 additions and 11 deletions
|
|
@ -13,6 +13,7 @@ exports.level = {
|
|||
"ja": "cherry-pick入門",
|
||||
"es_AR": "Introducción a cherry-pick",
|
||||
"es_ES": "Introducción a cherry-pick",
|
||||
"es_MX": "Introducción a cherry-pick",
|
||||
"pt_BR": "Introdução ao cherry-pick",
|
||||
"gl": "Introuducción a cherry-pick",
|
||||
"zh_CN": "Git Cherry-pick",
|
||||
|
|
@ -273,6 +274,63 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_MX": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Moviendo el trabajo por ahí",
|
||||
"",
|
||||
"Hasta ahora hemos cubierto lo básico de Git -- hacer confirmaciones, crear ramas y movernos por el árbol de confirmaciones. Estos conceptos alcanzan para aprovechar el 90% del poder de los repositorios de Git y cubrir las necesidades principales de los desarrolladores.",
|
||||
"",
|
||||
"El 10% restante, sin embargo, puede ser bastante útil en flujos de trabajo complejos (o cuando te metiste en algún problema complicado). El próximo concepto que vamos a cubrir es el de \"mover el trabajo por ahí\" -- en otras palabras, una forma que tienen los desarrolladores de decir \"Quiero este trabajo aquí y este otro allí\" de una manera precisa, elocuente y flexible.",
|
||||
"",
|
||||
"Puede parecer un montón, pero es un concepto bastante simple."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git Cherry-pick",
|
||||
"",
|
||||
"El primer comando en esta serie se llama `git cherry-pick`. Tiene la siguiente forma:",
|
||||
"",
|
||||
" `git cherry-pick <Commit1> <Commit2> <...>`",
|
||||
"",
|
||||
"Es una manera bastante directa de decir que quieres copiar una serie de commits sobre tu ubicación actual (`HEAD`). Personalmente amo `cherry-pick` porque hay muy poca magia involucrada y es bastante simple de entender.",
|
||||
"",
|
||||
"¡Veamos una demostración!",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Aquí tenemos un repositorio donde tenemos algo de trabajo en la rama `side` que queremos copiar a `main`. Podríamos lograrlo con un rebase (y ya aprendimos cómo), pero veamos cómo se comporta cherry-pick."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Eso es todo! Queríamos los commits `C2` y `C4` y Git los aplicó justo donde estábamos. ¡Tan simple como eso!"
|
||||
],
|
||||
"command": "git cherry-pick C2 C4",
|
||||
"beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout main; git commit;"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, simplemente copia algo de trabajo desde otras tres ramas a main. Puedes ver qué commits queremos en la visualización del objetivo.",
|
||||
""
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ exports.level = {
|
|||
"startTree": "{\"branches\":{\"main\":{\"target\":\"C2\",\"id\":\"main\"},\"bugFix\":{\"target\":\"C4\",\"id\":\"bugFix\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C1\"],\"id\":\"C3\"},\"C4\":{\"parents\":[\"C3\"],\"id\":\"C4\"}},\"HEAD\":{\"target\":\"bugFix\",\"id\":\"HEAD\"}}",
|
||||
"name": {
|
||||
"en_US": "Detach yo' HEAD",
|
||||
"es_MX": "Separa tu HEAD",
|
||||
"es_AR": "Desatacheá tu HEAD",
|
||||
"es_ES": "Desatachea tu HEAD",
|
||||
"pt_BR": "Solte a sua cabeça",
|
||||
|
|
@ -275,6 +276,84 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_MX": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Moviéndonos por ahí en Git",
|
||||
"",
|
||||
"Antes de meternos en algunas de las funcionalidades más avanzadas de Git, es importante entender las distintas maneras de moverse por el árbol de confirmaciones que representa tu proyecto.",
|
||||
"",
|
||||
"Una vez que estés cómodo moviendote por ahí, tus poderes con los otros comandos de git ¡van a amplificarse!",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
"",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## HEAD",
|
||||
"",
|
||||
"Primero tenemos que hablar de \"HEAD\". HEAD es el nombre simbólico del commit sobre el que hemos hecho checkout -- es, básicamente, el commit sobre el que estás trabajando.",
|
||||
"",
|
||||
"HEAD siempre apunta al commit más reciente, reflejado en el árbol de commits. La mayoría de los comandos de git que hacen cambios al árbol de commits empiezan modificando HEAD.",
|
||||
"",
|
||||
"Normalmente HEAD apunta al nombre de una rama (como bugFix). Cuando creas un commit, el estado de bugFix se altera y este cambio es visible a través de HEAD."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Veámoslo en acción. A continuación vamos a ver a HEAD antes y después de un commit."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Ves! HEAD estuvo oculta bajo nuestra rama `main` todo este tiempo."
|
||||
],
|
||||
"command": "git checkout C1; git checkout main; git commit; git checkout C2",
|
||||
"beforeCommand": ""
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"### Separando HEAD",
|
||||
"",
|
||||
"Separar HEAD simplemente significa adjuntarla a un commit en lugar de a un branch. Así es como se ve de antemano:",
|
||||
"",
|
||||
"HEAD -> main -> C1",
|
||||
""
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Y así queda ahora:",
|
||||
"",
|
||||
"HEAD -> C1"
|
||||
],
|
||||
"command": "git checkout C1",
|
||||
"beforeCommand": ""
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, separemos HEAD de `bugFix` y juntémoslo en su lugar al commit.",
|
||||
"",
|
||||
"Especifica este commit por su hash. El hash de cada commit se muestra en el círculo que lo representa."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ exports.level = {
|
|||
"en_US": "you can use either branches or relative refs (HEAD~) to specify the rebase target",
|
||||
"es_AR": "podés usar tanto ramas como referencias relativas (HEAD~) para especificar el objetivo del rebase",
|
||||
"es_ES": "puedes usar tanto ramas como referencias relativas (HEAD~) para especificar el objetivo del rebase",
|
||||
"es_MX": "puedes usar tanto ramas como referencias relativas (HEAD~) para especificar el objetivo del rebase",
|
||||
"pt_BR": "Você pode usar ou ramos ou referências relativas (HEAD~) para especificar o alvo do rebase",
|
||||
"gl": "Podes usar ramas ou referencias relativas (HEAD~) para especificar o obxectivo do rebase",
|
||||
"de_DE": "Du kannst entweder Branches oder relative Ref-Angaben (z.B. HEAD~) benutzen, um das Ziel des Rebase anzugeben.",
|
||||
|
|
@ -30,6 +31,7 @@ exports.level = {
|
|||
"en_US": "Interactive Rebase Intro",
|
||||
"es_AR": "Introducción al rebase interactivo",
|
||||
"es_ES": "Introducción al rebase interactivo",
|
||||
"es_MX": "Introducción al rebase interactivo",
|
||||
"pt_BR": "Introdução ao rebase interativo",
|
||||
"gl": "Introducción ó rebase interativo",
|
||||
"de_DE": "Einführung Interaktives Rebase",
|
||||
|
|
@ -439,6 +441,72 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_MX": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Git rebase interactivo",
|
||||
"",
|
||||
"git cherry-pick es genial cuando sabes qué commits quieres (_y_ sabes sus hashes) -- es dificil superar la simpleza que provee.",
|
||||
"",
|
||||
"Pero ¿qué pasa cuando no sabes qué commits quieres? Por suerte ¡Git te cubre en esta situación también! Podemos usar el rebase interactivo para esto -- es la mejor manera de revisar una serie de commits que estás a punto de rebasear.",
|
||||
"",
|
||||
"Entremos en los detalles..."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Todo rebase interactivo significa usar el comando `rebase` con la opción `-i`.",
|
||||
"",
|
||||
"Si incluyes esta opción, git abrirá una UI para mostrarte qué commits están a punto de ser copiados sobre el objetivo del rebase. También muestra sus hashes y mensajes, que ayuda mucho para saber qué es cada commit.",
|
||||
"",
|
||||
"Para el git \"de verdad\", la UI signfica abrir un archivo en un editor de textos como `vim`. Para nuestro propósito, hice una pequeña interfaz que se comporta de ese mismo modo."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Cuando el diálogo de rebase interactivo se abre, tienes la capacidad de hacer 2 cosas:",
|
||||
"",
|
||||
"* Puedes reordenar las confirmaciones con solamente cambiar su orden en la UI (en nuestra ventana, eso significa arrastrar y soltar con el mouse).",
|
||||
"* Puedes elegir mantener todas las confirmciones o ignorar algunas específicas. Cuando la ventana se abre, cada confirmación se asigna como incluido por medio del botón `pick` que está activo al lado. Para ignorar una confirmación, desactiva el botón `pick`.",
|
||||
"",
|
||||
"Vale la pena mencionar que en el rebase interactivo puedes hacer muchas más cosas como combinar confirmaciones, modificar los mensajes d elas confirmaciones e incluso editar las confirmaciones. Para nuestros propósitos nos centraremos en las dos operaciones anteriores.",
|
||||
"",
|
||||
"¡Genial! Veamos un ejemplo."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Cuando presiones el botón, va a aparecer una ventana de rebase interactivo. Reordena los commits (siéntete libre de ignorar alguno, también) ¡y observa el resultado!"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Vientos! Git copió las cofirmaciones exactamente de la misma manera que lo especificaste en la UI."
|
||||
],
|
||||
"command": "git rebase -i HEAD~4 --aboveAll",
|
||||
"beforeCommand": "git commit; git commit; git commit; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar el nivel, haz un rebase interactivo y alcanza el orden que se muestra en la visualización objetivo. Recuerda que siempre puedes hacer `undo` y `reset` para arreglar errores :D"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ exports.level = {
|
|||
"zh_CN": "相对引用（^）",
|
||||
"zh_TW": "相對引用（^）",
|
||||
"es_AR": "Referencias relativas (^)",
|
||||
"es_MX": "Referencias relativas (^)",
|
||||
"es_ES": "Referencias relativas (^)",
|
||||
"pt_BR": "Referências relativas (^)",
|
||||
"gl": "Referencias relativas (^)",
|
||||
|
|
@ -416,6 +417,81 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_MX": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Referencias relativas",
|
||||
"",
|
||||
"Moverse por ahí en Git usando los hashes de los commits puede volverse un tanto tedioso. En el mundo real no vas a tener una visualización de commits tan linda en la terminal, así que vas a tener que usar `git log` para ver los hashes.",
|
||||
"",
|
||||
"Peor aún, los hashes en general son mucho más largos en el git real, también. Por ejemplo, el hash del commit que introduje en el nivel anterior es `fed2da64c0efc5293610bdd892f82a58e8cbc5d8`. No es algo particularmente fácil de nombrar...",
|
||||
"",
|
||||
"Lo interesante es que Git es bastante astuto con los hashes. Sólo requiere que especifiques una cantidad de caracteres suficientes para identificar unívocamente al commit. Entonces, yo podría simplemente tipear `fed2` en lugar de esa larga cadena de arriba."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Como ya dije, especificar los commits por su hash no es la manera más conveniente y por eso Git tiene referencias relativas. ¡Son geniales!",
|
||||
"",
|
||||
"Con las referencias relativas puedes arrancar de algún lugar memoralbe (como la rama `bugFix`, o `HEAD`) y trabajar desde ahí.",
|
||||
"",
|
||||
"Los commits relativos son poderosos, pero ahora vamos a presentar sólo dos formas simples:",
|
||||
"",
|
||||
"* Moverse un commit hacia atrás con `^`",
|
||||
"* Moverse una cantidad de commits hacia atrás con `~<num>`"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Veamos el operador ^ primero. Cada vez que le agregas eso al nombre de una referencia, le estás diciendo a git que use el padre del commit especificado.",
|
||||
"",
|
||||
"Entonces, `main^` quiere decir que es equivalente a \"el primer padre de `main`\".",
|
||||
"",
|
||||
"`main^^` es el _abuelo_ (segunda generación de ancestros) de `main`",
|
||||
"",
|
||||
"Veamos el commit que está antes de main aquí."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Vientos! Ahí está. Mucho más simple que escribir el hash de ese commit."
|
||||
],
|
||||
"command": "git checkout main^",
|
||||
"beforeCommand": "git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"También puedes referenciar a `HEAD` como una referencia relativa. Usémoslo un par de veces para movernos hacia atrás en nuestro árbol."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Fácil! Podemos volver en el tiempo con `HEAD^`"
|
||||
],
|
||||
"command": "git checkout C3; git checkout HEAD^; git checkout HEAD^; git checkout HEAD^",
|
||||
"beforeCommand": "git commit; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, haz checkout sobre el padre del commit de `bugFix`. Esto va a detachear a `HEAD`.",
|
||||
"",
|
||||
"Puedes especificar el hash si quieres, pero mejor ¡trata de usar la referencia relativa!"
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ exports.level = {
|
|||
"ja": "相対リファレンス その２ (~)",
|
||||
"es_AR": "Referencias relativas #2 (~)",
|
||||
"es_ES": "Referencias relativas #2 (~)",
|
||||
"es_MX": "Referencias relativas #2 (~)",
|
||||
"pt_BR": "Referências relativas #2 (~)",
|
||||
"gl": "Referencias relativas #2 (~)",
|
||||
"fr_FR": "Références relatives #2 (~)",
|
||||
|
|
@ -249,6 +250,75 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_MX": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### El operador \"~\"",
|
||||
"",
|
||||
"Digamos que quieres moverte un montón de niveles atrás en tu árbol de commits. Podría ser tedioso escribir `^` muchas veces y por eso Git tiene el operador ~.",
|
||||
"",
|
||||
"",
|
||||
"El operador ~ (opcionalmente) toma la cantidad especificada de padres que quieres volver hacia atrás. Veámoslo en acción"
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Especifiquemos una cantidad de confirmaciones hacia atrás con `~`."
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Vientos! Genial -- las referencias relativas son lo mejor."
|
||||
],
|
||||
"command": "git checkout HEAD~4",
|
||||
"beforeCommand": "git commit; git commit; git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"### Forzando las ramas",
|
||||
"",
|
||||
"Ahora que eres un experto en las referencias relativas, *usémoslas* para algo.",
|
||||
"",
|
||||
"Una de las formas más comunes en que uso las referencias relativas es para mover las ramas. Puedes reasignar directamente una rama a un commit usando la opción `-f`. Algo así como:",
|
||||
"",
|
||||
"`git branch -f main HEAD~3`",
|
||||
"",
|
||||
"Mueve (forzadamente) la rama main tres padres por detrás de HEAD."
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"Veamos ese comando previo en acción"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Allá vamos! Las referencias relativas nos proporcionaron una manera breve de referenciar a `C1` y forzar la rama (`-f`) nos dio una manera rápida de mover la rama a esa ubicación"
|
||||
],
|
||||
"command": "git branch -f main HEAD~3",
|
||||
"beforeCommand": "git commit; git commit; git commit; git checkout -b bugFix"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Ahora que viste las referencias relativas y el forzar ramas combinados, usémoslos para resolver el siguiente nivel.",
|
||||
"",
|
||||
"Para completar este nivel, mueve `HEAD`, `main` y `bugFix` a sus destinos finales."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ exports.level = {
|
|||
"fr_FR": "Annuler des changements avec Git",
|
||||
"es_AR": "Revirtiendo cambios en git",
|
||||
"es_ES": "Revirtiendo cambios en git",
|
||||
"es_MX": "Revirtiendo cambios en Git",
|
||||
"pt_BR": "Revertendo mudanças no Git",
|
||||
"gl": "Revertindo cambios en git",
|
||||
"ko": "Git에서 작업 되돌리기",
|
||||
|
|
@ -27,6 +28,7 @@ exports.level = {
|
|||
"de_DE": "Beachte, dass revert und reset unterschiedliche Argumente benötigen",
|
||||
"fr_FR": "Notez que `revert` et `reset` n'ont pas les mêmes arguments.",
|
||||
"es_AR": "Notá que revert y reset toman parámetros distintos",
|
||||
"es_MX": "Observa que revert y reset utilizan parámetros distintos",
|
||||
"es_ES": "Observa que revert y reset utilizan parámetros distintos",
|
||||
"pt_BR": "Lembre que revert e reset recebem parâmetros diferentes",
|
||||
"gl": "Lembra que revert e reset usan parámetros distintos",
|
||||
|
|
@ -231,6 +233,69 @@ exports.level = {
|
|||
}
|
||||
]
|
||||
},
|
||||
"es_MX": {
|
||||
"childViews": [
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"## Revirtiendo cambios en Git",
|
||||
"",
|
||||
"Hay varias maneras de revertir cambios en Git. Y tal como al confirmar, revertir cambios en Git tiene tanto un componente de bajo nivel (indexar archivos o fragmentos individualmente) como un componente de alto nivel (cómo son efectivamente revertidos los cambios). Nuestra aplicación se va a concentrar en esto último.",
|
||||
"",
|
||||
"Hay dos formas principales de deshacer cambios en Git -- uno es usando `git reset` y el otro es usando `git revert`. Vamos a ver cada uno de ellos a continuación",
|
||||
""
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"## Git Reset",
|
||||
"",
|
||||
"`git reset` deshace los cambios moviendo la referencia de una rama hacia atrás en el tiempo a un commit anterior. En este sentido puedes imaginarlo como \"reescribir la historia\". `git reset` va a mover la rama hacia atrás, como si el commit nunca se hubiera hecho.",
|
||||
"",
|
||||
"Veamos cómo se ve eso:"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"¡Genial! git simplemente movió la referencia de la rama main atrás hacia `C1`. Ahora tu repositorio local está en un estado como si `C2` nunca hubiera ocurrido."
|
||||
],
|
||||
"command": "git reset HEAD~1",
|
||||
"beforeCommand": "git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "GitDemonstrationView",
|
||||
"options": {
|
||||
"beforeMarkdowns": [
|
||||
"## Git Revert",
|
||||
"",
|
||||
"Mientras que reiniciar (reset) los cambios funciona estupendamente para ramas locales en tu máquina, su método de \"reescribir la historia\" no funciona para ramas remotas que otros están usando.",
|
||||
"",
|
||||
"Para revertir cambios y *compartir* esa _revertida_ con otros, necesitamos usar `git revert`. Veámoslo en acción"
|
||||
],
|
||||
"afterMarkdowns": [
|
||||
"Extraño. Hay un nuevo commit aplicado sobre el que queríamos revertir. Eso es porque este nuevo commit `C2'` introduce *cambios* - sólo que esos cambios son exactamente los necesarios para revertir los que introdujo `C2`.",
|
||||
"",
|
||||
"Cuando utilices revert, puedes hacer push sobre ese cambio para compartirlo con otros."
|
||||
],
|
||||
"command": "git revert HEAD",
|
||||
"beforeCommand": "git commit"
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "ModalAlert",
|
||||
"options": {
|
||||
"markdowns": [
|
||||
"Para completar este nivel, revierte el commit más reciente, tanto en `local` como en `pushed`.",
|
||||
"",
|
||||
"Ten en cuenta que `pushed` es una rama remota y `local` es una rama local -- eso debería ayudarte a elegir qué métodos usar."
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
"pt_BR": {
|
||||
"childViews": [
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue