├── .gitignore ├── README.md ├── clase_2 ├── README.md ├── dia-de-paga.js ├── la-tienda-de-ropa.js └── las-galletas-de-ema.js ├── clase_3 ├── 1-pares.js ├── 2-contador.js ├── 3-la-venganza-del-contador.js ├── 4-fibonacci-simple.js ├── 4-la-secuencia-de-fibonacci.js └── 4-pero-en-una-linea.js ├── clase_4 ├── 1.js ├── 2.js └── 3.js ├── clase_5 ├── 1-ranking.js └── 2-lista-de-estudiantes.js ├── clase_6 ├── 1-alumnos-aprobados.js ├── 2-stock-agotado.js ├── 3-jugadores-sospechosos.js ├── 4-silabas.js ├── 5-pedidos.js └── 6-usuario-y-perfil.js ├── clase_7 ├── 1-funcionDeErrores.js ├── 2-simuladorDeDescargaDeInformacion.js └── 3-descargaDeInformacionProhibida.js └── clase_8 ├── Ejercicio1a.js ├── Ejercicio1b.js └── Ejercicio1c.js /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | package-lock.json 3 | package.json 4 | index.js 5 | launch.json 6 | .vscode 7 | index.ts 8 | consumirAPI.js 9 | datos.json 10 | index.html -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ejercicios_coderhood 2 | ejercicios de las primeras clases 3 | -------------------------------------------------------------------------------- /clase_2/README.md: -------------------------------------------------------------------------------- 1 | 2 | Ejercicios 3 | 1) Las galletitas de Ema 4 | Emanuel quiere cocinar galletitas y quiere un programa que lo ayude a saber que debe 5 | comprar y en caso que cuente con todos los ingredientes, informar que puede cocinar las 6 | galletas. La receta pide los siguientes ingredientes: 7 | 3 huevos, 8 | 1 barra de chocolate, 9 | 0.5 kilos de harina, 10 | 5 cucharadas de azucar, 11 | Los ingredientes que tiene Ema tienen que ser variables al inicio del programa que sean 12 | faciles de editar 13 | ------------------------------------------------------------- 14 | 2) La tienda de ropa 15 | Una tienda de ropa desea tener un programa que le permita calcular los aumentos a sus 16 | prendas, para eso se tienen los datos 17 | precioDePrenda (que ronda entre los 1500 y 3000 pesos) 18 | porcentajeDeAumento (que ronda entre el 25-100% ) 19 | precioFinal (precioDePrenda con el aumento agregado) 20 | Ademas, implementar las siguiente funcionalidades: 21 | El programa debe informar en pantalla el precio final 22 | El programa debe informar en pantalla 'Precio excedido' cuando el precio final supere los 23 | $4000 24 | ------------------------------------------------------------- 25 | 3) Dia de paga 26 | En una pizzeria requieren un programa que calcule cuanto cobraran neto los repartides al 27 | final del dia (Todos cobran igual) 28 | Se tienen los siguientes datos obligatorios 29 | 30 | repartidores (Cantidad de repartidores, puede ser cualquier numero entero) 31 | 32 | esFeriado (true si es Feriado, false si no) 33 | 34 | gananciaDelDia (Cuanto recaudo la pizzeria para distribuir a los empleados) 35 | 36 | porcentajeParaSueldos (Un porcentaje de gananciaDelDia) 37 | 38 | sueldoNetoDeRepartidor (Cuanto gana en bolsillo el repartidor) 39 | 40 | gananciaDelComercioFinal (Cuanto gana el comercio una vez pagados los sueldos y 41 | demas) 42 | 43 | Se sabe que: 44 | En feriados: porcentajeParaSueldos es del 80% de gananciaDelDia mientras que en 45 | dias normales, es del 65% 46 | -------------------------------------------------------------------------------- /clase_2/dia-de-paga.js: -------------------------------------------------------------------------------- 1 | console.clear(); 2 | var repartidores = 8; 3 | var esFeriado = true; 4 | var gananciaDelDia = 10000; 5 | var porcentajeParaSueldos; 6 | var sueldoNetoDeRepartidor; 7 | var gananciaDelComercioFinal; 8 | 9 | if (esFeriado === true) { 10 | porcentajeParaSueldos = 0.8 * gananciaDelDia; 11 | } else { 12 | porcentajeParaSueldos = 0.65 * gananciaDelDia; 13 | } 14 | 15 | sueldoNetoDeRepartidor = porcentajeParaSueldos / repartidores; 16 | 17 | gananciaDelComercioFinal = gananciaDelDia - porcentajeParaSueldos; 18 | console.log("El sueldo neto de cada repartidor es: " + sueldoNetoDeRepartidor); 19 | console.log("Una vez pagados los sueldos la pizzeria gana: " + gananciaDelComercioFinal); 20 | -------------------------------------------------------------------------------- /clase_2/la-tienda-de-ropa.js: -------------------------------------------------------------------------------- 1 | console.clear(); 2 | var precioDePrenda = 1500; 3 | var porcentajeDeAumento = 25; 4 | var precioFinal; 5 | 6 | precioFinal = (precioDePrenda * porcentajeDeAumento) / 100 + precioDePrenda; 7 | if (precioFinal > 4000) { 8 | console.log(`'Precio excedido'`); 9 | } else { 10 | console.log("el precio final de la prenda es: $" + precioFinal); 11 | } 12 | -------------------------------------------------------------------------------- /clase_2/las-galletas-de-ema.js: -------------------------------------------------------------------------------- 1 | console.clear(); 2 | var huevos = 3; 3 | var barraDeChocolate = 5; 4 | var harina = 0.5; 5 | var azucar = 3; 6 | var comprar = "hay que comprar:\n"; 7 | 8 | if (huevos >= 3 && barraDeChocolate >= 1 && harina >= 0.5 && azucar >= 5) { 9 | console.log("se pueden hacer las galletitas"); 10 | } else { 11 | if (huevos < 3) { 12 | comprar = comprar + "-" + (3 - huevos) + " huevo(s)\n"; 13 | } 14 | if (barraDeChocolate < 1) { 15 | comprar = comprar + "-" + 1 + " Barra de chocolate\n"; 16 | } 17 | if (harina < 0.5) { 18 | comprar = comprar + "-Harina\n"; 19 | } 20 | if (azucar < 5) { 21 | comprar = comprar + "-Azucar\n"; 22 | } 23 | console.log(comprar); 24 | } 25 | -------------------------------------------------------------------------------- /clase_3/1-pares.js: -------------------------------------------------------------------------------- 1 | console.clear(); 2 | var limite = 20; 3 | 4 | for(let i = 0; i<=limite; i++){ 5 | if(i % 2 === 0){ 6 | console.log(i) 7 | } 8 | } 9 | 10 | /* 11 | 1) Pares 12 | Sea una variable numerica entera y positiva 'limite': 13 | - Recorrer desde 0 hasta `limite` 14 | - Imprimir en pantalla los numeros pares (No la cantidad de num 15 | */ -------------------------------------------------------------------------------- /clase_3/2-contador.js: -------------------------------------------------------------------------------- 1 | var limite = 20; 2 | var impares = 0; 3 | var menores = 0; 4 | for (var i = 0; i <= limite; i++) { 5 | if (i % 2 === 1) { 6 | impares = impares + 1; 7 | } 8 | if (i < limite / 2) { 9 | menores = menores + 1; 10 | } 11 | } 12 | console.log("La cantidad de numeros impares es: " + impares); 13 | console.log("La cantidad de numeros menores que limite/2 es: " + menores); 14 | 15 | /* 16 | 2) Contador 17 | Sea una variable numerica entera y positiva 'limite': 18 | Recorrer desde 0 hasta limite 19 | Imprimir al final del programa la cantidad de numeros impares 20 | Imprimir al final del programa la cantidad de numeros menores de limite / 2 21 | */ 22 | -------------------------------------------------------------------------------- /clase_3/3-la-venganza-del-contador.js: -------------------------------------------------------------------------------- 1 | var limite = 9; 2 | var final = 10; 3 | var pares = 0; 4 | var multiplosDeTres = 0; 5 | var aux = 0; 6 | var suma =0; 7 | 8 | while (aux <= limite && pares <= final) { 9 | 10 | suma = suma + aux; 11 | aux = aux + 1; 12 | 13 | if (aux % 2 === 0) { 14 | pares = pares + 1; 15 | } 16 | 17 | if (aux % 3 === 0) { 18 | multiplosDeTres++; 19 | 20 | } 21 | } 22 | 23 | console.log('La cantidad de numeros multiplos de 3 es: '+ multiplosDeTres); 24 | console.log('la suma de todos los numeros desde 0 hasta el final del recorrido es: '+suma); 25 | 26 | /* 27 | 3) Contador 2: La venganza del contador 28 | Sea una variable numerica entera y positiva 'limite': 29 | Recorrer desde 0 hasta que se cumpla una de las siguientes condiciones: 30 | Se llega a limite 31 | La cantidad de numeros pares desde 0 hasta limite es mayor a una variable 32 | anteriormente creada llamada final 33 | Al final del recorrido imprimir la cantidad de numeros multiplos de 3 34 | Al final del recorrido imprimir la suma de todos los numeros entre el 0 hasta que se 35 | termine el recorrido 36 | */ 37 | -------------------------------------------------------------------------------- /clase_3/4-fibonacci-simple.js: -------------------------------------------------------------------------------- 1 | var limite = 10; 2 | var a = 0; 3 | var b = 1; 4 | var c = 0; 5 | 6 | for (let i = 0; i < limite; i++) { 7 | console.log(c); 8 | a = b; 9 | b = c; 10 | c = a + b; 11 | } -------------------------------------------------------------------------------- /clase_3/4-la-secuencia-de-fibonacci.js: -------------------------------------------------------------------------------- 1 | var limite = 10; 2 | var a = 0; 3 | var b = 1; 4 | var c = 0; 5 | for (let i = 0; i < limite; i++) { 6 | if (i > 1) { 7 | c = a + b; 8 | a = b; 9 | b = c; 10 | console.log(c); 11 | } else { 12 | if (i === 0) { 13 | console.log(i); 14 | } else { 15 | console.log(i); 16 | } 17 | } 18 | } 19 | /* 20 | 4) La secuencia de Fibonacci 21 | En matemáticas, la sucesión o serie de Fibonacci es la 22 | siguiente sucesión infinita de números naturales: 23 | 0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 24 | La sucesión comienza con los números 0 y 1,a partir de estos 25 | cada término es la suma de sus dos anteriores 26 | Sea una variable numerica entera y positiva 'limite': 27 | Recorrer desde 0 hasta limite 28 | Imprimir tantos terminos de la secuencia como repeticions de 0 hasta limite 29 | Ejemplo: si limite = 6, imprimir 0, 1, 1, 2, 3, 5 30 | */ -------------------------------------------------------------------------------- /clase_3/4-pero-en-una-linea.js: -------------------------------------------------------------------------------- 1 | var limite = 10; 2 | var a = 0; 3 | var b = 1; 4 | var c = 0; 5 | var fibonacci = "0, 1, "; 6 | for (let i = 0; i <= limite; i++) { 7 | if (i > 2 && i < limite) { 8 | c = a + b; 9 | a = b; 10 | b = c; 11 | fibonacci += c + ", "; 12 | } else if (i === limite) { 13 | c = a + b; 14 | a = b; 15 | b = c; 16 | fibonacci += c + "..."; 17 | } 18 | } 19 | console.log(fibonacci); 20 | 21 | /* 22 | 4) La secuencia de Fibonacci 23 | En matemáticas, la sucesión o serie de Fibonacci es la 24 | siguiente sucesión infinita de números naturales: 25 | 0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 26 | La sucesión comienza con los números 0 y 1,a partir de estos 27 | cada término es la suma de sus dos anteriores 28 | Sea una variable numerica entera y positiva 'limite': 29 | Recorrer desde 0 hasta limite 30 | Imprimir tantos terminos de la secuencia como repeticions de 0 hasta limite 31 | Ejemplo: si limite = 6, imprimir 0, 1, 1, 2, 3, 5 32 | */ -------------------------------------------------------------------------------- /clase_4/1.js: -------------------------------------------------------------------------------- 1 | //1. Hacer una función que reciba un numero y que retorne verdadero si es par o falso en caso 2 | //contrario. 3 | 4 | function parImpar(_numero) { 5 | if (_numero % 2 === 0) { 6 | return true; 7 | } else { 8 | return false; 9 | } 10 | } 11 | console.log(parImpar(2)); 12 | -------------------------------------------------------------------------------- /clase_4/2.js: -------------------------------------------------------------------------------- 1 | //Hacer una función que reciba una serie de palabras separadas por espacios y que imprima 2 | //la misma frase pero en orden inverso. 3 | 4 | //solucion 1 5 | function inverso(_frase) { 6 | let _inverso = _frase.split("").reverse().join(""); 7 | console.log(_inverso); 8 | } 9 | 10 | inverso("hola amigo"); 11 | 12 | //solucion 2 13 | function inversoFor(_frase) { 14 | let _inverso = ""; 15 | for (let i = _frase.length; i >= 0; i--) { 16 | _inverso += _frase.charAt(i); 17 | } 18 | console.log(_inverso); 19 | } 20 | 21 | inversoFor("adios amigo"); 22 | 23 | //solucion 3 24 | 25 | function inversoWhile(_frase) { 26 | let x = _frase.length - 1; 27 | let _inverso = ""; 28 | while (x >= 0) { 29 | _inverso += _frase[x]; 30 | x--; 31 | } 32 | console.log(_inverso); 33 | } 34 | 35 | inversoWhile("sorpresa he vuelto"); -------------------------------------------------------------------------------- /clase_4/3.js: -------------------------------------------------------------------------------- 1 | //3. Hacer una función que reciba como parámetro tres números enteros y que lo ordene de 2 | //mayor a menor. 3 | 4 | function deMayorAMenor(_num1, _num2, _num3) { 5 | let mayor; 6 | let menor; 7 | 8 | if (_num1 > _num2) { 9 | if (_num1 > _num3) { 10 | mayor = _num1; 11 | } else { 12 | mayor = _num3; 13 | } 14 | } else if (_num2 > _num3) { 15 | mayor = _num2; 16 | } else { 17 | mayor = _num3; 18 | } 19 | 20 | if (_num1 < _num2) { 21 | if (_num1<_num3) { 22 | menor = _num1 23 | } else { 24 | menor = _num3 25 | } 26 | 27 | } else if(_num2 < _num3){ 28 | menor = _num2 29 | }else{ 30 | menor = _num3 31 | } 32 | let medio = _num1 + _num2 + _num3 - (mayor + menor) 33 | console.log(mayor, medio, menor); 34 | 35 | } 36 | 37 | deMayorAMenor(9, 3, 5); -------------------------------------------------------------------------------- /clase_5/1-ranking.js: -------------------------------------------------------------------------------- 1 | // //Dado un array de alumnos de Coderhood Academy, 2 | //indicar quien es el que lidera el ranking de paricipacion en Discord 3 | 4 | let alumnos = [ 5 | { user: "miafate", ranking: 4 }, 6 | { user: "argentum", ranking: 2 }, 7 | { user: "lucas", ranking: 6 }, 8 | { user: "ema", ranking: 3 }, 9 | ]; 10 | 11 | let lider = alumnos[0]; 12 | for (let i = 0; i < alumnos.length; i++) { 13 | if (alumnos[i].ranking < lider.ranking) { 14 | lider = alumnos[i]; 15 | } 16 | } 17 | 18 | console.log(lider.user); 19 | -------------------------------------------------------------------------------- /clase_5/2-lista-de-estudiantes.js: -------------------------------------------------------------------------------- 1 | // //Dado un array de estudiantes de una universidad, 2 | //mostrar los nombres de los estudiantes de la carrera Ingenieria en computacion. 3 | 4 | let alumnos = [ 5 | { nombre: "Ema", carrera: "Ingenieria en computacion" }, 6 | { nombre: "Luis", carrera: "Produccion audiovisual" }, 7 | { nombre: "Pablo", carrera: "Licenciatura en sistemas" }, 8 | { nombre: "Meison", carrera: "Ingenieria en computacion" }, 9 | ]; 10 | 11 | let lista = ""; 12 | 13 | for (let i = 0; i < alumnos.length; i++) { 14 | if (alumnos[i].carrera === "Ingenieria en computacion") { 15 | lista += ", " + alumnos[i].nombre; 16 | } 17 | } 18 | 19 | lista += "."; 20 | 21 | if (lista === ".") { 22 | console.log("nadie estudia Ingenieria en computacion"); 23 | } else { 24 | console.log(`estudian Ingenieria en computacion${lista}`); 25 | } -------------------------------------------------------------------------------- /clase_6/1-alumnos-aprobados.js: -------------------------------------------------------------------------------- 1 | //1. Alumnos aprobados 2 | //Dado el siguiente array de alumnos de una clase 3 | //Obtener un array con los números de alumno de aquellos alumnos que hayan 4 | //aprobado la materia. Para approbar la matería la nota final debe ser mayor a 6. 5 | const alumnos = [ 6 | { numAlumno: "1234/0", nombre: "maria", nota: 7 }, 7 | { numAlumno: "4459/2", nombre: "juan", nota: 3 }, 8 | { numAlumno: "5877/1", nombre: "pepe", nota: 5 }, 9 | { numAlumno: "5512/0", nombre: "josefina", nota: 9 }, 10 | { numAlumno: "9874/0", nombre: "jaime", nota: 7 }, 11 | ]; 12 | 13 | function filtrarNotas(notas) { 14 | return notas.nota > 6; 15 | } 16 | 17 | function aprobados(alumnos) { 18 | return alumnos.numAlumno; 19 | } 20 | 21 | //const arr = alumnos.filter(filtrarNotas).forEach(aprobados); 22 | //en lugar de for each tambien podriamos usar un .map() 23 | const arr = alumnos.filter(nota=>nota>6).forEach(alumno=>alumno.numAlumno); 24 | console.log(arr); -------------------------------------------------------------------------------- /clase_6/2-stock-agotado.js: -------------------------------------------------------------------------------- 1 | //2. Stock agotado 2 | //Dado el siguiente array de productos en stock, 3 | //agregar a cada producto un atributo booleano agotado en true si el stock es mayor a 4 | //0, caso contrario false. 5 | const productos = [ 6 | { id: "1", nombre: "lapiceras", stock: 164 }, 7 | { id: "2", nombre: "marcadores", stock: 0 }, 8 | { id: "3", nombre: "cartulinas", stock: 25 }, 9 | { id: "4", nombre: "cartucheras", stock: 0 }, 10 | { id: "5", nombre: "mochilas", stock: 4 }, 11 | ]; 12 | 13 | function productoAgotado(producto) { 14 | if (producto.stock > 0) { 15 | producto.agotado = false; 16 | } else { 17 | producto.agotado = true; 18 | } 19 | return producto; 20 | } 21 | 22 | const arr = productos.map(productoAgotado); 23 | 24 | console.log(arr); -------------------------------------------------------------------------------- /clase_6/3-jugadores-sospechosos.js: -------------------------------------------------------------------------------- 1 | //3. Jugadores sospechosos 2 | //En nuestro juego online tenemos un array de usuarios sospechosos 3 | // que están usando un item que fue prohibido, obtener la lista 4 | //de IDs de usuarios que en su inventario tengan dicho item. 5 | // El item prohibido se llama "Katana de fuego". 6 | const jugadores = [ 7 | { 8 | ID: "1", 9 | clase: "mago", 10 | nivel: 35, 11 | inventario: ["Manzana", "Poción de maná", "Vara mágica"], 12 | }, 13 | { 14 | ID: "2", 15 | clase: "ladron", 16 | nivel: 65, 17 | inventario: ["Daga", "Katana de fuego", "Poción de vida"], 18 | }, 19 | { 20 | ID: "4", 21 | clase: "curandero", 22 | nivel: 73, 23 | inventario: ["Vara mágica", "Armadura ligera"], 24 | }, 25 | { 26 | ID: "3", 27 | clase: "espadachin", 28 | nivel: 36, 29 | inventario: ["Casco de hierro", "Katana de fuego", "Pocíón de velocidad"], 30 | }, 31 | { 32 | ID: "5", 33 | clase: "mago", 34 | nivel: 26, 35 | inventario: ["Carta de PecoPeco", "Oridecon", "Poción de concentración"], 36 | }, 37 | ]; 38 | 39 | function obtenerId(jugador) { 40 | return jugador.ID; 41 | } 42 | function tieneKatana(jugador) { 43 | return jugador.inventario.includes("Katana de fuego"); 44 | } 45 | const arr = jugadores.filter(tieneKatana).map(obtenerId); 46 | 47 | console.log(arr); -------------------------------------------------------------------------------- /clase_6/4-silabas.js: -------------------------------------------------------------------------------- 1 | //4. Silabas 2 | //Nuestro software de reconocimiento de voz funciona de una forma un poco particualar, 3 | //y el texto reconocido nos lo envía en un arreglo de silabas. 4 | //Dado el siguiente array, obtener un string con todo el texto de corrido. 5 | const silabas = ["¡Ho", "la, ", "mun", "do! ", "¿To", "do ", "bien?", " Me ", "a", "le", "gro."] 6 | //resultado esperado "¡Hola, mundo! ¿Todo bien? Me alegro." 7 | function concatenacion(acc, el){ 8 | return acc + el; 9 | } 10 | 11 | const string = silabas.reduce(concatenacion,""); 12 | 13 | console.log(string); -------------------------------------------------------------------------------- /clase_6/5-pedidos.js: -------------------------------------------------------------------------------- 1 | //5. Pedidos 2 | //Tenemos un array con pedidos para nuestro negocio de comidas. 3 | //Obtener un array con solo aquellos pedidos que incluyan algun 4 | //condimento extra. 5 | 6 | const pedidos = [ 7 | { id: "1", pedido: "hamburgesa", extras: ["mayonesa"] }, 8 | { id: "1", pedido: "pancho" }, 9 | { id: "1", pedido: "pizza" }, 10 | { id: "1", pedido: "pancho", extras: ["ketchup"] }, 11 | { id: "1", pedido: "empanadas" }, 12 | ]; 13 | 14 | function tieneExtras(pedido) { 15 | return pedido.hasOwnProperty("extras"); 16 | } 17 | 18 | const arr = pedidos.filter(tieneExtras); 19 | 20 | console.log(arr); -------------------------------------------------------------------------------- /clase_6/6-usuario-y-perfil.js: -------------------------------------------------------------------------------- 1 | //6. Usuario y su perfil 2 | //Tenemos dos objetos, uno con la información de usuario, 3 | // y otro con la información personal de dicho usuario, queremos obtener 4 | //un solo objeto con toda la información. 5 | const usuario1 = { id: "123", username: "pepe24" }; 6 | const usuario1perfil = { nombre: "pepe", edad: 27, profesion: "programador" }; 7 | //resultado esperado { id: "123", username: "pepe24", nombre: "pepe", edad: 27, profesion: "programador" } 8 | 9 | const obj = { ...usuario1, ...usuario1perfil }; 10 | 11 | console.log(obj); -------------------------------------------------------------------------------- /clase_7/1-funcionDeErrores.js: -------------------------------------------------------------------------------- 1 | /* 1) Funcion de errores 2 | Crear una funcion que recibe tres parametros chance, mensaje y resultado. 3 | chance: es un numero que indica el porcentaje que tiene esa funcion de arrojar un error. 4 | si chance = 20 entonces la funcion tiene 20% de posibilidades de disparar un error 5 | mensaje: el mensaje que tiene que tener el error que puede disparar la funcion 6 | resultado: es cualquier cosa, un numero, un texto, un objeto, etc. es lo que retorna la 7 | funcion si no arrojo un error */ 8 | function funcionCatastrofica(chance, mensaje, resultado) { 9 | let probabilidad = chance / 100; 10 | if (Math.random() <= probabilidad) { 11 | throw new Error(mensaje); 12 | } 13 | return resultado; 14 | } 15 | 16 | try { 17 | let resultado = funcionCatastrofica(5, "Error, ya volvemos :)", 5); 18 | console.log("todo salio bien :)", resultado) 19 | } catch (error) { 20 | console.log(error.message); 21 | } -------------------------------------------------------------------------------- /clase_7/2-simuladorDeDescargaDeInformacion.js: -------------------------------------------------------------------------------- 1 | /* 2) Simulador de descarga de informacion 2 | Cuando queremos descargar informacion de internet, varias cosas pueden ir mal: 3 | desconexion de internet, corte de luz, perdida de informacion por culpa de seres 4 | desconocidos. Crear una funcion llamada pedirInformacion que no recibe parametros y 5 | que devuelve el siguiente objeto que corresponde a los datos de un usuario: let persona = 6 | { id: 19310, nombre: "Bautista", apellido: "Di Santo" } 7 | La funcion pedirInformacion tiene: 8 | 25% de posibilidades de disparar un error por desconexion de internet, el nombre del 9 | error es 'NetworkError' 10 | 18% de posibilidades de disparar un error por error del servidor, el nombre del error es 11 | 'InternalError' 12 | 10% de posibilidades de disparar un error por una anomalia, el nombre del error es 13 | 'AlienError' 14 | Cuando se llame a la funcion, informar: 15 | Si hubo un error, informar segun el mensaje del error: 16 | NetworkError => informar "Hubo un problema en la conexion de internet" 17 | InternalError => informar "Hubo un error interno en el el servidor" 18 | AlienError => informar "Una anomalia intercepto la informacion" 19 | Si no hubo un error, informar el objeto persona */ 20 | 21 | 22 | function pedirInformacion() { 23 | 24 | const falla = Math.random() * 100; 25 | const persona = { id: 19310, nombre: "Bautista", apellido: "Di Santo" }; 26 | //mensajes de error 27 | const NetworkError = "Hubo un problema en la conexion de internet"; 28 | const InternalError = "Hubo un error interno en el el servidor"; 29 | const AlienError = "Una anomalia intercepto la informacion"; 30 | //calculo si salio en el 28% de error 31 | if (falla > 28 && falla <= 53) { 32 | throw new Error(NetworkError); 33 | } 34 | //calculo si salio en el 18% el error 35 | if (falla > 10 && falla <= 28) { 36 | throw new Error(InternalError); 37 | } 38 | //calculo si salio en el 10% el error 39 | if (falla <= 10) { 40 | throw new Error(AlienError); 41 | } 42 | 43 | return console.log(persona); 44 | } 45 | 46 | try { 47 | pedirInformacion(); 48 | } catch (error) { 49 | console.log(error.message); 50 | } 51 | -------------------------------------------------------------------------------- /clase_7/3-descargaDeInformacionProhibida.js: -------------------------------------------------------------------------------- 1 | /* 3) Descarga de informacion prohibida 2 | Crear una funcion llamada pedirUsuario que retorna un usuario al azar de la siguiente 3 | lista: 4 | let lista = [{ 5 | id: 19310, 6 | nombre: "Bautista", 7 | },{ 8 | id: 90010, 9 | nombre: "Ema", 10 | },{ 11 | id: 00519, 12 | nombre: "Lucas", 13 | },{ 14 | id: 00000, 15 | nombre: "Meison", 16 | } 17 | ] 18 | La funcion pedirUsuario disparar un error llamado 'ForbiddenInformation' si el usuario 19 | elegido es el del id = 00000 20 | Llamar a la funcion pedirUsuario dentro de la funcion pedirInformacion para cambiar el 21 | retorno de la funcion pedirInformacion. 22 | Considerar que la funcion pedirInformacion ahora tiene que capturar un error, cuando la 23 | capture debe disparar un error 'NetworkError'. 24 | Ejemplo: 25 | function pedirUsuario(){ 26 | // puede disparar un error, devuelve un usuario 27 | } 28 | function pedirInformacion(){ 29 | let usuario = pedirUsuario(); // considerar 'pedirUsuario' p 30 | // el resto de la funcion 31 | return usuario; 32 | } */ 33 | const lista = [ 34 | { 35 | id: 19310, 36 | nombre: "Bautista", 37 | }, 38 | { 39 | id: 90010, 40 | nombre: "Ema", 41 | }, 42 | { 43 | id: 0051, 44 | nombre: "Lucas", 45 | }, 46 | { 47 | id: 00000, 48 | nombre: "Meison", 49 | }, 50 | ]; 51 | function pedirUsuario() { 52 | //para calcular el usuario que saldra 53 | //con Math.trunc le quito la parte fraccionaria, 54 | //tambien funciona con parseInt() pero ese metodo es mas indicado para trabajar con strings 55 | //asi mismo tambien se podria usar Math.floor() 56 | //pero no Math.round() porque me podria redondear hacia arriba 57 | const usuario = Math.trunc(Math.random() * lista.length); 58 | const ForbiddenInformation = "Informacion Prohibida"; 59 | 60 | if (lista[usuario].id == 00000) { 61 | //si el id es 00000 dispara el error 62 | throw new Error(ForbiddenInformation); 63 | } 64 | //devuelve accediendo al array por el indice aleatorio 65 | return lista[usuario]; 66 | } 67 | 68 | //esta funcion es la misma del ejercicio 2 pero llamando a "pedirUsuario()" 69 | function pedirInformacion() { 70 | const falla = Math.random() * 100; 71 | //defino la variable usuario aqui afuera porque sino no podria devolverla en el bloque finally 72 | let usuario; 73 | //mensajes de error 74 | const NetworkError = "Hubo un problema en la conexion de internet"; 75 | const InternalError = "Hubo un error interno en el el servidor"; 76 | const AlienError = "Una anomalia intercepto la informacion"; 77 | try { 78 | //intento buscar un usuario 79 | usuario = pedirUsuario(); 80 | } catch (error) { 81 | //si atrapa un error debido a que el usuario era el 00000 disparo un nuevo error 82 | //y le paso el mensaje 83 | throw new Error(error.message); 84 | } finally { 85 | 86 | //calculo si salio en el 28% de error 87 | if (falla > 28 && falla <= 53) { 88 | throw new Error(NetworkError); 89 | } 90 | //calculo si salio en el 18% el error 91 | if (falla > 10 && falla <= 28) { 92 | throw new Error(InternalError); 93 | } 94 | //calculo si salio en el 10% el error 95 | if (falla <= 10) { 96 | throw new Error(AlienError); 97 | } 98 | //si no se disparo ningun error chequeo que usuario exista 99 | if (usuario) { 100 | //si usuario tiene algo lo muestro por consola 101 | return console.log(usuario); 102 | } 103 | } 104 | } 105 | 106 | //intento ejecutar "pedirInformacion" 107 | try { 108 | pedirInformacion(); 109 | } catch (error) { 110 | //si se disparo algun error dentro de la funcion lo muestro por consola 111 | console.log(error.message); 112 | } -------------------------------------------------------------------------------- /clase_8/Ejercicio1a.js: -------------------------------------------------------------------------------- 1 | /* Ejercicio 1 - a 2 | Reescribir la siguiente función tal que retorne una promesa que se cumpla luego de 3 segundos (usar setTimeout), devolviendo el 3 | mismo resultado que la función dada. 4 | function dividirNumeros(dividendo, divisor) { 5 | return dividendo / divisor; 6 | } */ 7 | 8 | 9 | function dividirNumerosAsync(dividendo, divisor) { 10 | return new Promise(function (resolve, reject) { 11 | try { 12 | setTimeout(() => { 13 | resolve(dividendo / divisor); 14 | }, 3000); 15 | } catch (error) { 16 | reject(error); 17 | } 18 | }); 19 | } 20 | 21 | function callbackExito(resultadoExito) { 22 | console.log("el resultado obtenido es: " + resultadoExito); 23 | } 24 | function callbackFallo(error) { 25 | console.log("lo siento, hubo un error: " + error); 26 | } 27 | 28 | const promesa = dividirNumerosAsync(3, 0); 29 | promesa.then(callbackExito).catch(callbackFallo); 30 | /* promesa.then((x)=>console.log('el resultado es:',x)).catch((x)=>console.log(x)) */ -------------------------------------------------------------------------------- /clase_8/Ejercicio1b.js: -------------------------------------------------------------------------------- 1 | /* Ejercicio 1 - b 2 | Usando then y catch completar la función "programa" dada para llamar a dividirNumeros e imprimir el resultado o imprimir un 3 | mensaje de error si ocurriera. Para provocar un error pueden enviar 0 como divisor. 4 | function programa() { 5 | // Tu código acá 6 | } 7 | programa(); */ 8 | 9 | function dividirNumerosAsync(dividendo, divisor) { 10 | return new Promise(function (resolve, reject) { 11 | try { 12 | setTimeout(() => { 13 | resolve(dividendo / divisor); 14 | }, 3000); 15 | } catch (error) { 16 | reject(error); 17 | } 18 | }); 19 | } 20 | 21 | function programa(a, b) { 22 | return new Promise(function (resolve, reject) { 23 | try { 24 | resolve(dividirNumerosAsync(a, b)); 25 | } catch (error) { 26 | reject(error); 27 | } 28 | }); 29 | } 30 | programa(5, 0).then((x) => console.log("el resultado es", x)).catch((x)=>console.log(error)); -------------------------------------------------------------------------------- /clase_8/Ejercicio1c.js: -------------------------------------------------------------------------------- 1 | /* Reescribir la función programa del insiso anterior para que use async y await */ 2 | 3 | function dividirNumerosAsync(dividendo, divisor) { 4 | return new Promise(function (resolve, reject) { 5 | try { 6 | setTimeout(() => { 7 | resolve(dividendo / divisor); 8 | }, 3000); 9 | } catch (error) { 10 | reject(error); 11 | } 12 | }); 13 | } 14 | 15 | async function programa(a, b) { 16 | try { 17 | const resultado = await dividirNumerosAsync(a, b); 18 | console.log("el resultado es:", resultado); 19 | } catch (error) { 20 | console.log(error); 21 | } 22 | } 23 | 24 | programa(10, 5); 25 | --------------------------------------------------------------------------------