Merge branch 'master' into master

Author: vplentinax

1-js/02-first-steps/18-javascript-specials/article.md

@@ -22,7 +22,6 @@ Eso se llama "inserción automática de punto y coma". A veces no funciona, por
 ```js run
 alert("Habrá un error después de este mensaje.")
 
-
 [1, 2].forEach(alert)
 ```
 
@@ -50,7 +49,6 @@ Para habilitar completamente todas las características de JavaScript moderno, d
 
 ```js
 'use strict';
-
 ...
 ```
 
@@ -70,7 +68,6 @@ Se pueden declarar usando:
 - `const` (constante, no se puede cambiar)
 - `var` (estilo antiguo, lo veremos más tarde)
 
-
 Un nombre de variable puede incluir:
 - Letras y dígitos, pero el primer carácter puede no ser un dígito.
 - Los caracteres `$` y `_` son normales, al igual que las letras.
@@ -151,9 +148,11 @@ Ternarios
 : El único operador con 3 parametros: `cond ? resultA : resultB`. Sí `cond` es verdadera, devuelve `resultA`, de lo contrario `resultB`.
 
 Operadores Lógicos
+
 : Los operadores lógicos Y `&&` y Ó `||` realizan una evaluación de circuito corto y luego devuelven el valor donde se detuvo. El operador lógico NOT `!` convierte el operando a tipo booleano y devuelve el valor inverso.
 
 Comparaciones
+
 : Revision de igualdad `==` para valores de diferentes tipos los convierte en un número (excepto `null` y `undefined` que son iguales entre sí y nada más), por lo que son iguales:
 
     ```js run
@@ -196,6 +195,7 @@ Más en: <info:operators>, <info:comparison>, <info:logical-operators>.
     ```
 
 - La variable declarada en el bucle `for(let...)` sólo es visible dentro del bucle. Pero también podemos omitir el `let` y reutilizar una variable existente.
+
 - Directivas `break/continue` permiten salir de todo el ciclo/iteración actual. Use etiquetas para romper bucles anidados.
 
 Detalles en: <info:while-for>.
