[ADD] Challenge #79boolean.md 👍🏻

data/74-json-stringify.md

@@ -0,0 +1,31 @@
+---
+title: 'Explica este código JavaScript'
+createdAt: '2022-06-12T15:40:45.757Z'
+answers: ['true, false', 'false, false', 'false, true', 'true, true']
+response: 0
+explanation: '<code>JSON.stringify</code> convierte a los arreglos en cadenas.
+Para los arreglos <code>a</code> y <code>b</code> tendríamos:
+<br/> <br/>
+<code>
+    console.log("[1, 2, 3]" === "[1, 2, 3]"); //true
+</code>
+<br/> <br/>
+Para los arreglos <code>a</code> y <code>c</code> tendríamos:
+<br/> <br/>
+<code>
+    console.log("[1, 2, 3]" === "[1, 2, "3"]"); //false
+</code>
+Son simples comparaciones de primitivos, en este caso de cadenas.
+Usar <code>JSON.stringify</code> es muy común cuando se quiere verificar si 2 arreglos son iguales o no.'
+author: 'cristian-fernando-villca-gutie'
+course: 'Curso de ECMAScript 6+'
+reference: 'https://platzi.com/cursos/ecmascript-6/'
+level: 'intermediate'
+---
+```javascript
+const a = [1, 2, 3];
+const b = [1, 2, 3];
+const c = [1, 2, "3"];
+console.log(JSON.stringify(a) === JSON.stringify(b)); //? 🤔
+console.log(JSON.stringify(a) === JSON.stringify(c)); //? 🤔
+```

data/75-array-string.md

@@ -0,0 +1,31 @@
+---
+title: 'Explica este código JavaScript'
+createdAt: '2022-06-12T16:38:30.698Z'
+answers: [
+    '[1, 2, 3, 4, 5, 6]', 
+    '[1, 2, 3, [4, 5, 6]]', 
+    '"1, 2, 3, 4, 5, 6"', 
+    '"1, 2, 34, 5, 6"']
+response: 3
+explanation: 'Los operadores de javascript, como por ejemplo el operador suma <code>(+)</code>, están diseñados para tipos de datos primitivos, especialmente para cadenas de caracteres y números.
+<br /> <br />
+Cuando intentamos usar dichos operadores para tipos no primitivos, javascript hará su mayor esfuerzo para devolver un resultado lógico, pero la mayoría de las veces obtendremos salidas no esperadas o ambiguas.
+<br /> <br />
+Lo primero que tratará de hacer el interprete de javascript es tratar de convertir los arreglos a cadenas, aunque no lo veamos hará algo como esto:
+<code>
+    const a = [1, 2, 3];<br/>
+    let b = [4, 5, 6];<br/>
+    console.log(a.toString() + b.toString()); //"1, 2, 3" + "4, 5, 6"
+</code>
+<br /> <br/>
+La operación de "suma de arreglos" al final se convierte en una concatenación de cadenas. Esto explica el loco resultado que nos muestra por consola.'
+author: 'cristian-fernando-villca-gutie'
+course: 'Curso de ECMAScript 6+'
+reference: 'https://platzi.com/cursos/ecmascript-6/'
+level: 'intermediate'
+---
+```javascript
+const a = [1, 2, 3];
+let b = [4, 5, 6];
+console.log(a + b); //?
+```

data/76-object-is.md

@@ -0,0 +1,24 @@
+---
+title: 'Explica este código JavaScript'
+createdAt: '2022-06-12T16:58:22.727Z'
+answers: ['true, false', 'false, true', 'true, NaN', 'true, undefiend']
+response: 1
+explanation: 'El operador de igualdad estricta es muy potente, pero ¿sabias que existe uno aún mejor?
+<br /> <br />
+<code>Object.is</code> recibe 2 parámetros y hace una comparación profunda entre ellos, pero va un poco más lejos.
+<br /> <br />
+Casos como: <code>0 === -0</code> y <code>NaN === NaN</code> son mejor manejados con <code>Object.is</code>.
+<br /> <br />
+Cuando comparamos un <code>NaN</code> vs otro <code>NaN</code> usando <code>===</code> obtenemos siempre false lo que no tiene mucho sentido, en estos casos es mejor usar <code>Object.is</code>.'
+author: 'cristian-fernando-villca-gutie'
+course: 'Curso de ECMAScript 6+'
+reference: 'https://platzi.com/cursos/ecmascript-6/'
+level: 'intermediate'
+---
+```javascript
+const a = NaN;
+const b = 5/"Hola";
+
+console.log( a === b ); // 🤔?
+console.log(Object.is(a, b)); //🤔?
+```

data/77-undefined.md

