Sync with upstream @ 34a80e70

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: iliakan

1-js/02-first-steps/04-variables/article.md

@@ -88,16 +88,26 @@ En scripts más viejos, a veces se encuentra otra palabra clave: `var` en lugar
 *!*var*/!* mensaje = 'Hola';
 ```
 
+<<<<<<< HEAD
 La palabra clave `var` es *casi* lo mismo que `let`. También hace la declaración de una variable, aunque de un modo ligeramente distinto, y más antiguo.
 
 Existen sutiles diferencias entre `let` y `var`, pero no nos interesan en este momento. Cubriremos el tema a detalle en el capítulo <info:var>.
+=======
+The `var` keyword is *almost* the same as `let`. It also declares a variable but in a slightly different, "old-school" way.
+
+There are subtle differences between `let` and `var`, but they do not matter to us yet. We'll cover them in detail in the chapter <info:var>.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 ````
 
 ## Una analogía de la vida real
 
 Podemos comprender fácilmente el concepto de una "variable" si nos la imaginamos como una "caja" con una etiqueta de nombre único pegada en ella.
 
+<<<<<<< HEAD
 Por ejemplo, podemos imaginar la variable `message` como una caja etiquetada `"message"` con el valor `"Hola!"` adentro:
+=======
+For instance, the variable `message` can be imagined as a box labelled `"message"` with the value `"Hello!"` in it:
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ![](variable.svg)
 
@@ -197,15 +207,24 @@ let my-name; // los guiones '-' no son permitidos en nombres
 Dos variables con nombres `manzana` y `MANZANA` son variables distintas.
 ```
 
+<<<<<<< HEAD
 ````smart header="Las letras que no son del alfabeto inglés están permitidas, pero no se recomiendan"
 Es posible utilizar letras de cualquier alfabeto, incluyendo letras del cirílico, logogramas chinos, etc.:
+=======
+````smart header="Non-Latin letters are allowed, but not recommended"
+It is possible to use any language, including Cyrillic letters, Chinese logograms and so on, like this:
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ```js
 let имя = '...';
 let 我 = '...';
 ```
 
+<<<<<<< HEAD
 Técnicamente, no existe ningún error aquí. Tales nombres están permitidos, pero existe una tradición internacional de utilizar inglés en el nombramiento de variables. Incluso si estamos escribiendo un script pequeño, este puede tener una larga vida por delante. Puede ser necesario que gente de otros países deba leerlo en algún momento.
+=======
+Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it sometime.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 ````
 
 ````warn header="Nombres reservados"
