diff --git a/data/74-json-stringify.md b/data/74-json-stringify.md
new file mode 100644
index 0000000..bd21ecc
--- /dev/null
+++ b/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: 'JSON.stringify convierte a los arreglos en cadenas.
+Para los arreglos a y b tendríamos:
+
+
+ console.log("[1, 2, 3]" === "[1, 2, 3]"); //true
+
+
+Para los arreglos a y c tendríamos:
+
+
+ console.log("[1, 2, 3]" === "[1, 2, "3"]"); //false
+
+Son simples comparaciones de primitivos, en este caso de cadenas.
+Usar JSON.stringify 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)); //? 🤔
+```
\ No newline at end of file
diff --git a/data/75-array-string.md b/data/75-array-string.md
new file mode 100644
index 0000000..c703ed9
--- /dev/null
+++ b/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 (+), están diseñados para tipos de datos primitivos, especialmente para cadenas de caracteres y números.
+
+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.
+
+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:
+
+ const a = [1, 2, 3];
+ let b = [4, 5, 6];
+ console.log(a.toString() + b.toString()); //"1, 2, 3" + "4, 5, 6"
+
+
+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); //?
+```
\ No newline at end of file
diff --git a/data/76-object-is.md b/data/76-object-is.md
new file mode 100644
index 0000000..b3422cd
--- /dev/null
+++ 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?
+
+Object.is recibe 2 parámetros y hace una comparación profunda entre ellos, pero va un poco más lejos.
+
+Casos como: 0 === -0 y NaN === NaN son mejor manejados con Object.is.
+
+Cuando comparamos un NaN vs otro NaN usando === obtenemos siempre false lo que no tiene mucho sentido, en estos casos es mejor usar Object.is.'
+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)); //🤔?
+```
\ No newline at end of file
diff --git a/data/77-undefined.md b/data/77-undefined.md
new file mode 100644
index 0000000..efc0fb7
--- /dev/null
+++ 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 undefined como resultado:
+
+Cuando declaramos una variable con let o var sin inicializarla, como en el ejemplo #1.
+
+Cuando en la llamada de una función omitimos parámetros obligatorios, como en el ejemplo #2.
+
+Cuando intenamos acceder a una propiedad de un objeto que no existe, como en el ejemplo #3.
+
+Cuando llamamos a una función que no tiene la sentencia return 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())
+```
\ No newline at end of file
diff --git a/data/78-function.md b/data/78-function.md
new file mode 100644
index 0000000..9966038
--- /dev/null
+++ b/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: 'Primer caso:
+Simple suma de números enteros.
+
+Segundo caso:
+Por inferencia de tipos, el parámetro true se convierte en 1, por ello el resultado es 3.
+
+Tercer caso:
+En el if 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:
+
+
+ const sumar = (a,b) => {
+ if(a === undefined || b === undefined){
+ throw new Error("faltan parametros");
+ }
+ return a + b;
+ }
+
+
+O una solucuón un poco más elegante:
+
+
+ const sumar = (a, b) => {
+ if ([a,b].includes(undefined)) {
+ throw new Error("faltan parametros");
+ }
+ return a + b;
+ }
+
+
+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));
+```
\ No newline at end of file
diff --git a/data/79-boolean.md b/data/79-boolean.md
new file mode 100644
index 0000000..90f571b
--- /dev/null
+++ b/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 Boolean permite convertir valores a tipo boolean.
+
+Los valores truthy como el número 37, un objeto vacío, o un Symbol infieren a true sin ninguna complicación.
+
+Valores como NaN, cadenas vacías o 0 al ser considerados valores falsy inferirán a false.'
+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")));
+```
\ No newline at end of file