@@ -213,8 +213,9 @@ let age = prompt('¿Su Edad?', 18);
 
 switch (age) {
   case 18:
-    alert("No funciona"); // el resultado de la petición es un string, no un número
 
+    alert("No funciona"); // el resultado de la petición es un string, no un número
+    
   case "18":
     alert("¡Funciona!");
     break;

1-js/05-data-types/07-map-set/01-array-unique-map/task.md

@@ -2,17 +2,17 @@ importance: 5
 
 ---
 
-# Filter unique array members
+# Filtrar miembros únicos del array
 
-Let `arr` be an array.
+Permita que `arr` sea un array.
 
-Create a function `unique(arr)` that should return an array with unique items of `arr`.
+Cree una función `unique(arr)` que debería devolver un array con elementos únicos de `arr`.
 
-For instance:
+Por ejemplo:
 
 ```js
 function unique(arr) {
-  /* your code */
+  /* tu código */
 }
 
 let values = ["Hare", "Krishna", "Hare", "Krishna",
@@ -21,7 +21,7 @@ let values = ["Hare", "Krishna", "Hare", "Krishna",
 
 alert( unique(values) ); // Hare, Krishna, :-O
 ```
+P.D. Aquí se usan strings, pero pueden ser valores de cualquier tipo.
 
-P.S. Here strings are used, but can be values of any type.
+P.D.S. Use `Set` para almacenar valores únicos.
 
-P.P.S. Use `Set` to store unique values.

1-js/05-data-types/07-map-set/02-filter-anagrams/solution.md

@@ -1,6 +1,7 @@
-To find all anagrams, let's split every word to letters and sort them. When letter-sorted, all anagrams are same.
 
-For instance:
+Para encontrar todos los anagramas, dividamos cada palabra en letras y las ordenamos. Cuando se clasifican las letras, todos los anagramas son iguales.
+
+Por ejemplo:
 
 ```
 nap, pan -> anp
@@ -9,55 +10,54 @@ cheaters, hectares, teachers -> aceehrst
 ...
 ```
 
-We'll use the letter-sorted variants as map keys to store only one value per each key:
+Utilizaremos las variantes ordenadas por letras como propiedades de Map para almacenar solo un valor por cada propiedad:
 
 ```js run
 function aclean(arr) {
   let map = new Map();
 
   for (let word of arr) {
-    // split the word by letters, sort them and join back
+    // dividir la palabra por letras, ordenarlas y volver a unir
 *!*
     let sorted = word.toLowerCase().split('').sort().join(''); // (*)
 */!*
     map.set(sorted, word);
   }
-
   return Array.from(map.values());
 }
 
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
 alert( aclean(arr) );
 ```
+La clasificación de letras se realiza mediante la cadena de llamadas en la línea `(*)`.
 
-Letter-sorting is done by the chain of calls in the line `(*)`.
-
-For convenience let's split it into multiple lines:
+Por conveniencia la dividimos en múltiples líneas:
 
 ```js
-let sorted = word // PAN
+let sorted = arr[i] // PAN
   .toLowerCase() // pan
   .split('') // ['p','a','n']
   .sort() // ['a','n','p']
   .join(''); // anp
 ```
+Dos palabras diferentes`'PAN'` y `'nap'` reciben la misma forma ordenada por letras `'anp'`.
 
-Two different words `'PAN'` and `'nap'` receive the same letter-sorted form `'anp'`.
+La siguiente línea pone la palabra en el Map:
 
-The next line put the word into the map:
 
 ```js
 map.set(sorted, word);
 ```
 
-If we ever meet a word the same letter-sorted form again, then it would overwrite the previous value with the same key in the map. So we'll always have at maximum one word per letter-form.
+Si alguna vez volvemos a encontrar una palabra con la misma forma ordenada por letras, sobrescribiría el valor anterior con la misma propiedad en Map. Por lo tanto, siempre tendremos como máximo una palabra ordenada por letras.
+
+Al final, `Array.from (map.values())` toma un valor iterativo sobre los valores de Map (no necesitamos propiedades en el resultado) y devuelve un array de ellos.
 
-At the end `Array.from(map.values())` takes an iterable over map values (we don't need keys in the result) and returns an array of them.
+Aquí también podríamos usar un objeto plano en lugar del `Map`, porque las propiedades son strings.
 
-Here we could also use a plain object instead of the `Map`, because keys are strings.
+Así es como puede verse la solución:
 
-That's how the solution can look:
 
 ```js run demo
 function aclean(arr) {

1-js/05-data-types/07-map-set/02-filter-anagrams/task.md

@@ -2,27 +2,27 @@ importance: 4
 
 ---
 
-# Filter anagrams
+# Filtrar anagramas
 
-[Anagrams](https://en.wikipedia.org/wiki/Anagram) are words that have the same number of same letters, but in different order.
+[Anagramas](https://es.wikipedia.org/wiki/Anagrama) son palabras que tienen el mismo número de letras, pero en diferente orden.
 
-For instance:
+Por ejemplo:
 
 ```
 nap - pan
 ear - are - era
 cheaters - hectares - teachers
 ```
 
-Write a function `aclean(arr)` that returns an array cleaned from anagrams.
+Escriba una función `aclean(arr)` que devuelva un array limpio de anagramas.
+
+Por ejemplo:
 
-For instance:
 
 ```js
 let arr = ["nap", "teachers", "cheaters", "PAN", "ear", "era", "hectares"];
 
-alert( aclean(arr) ); // "nap,teachers,ear" or "PAN,cheaters,era"
+alert( aclean(arr) ); // "nap,teachers,ear" o "PAN,cheaters,era"
 ```
-
-From every anagram group should remain only one word, no matter which one.
+Es decir, de cada grupo de anagramas debe quedar solo una palabra, sin importar cual.
 

1-js/05-data-types/07-map-set/03-iterable-keys/solution.md

@@ -1,8 +1,7 @@
 
-That's because `map.keys()` returns an iterable, but not an array.
-
-We can convert it into an array using `Array.from`:
+Eso es porque `map.keys()` devuelve un iterable, pero no un array.
 
+Podemos convertirlo en un array usando `Array.from`:
 
 ```js run
 let map = new Map();

1-js/05-data-types/07-map-set/03-iterable-keys/task.md

@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Iterable keys
+# Propiedades iterables
 
-We'd like to get an array of `map.keys()` in a variable and then do apply array-specific methods to it, e.g. `.push`.
+Nos gustaría obtener un array de `map.keys()` en una variable y luego aplicarle métodos específicos de array, ej. .push.
 
-But that doesn't work:
+Pero eso no funciona:
 
 ```js run
 let map = new Map();
@@ -16,9 +16,10 @@ map.set("name", "John");
 let keys = map.keys();
 
 *!*
-// Error: keys.push is not a function
+// Error: keys.push no es una función
 keys.push("more");
 */!*
 ```
 
-Why? How can we fix the code to make `keys.push` work?
+¿Por qué? ¿Cómo podemos arreglar el código para que funcione `keys.push`?
+