@@ -260,11 +279,19 @@ const myBirthday = '18.04.1982';
 myBirthday = '01.01.2001'; // ¡error, no se puede reasignar la constante!
 ```
 
+<<<<<<< HEAD
 Cuando un programador está seguro de que una variable nunca cambiará, puede declarar la variable con `const` para garantizar y comunicar claramente este hecho a todos.
+=======
+When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and communicate that fact to everyone.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ### Constantes mayúsculas
 
+<<<<<<< HEAD
 Existe una práctica utilizada ampliamente de utilizar constantes como aliases de valores difíciles-de-recordar y que se conocen previo a la ejecución.
+=======
+There is a widespread practice to use constants as aliases for difficult-to-remember values that are known before execution.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 Tales constantes se nombran utilizando letras mayúsculas y guiones bajos.
 
@@ -289,15 +316,23 @@ Ventajas:
 
 ¿Cuándo se deben utilizar letras mayúsculas para una constante, y cuando se debe nombrarla de manera normal? Dejémoslo claro.
 
+<<<<<<< HEAD
 Ser una "constante" solo significa que el valor de la variable nunca cambia. Pero hay constantes que son conocidas previo a la ejecución (como el valor hexadecimal del color rojo) y hay constantes que son *calculadas* en el tiempo de ejecución, pero no cambian después de su asignación inicial.
+=======
+Being a "constant" just means that a variable's value never changes. But some constants are known before execution (like a hexadecimal value for red) and some constants are *calculated* in run-time, during the execution, but do not change after their initial assignment.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 Por ejemplo:
 
 ```js
 const pageLoadTime = /* el tiempo que tardó la página web para cargar */;
 ```
 
+<<<<<<< HEAD
 El valor de `pageLoadTime` no se conoce antes de cargar la página, así que la nombramos normalmente. No obstante, es una constante porque no cambia después de su asignación inicial.
+=======
+The value of `pageLoadTime` is not known before the page load, so it's named normally. But it's still a constant because it doesn't change after the assignment.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 En otras palabras, las constantes con nombres en mayúscula son utilizadas solamente como alias para valores invariables y preestablecidos ("hard-coded").
 
@@ -307,18 +342,31 @@ Estando en el tema de las variables, existe una cosa de mucha importancia.
 
 Una variable debe tener un nombre claro, de significado evidente, que describa el dato que almacena.
 
+<<<<<<< HEAD
 Nombrar variables es una de las habilidades más importantes y complejas en la programación. Un vistazo rápido a el nombre de las variables nos revela cuál código fue escrito por un principiante o por un desarrollador experimentado.
 
 En un proyecto real, la mayor parte de el tiempo se pasa modificando y extendiendo una base de código en vez de empezar a escribir algo desde cero. Cuando regresamos a algún código después de hacer algo distinto por un rato, es mucho más fácil encontrar información que está bien etiquetada. O, en otras palabras, cuando las variables tienen nombres adecuados.
+=======
+Variable naming is one of the most important and complex skills in programming. A glance at variable names can reveal which code was written by a beginner versus an experienced developer.
+
+In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labelled. Or, in other words, when the variables have good names.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 Por favor pasa tiempo pensando en el nombre adecuado para una variable antes de declararla. Hacer esto te da un retorno muy sustancial.
 
 Algunas reglas buenas para seguir:
 
+<<<<<<< HEAD
 - Use términos legibles para humanos como `userName` p `shoppingCart`.
 - Evite abreviaciones o nombres cortos `a`, `b`, `c`, al menos que en serio sepa lo que está haciendo.
 - Cree nombres que describen al máximo lo que son y sean concisos. Ejemplos que no son adecuados son `data` y `value`. Estos nombres no nos dicen nada. Estos solo está bien usarlos en el contexto de un código que deje excepcionalmente obvio cuál valor o cuales datos está referenciando la variable.
 - Acuerda en tu propia mente y con tu equipo cuáles términos se utilizarán. Si a un visitante se le llamara "user", debemos llamar las variables relacionadas `currentUser` o `newUser` en vez de `currentVisitor` o `newManInTown`.
+=======
+- Use human-readable names like `userName` or `shoppingCart`.
+- Stay away from abbreviations or short names like `a`, `b`, and `c`, unless you know what you're doing.
+- Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
+- Agree on terms within your team and in your mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ¿Suena simple? De hecho lo es, pero no es tan fácil crear nombres de variables descriptivos y concisos a la hora de practicar. Inténtelo.
 

1-js/02-first-steps/05-types/article.md

@@ -92,7 +92,11 @@ Un valor `BigInt` se crea agregando `n` al final de un entero:
 const bigInt = 1234567890123456789012345678901234567890n;
 ```
 
+<<<<<<< HEAD
 Como los números `BigInt` rara vez se necesitan, no los cubrimos aquí sino que les dedicamos un capítulo separado <info: bigint>. Léelo cuando necesites números tan grandes.
+=======
+As `BigInt` numbers are rarely needed, we don't cover them here, but devoted them a separate chapter <info:bigint>. Read it when you need such big numbers.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ## String
 

1-js/03-code-quality/06-polyfills/article.md