@@ -0,0 +1,49 @@
+---
+title: 'Explica este código JavaScript'
+createdAt: '2022-06-12T17:15:05.933Z'
+answers: [
+    'Solo el ejemplo #1', 
+    'Ejemplo #2 y Ejemplo #3', 
+    'Ejemplo #3 y Ejemplo #4', 
+    'Todos los ejemplos']
+response: 3
+explanation: 'En javascript existen 4 maneras de obtener un <code>undefined</code> como resultado:
+<br /> <br/>
+Cuando declaramos una variable con <code>let</code> o <code>var</code> sin inicializarla, como en el ejemplo #1.
+<br /> <br/>
+Cuando en la llamada de una función omitimos parámetros obligatorios, como en el ejemplo #2.
+<br /> <br/>
+Cuando intenamos acceder a una propiedad de un objeto que no existe, como en el ejemplo #3.
+<br /> <br/>
+Cuando llamamos a una función que no tiene la sentencia <code>return</code> en su cuerpo, como en el ejemplo #4.'
+author: 'cristian-fernando-villca-gutie'
+course: 'Curso de ECMAScript 6+'
+reference: 'https://platzi.com/cursos/ecmascript-6/'
+level: 'intermediate'
+---
+```javascript
+//#1
+let a;
+console.log(a);
+
+//#2
+function f(x) {
+  return x;
+}
+console.log(f());
+
+//#3
+const obj= {
+  nombre:"Cris",
+}
+console.log(obj.edad);
+
+//#4
+function y(){
+  let z =3;
+  if(true){
+    z=4;
+  }
+}
+console.log(y())
+```

data/78-function.md

@@ -0,0 +1,57 @@
+---
+title: 'Explica este código JavaScript'
+createdAt: '2022-06-12T17:39:05.756Z'
+answers: [
+    '4, "2true", 2', 
+    '4, 3, Error: falta de parametros', 
+    '"22", "3true", "20"', 
+    '4, 3, 2'
+    ]
+response: 1 
+explanation: '<strong>Primer caso</strong>:
+Simple suma de números enteros.
+<br /> <br />
+<strong>Segundo caso</strong>:
+Por inferencia de tipos, el parámetro <code>true</code> se convierte en <code>1</code>, por ello el resultado es <code>3</code>.
+<br /> <br />
+<strong>Tercer caso</strong>:
+En el <code>if</code> usamos el operador de negación para la validación de parámetros, esto hace que los valores falsy también se vean afectados y nos arroje la excepción. Para arreglar esto podríamos hacer lo siguiente:
+<br /> <br />
+<code>
+    const sumar = (a,b) => {<br />
+    if(a === undefined || b === undefined){<br />
+        throw new Error("faltan parametros");<br />
+    }<br />
+    return a + b;<br />
+    }
+</code>
+<br /> <br />
+O una solucuón un poco más elegante:
+<br /> <br />
+<code>
+    const sumar = (a, b) => {<br />
+    if ([a,b].includes(undefined)) {<br />
+        throw new Error("faltan parametros");<br />
+    }<br />
+    return a + b;<br />
+    }
+</code>
+<br /> <br />
+De esa manera no solo cuando alguno de los parámetros no este definido en la llamada de la función se lanza la excepción.'
+author: 'cristian-fernando-villca-gutie'
+course: 'Curso de ECMAScript 6+'
+reference: 'https://platzi.com/cursos/ecmascript-6/'
+level: 'advanced'
+---
+```javascript
+const sumar = (a,b) => {
+  if(!a || !b){
+    throw new Error("faltan parametros");
+  }
+  return a + b;
+}
+
+console.log(sumar(2,2));
+console.log(sumar(2,true));
+console.log(sumar(2,0));
+```

data/79-boolean.md

@@ -0,0 +1,28 @@
+---
+title: 'Explica este código JavaScript'
+createdAt: '2022-06-12T18:02:21.474Z'
+answers: [
+    'true, false, false, true, true', 
+    'false, false, true, true, false', 
+    'true, true, false, false, false', 
+    'false, ReferenceError, false, false, true']
+response: 0 
+explanation: 'El constructor <code>Boolean</code> permite convertir valores a tipo boolean.
+<br /> <br/>
+Los valores <code>truthy</code> como el número <code>37</code>, un objeto vacío, o un <code>Symbol</code> infieren a <code>true</code> sin ninguna complicación.
+<br /> <br/>
+Valores como <code>NaN</code>, cadenas vacías o <code>0</code> al ser considerados valores <code>falsy</code> inferirán a <code>false</code>.'
+author: 'cristian-fernando-villca-gutie'
+course: 'Curso de ECMAScript 6+'
+reference: 'https://platzi.com/cursos/ecmascript-6/'
+level: 'intermediate'
+---
+```javascript
+const toBolean = x => Boolean(x);
+
+console.log(toBolean(37));
+console.log(toBolean(0/0));
+console.log(toBolean(0));
+console.log(toBolean({}));
+console.log(toBolean(Symbol("Soy un symbol")));
+```