@@ -7,7 +7,11 @@ Los equipos de desarrollo detrás de los intérpretes (engines) de JavaScript ti
 
 Por lo tanto, es bastante común para un intérprete implementar solo parte del estándar.
 
+<<<<<<< HEAD
 Una buena página para ver el estado actual de soporte de características del lenguaje es <https://kangax.github.io/compat-table/es6/> (es grande, todavía tenemos mucho que aprender).
+=======
+A good page to see the current state of support for language features is <https://compat-table.github.io/compat-table/es6/> (it's big, we have a lot to study yet).
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 Como programadores, queremos las características más recientes. Cuanto más, ¡mejor!
 
@@ -71,8 +75,13 @@ if (!Math.trunc) { // no existe tal función
 
 JavaScript es un lenguaje muy dinámico, los scripts pueden agregar o modificar cualquier función, incluso las integradas. 
 
+<<<<<<< HEAD
 Una librería interesante de polyfills es:
 - [core js](https://github.com/zloirock/core-js) - da muchísimo soporte, pero sin sobrecargar, ya que permite incluir solo las características necesarias.
+=======
+Two interesting polyfill libraries are:
+- [core js](https://github.com/zloirock/core-js) that supports a lot, allows to include only needed features.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ## Resumen
 
@@ -86,5 +95,13 @@ Buenos recursos que muestran el estado actual de soporte para varias caracterís
 - <https://kangax.github.io/compat-table/es6/> - para JavaScript puro.
 - <https://caniuse.com/> - para funciones relacionadas al navegador.
 
+<<<<<<< HEAD
 P.S. Google Chrome usualmente es el más actualizado con las características del lenguaje, pruébalo si algún demo del tutorial falla. Aunque la mayoría de los demos funciona con cualquier navegador moderno.
+=======
+Good resources that show the current state of support for various features:
+- <https://compat-table.github.io/compat-table/es6/> - for pure JavaScript.
+- <https://caniuse.com/> - for browser-related functions.
+
+P.S. Google Chrome is usually the most up-to-date with language features, try it if a tutorial demo fails. Most tutorial demos work with any modern browser though.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 

1-js/04-object-basics/04-object-methods/8-chain-calls/task.md

@@ -4,7 +4,11 @@ importance: 2
 
 # Encadenamiento
 
+<<<<<<< HEAD
 Hay un objeto `ladder` que permite subir y bajar:
+=======
+There's a `ladder` object that allows you to go up and down:
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ```js
 let ladder = {
@@ -21,7 +25,11 @@ let ladder = {
 };
 ```
 
+<<<<<<< HEAD
 Ahora, si necesitamos hacer varios llamados en secuencia podemos hacer algo como esto:
+=======
+Now, if we need to make several calls in sequence, we can do it like this:
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ```js
 ladder.up();
@@ -32,10 +40,18 @@ ladder.down();
 ladder.showStep(); // 0
 ```
 
+<<<<<<< HEAD
 Modifica el código de "arriba" `up`, "abajo" `down` y "mostrar peldaño" `showStep` para hacer los llamados encadenables como esto:
+=======
+Modify the code of `up`, `down`, and `showStep` to make the calls chainable, like this:
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 
 ```js
 ladder.up().up().down().showStep().down().showStep(); // shows 1 then 0
 ```
 
+<<<<<<< HEAD
 Tal enfoque es ampliamente usado entre las librerías JavaScript.
+=======
+Such an approach is widely used across JavaScript libraries.
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3

1-js/04-object-basics/09-object-toprimitive/article.md

@@ -253,7 +253,11 @@ let obj = {
   }
 };
 
+<<<<<<< HEAD
 alert(obj + 2); // 22 ("2" + 2), la conversión a valor primitivo devolvió un string => concatenación
+=======
+alert(obj + 2); // "22" ("2" + 2), conversion to primitive returned a string => concatenation
+>>>>>>> 34a80e70f8cce5794be259d25f815d7a7db7cbe3
 ```
 
 ## Resumen