From 5925e41c79ff250b639c3cca2ce8bab01fa4ea2f Mon Sep 17 00:00:00 2001 From: AlexAmenta Date: Thu, 16 Feb 2023 16:36:28 -0300 Subject: [PATCH 1/4] ejercicios resueltos --- M03 JavaScript Fundamentos/Ejercicio 01.js | 12 +- M03 JavaScript Fundamentos/Ejercicio 02.js | 6 + M03 JavaScript Fundamentos/Ejercicio 03.js | 30 +++++ M03 JavaScript Fundamentos/Ejercicio 04.js | 7 ++ M03 JavaScript Fundamentos/Ejercicio 05.js | 30 +++++ M04 JavaScript Bucles/homework.js | 107 +++++++++++++++++- M05 JavaScript Arrays/homework.js | 124 ++++++++++++++++++++- 7 files changed, 307 insertions(+), 9 deletions(-) diff --git a/M03 JavaScript Fundamentos/Ejercicio 01.js b/M03 JavaScript Fundamentos/Ejercicio 01.js index 655f3d38af..9110d697a4 100644 --- a/M03 JavaScript Fundamentos/Ejercicio 01.js +++ b/M03 JavaScript Fundamentos/Ejercicio 01.js @@ -5,22 +5,22 @@ // por el correspondiente. // Crea una variable de tipo string. -const nuevoString = null; +const nuevoString = "hola"; // Crea una variable de tipo number. -const nuevoNumero = null; +const nuevoNumero = 3; // Crea una variable de tipo boolean. -const nuevoBoolean = null; +const nuevoBoolean = true; // Resuelve el siguiente problema matemático. -const nuevaResta = 10 - null === 3; +const nuevaResta = 10 - 7 === 3; // Resuelve el siguiente problema matemático. -const nuevaMultiplicacion = 10 * null === 40; +const nuevaMultiplicacion = 10 * 4 === 40; // Resuelve el siguiente problema matemático. -const nuevoModulo = 21 % 5 === null; +const nuevoModulo = 21 % 5 === 1; /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ module.exports = { diff --git a/M03 JavaScript Fundamentos/Ejercicio 02.js b/M03 JavaScript Fundamentos/Ejercicio 02.js index 5f1acc08fe..271ed6794e 100644 --- a/M03 JavaScript Fundamentos/Ejercicio 02.js +++ b/M03 JavaScript Fundamentos/Ejercicio 02.js @@ -4,6 +4,7 @@ function devolverString(string) { // Debe retornar un string. // Tu código: + return string; } // ⛔️ "X" e "Y" son números. @@ -11,26 +12,31 @@ function devolverString(string) { function suma(x, y) { // Retorna el resultado de su suma. // Tu código: + return x + y; } function resta(x, y) { // Retorna el resultado de la resta. // Tu código: + return x - y; } function divide(x, y) { // Retorna el resultado de su división. // Tu código: + return x / y; } function multiplica(x, y) { // Retorna el resultado de su multiplicación. // Tu código: + return x * y; } function obtenerResto(x, y) { // Obten el resto de la división de "x" entre "y". // Tu código: + return x % y; } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ diff --git a/M03 JavaScript Fundamentos/Ejercicio 03.js b/M03 JavaScript Fundamentos/Ejercicio 03.js index 03cd0c9477..ee07796e11 100644 --- a/M03 JavaScript Fundamentos/Ejercicio 03.js +++ b/M03 JavaScript Fundamentos/Ejercicio 03.js @@ -5,36 +5,66 @@ function sonIguales(x, y) { // Retorna true si "x" e "y" son iguales. // De lo contrario, retorna false. // Tu código: + if (x === y){ + return true; + } else { + return false; + } } function tienenMismaLongitud(str1, str2) { // Retorna true si los dos strings tienen la misma longitud. // De lo contrario, retorna false. // Tu código: + if(str1.length === str2.length) { + return true + } else { + return false; + } } function menosQueNoventa(num) { // Retorna true si el argumento "num" es menor que noventa. // De lo contrario, retorna false. // Tu código: + if(num < 90) { + return true; + } else { + return false; + } } function mayorQueCincuenta(num) { // Retorna true si el argumento "num" es mayor que cincuenta. // De lo contrario, retorna false. // Tu código: + if(num > 50) { + return true; + } else { + return false; + } } function esPar(num) { // Retorna true si "num" es par. // De lo contrario, retorna false. // Tu código: + if(num % 2 === 0){ + return true; + } else{ + return false; + } } function esImpar(num) { // Retorna true si "num" es impar. // De lo contrario, retorna false. // Tu código: + if(num % 2 !== 0) { + return true; + } else { + return false; + } } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ diff --git a/M03 JavaScript Fundamentos/Ejercicio 04.js b/M03 JavaScript Fundamentos/Ejercicio 04.js index ff7dbe2dcc..6bf2675d8f 100644 --- a/M03 JavaScript Fundamentos/Ejercicio 04.js +++ b/M03 JavaScript Fundamentos/Ejercicio 04.js @@ -6,31 +6,38 @@ function elevarAlCuadrado(num) { // Retorna el valor de "num" elevado al cuadrado. // Tu código: + return Math.pow(num, 2); } function elevarAlCubo(num) { // Retorna el valor de "num" elevado al cubo. // Tu código: + return Math.pow(num, 3); } function elevar(num, exponent) { // Retorna el valor de "num" elevado al exponente "exponent". // Tu código: + return Math.pow(num, exponent); } function redondearNumero(num) { // Redondea "num" al entero más próximo y retórnalo. // Tu código: + return Math.round(num); } function redondearHaciaArriba(num) { // Redondea "num" hacia arriba y retórnalo. // Tu código: + return Math.ceil(num); } function numeroRandom() { // Genera un número al azar entre 0 y 1 y retórnalo. // Tu código: + return Math.random(0, 1); + } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ diff --git a/M03 JavaScript Fundamentos/Ejercicio 05.js b/M03 JavaScript Fundamentos/Ejercicio 05.js index f82c3e3f07..8cd4e1d9c7 100644 --- a/M03 JavaScript Fundamentos/Ejercicio 05.js +++ b/M03 JavaScript Fundamentos/Ejercicio 05.js @@ -8,46 +8,61 @@ function esPositivo(num) { // Si el número es negativo ---> "Es negativo". // Si el número es 0, devuelve false. // Tu código: + if(num > 0){ + return "Es positivo"; + } else if (num < 0){ + return "Es negativo"; + } else { + return false; + } + } function agregarSimboloExclamacion(str) { // Agrega un símbolo de exclamación al final del string "str" y retórnalo // Ejemplo: "hello world" ---> "hello world!" // Tu código: + return str + "!"; } function combinarNombres(nombre, apellido) { // Retorna "nombre" y "apellido" combinados en un mismo string pero separados por un espacio. // Ejemplo: ("Soy", "Henry") ---> "Soy Henry" // Tu código: + return nombre + " " + apellido; } function obtenerSaludo(nombre) { // Toma el string "nombre" y concatena otra string en la cadena para que tome la siguiente forma: // Ejemplo: "Martin" ---> "Hola Martin!" // Tu código: + return "Hola " + nombre + "!"; } function obtenerAreaRectangulo(alto, ancho) { // Retornar el área de un rectángulo teniendo su altura y ancho. // Tu código: + return alto * ancho; } function retornarPerimetro(lado) { // La función recibe como argumento la medida de un lado de un cuadrado. // Debes retornar su perímetro. // Tu código: + return lado * 4; } function areaDelTriangulo(base, altura) { // Calcula el área de un triángulo y retorna el resultado. // Tu código: + return (base * altura) / 2; } function deEuroAdolar(euro) { // Supongamos que 1 euro equivale a 1.20 dólares. // Debes calcular el valor recibido como argumento pasándolo a dolares. // Tu código: + return euro * 1.20; } function esVocal(letra) { @@ -55,8 +70,23 @@ function esVocal(letra) { // Si el usuario ingresa un string de más de un caracter debes retornar el mensaje: "Dato incorrecto". // Si no es vocal, tambien debe retornar "Dato incorrecto". // Tu código: + if ( + letra === "a" || + letra === "e" || + letra === "i" || + letra === "o" || + letra === "u" + ) + { + return "Es vocal"; + } else if (letra.length > 1){ + return "Dato incorrecto"; + } else { + return "Dato incorrecto"; + } } + /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ module.exports = { esPositivo, diff --git a/M04 JavaScript Bucles/homework.js b/M04 JavaScript Bucles/homework.js index 4195354dd9..eedb43658f 100644 --- a/M04 JavaScript Bucles/homework.js +++ b/M04 JavaScript Bucles/homework.js @@ -5,6 +5,11 @@ function obtenerMayor(x, y) { // Retornar el número más grande. // Si son iguales, retornar cualquiera de los dos. // Tu código: +if(x > y){ + return x; +}else{ + return y; +} } function mayoriaDeEdad(edad) { @@ -12,6 +17,11 @@ function mayoriaDeEdad(edad) { // Si tiene 18 años ó más debe retornar el string: "Allowed". // Caso contrario: "Not allowed". // Tu código: + if(edad >= 18){ + return "Allowed"; + }else{ + return "Not allowed"; + } } function conection(status) { @@ -21,6 +31,13 @@ function conection(status) { // De lo contrario, presumimos que el usuario está "Offline". // Retornar el estado de conexión del usuario. // Tu código: + if(status == 1){ + return "Online"; + }else if(status == 2) { + return "Away"; + }else{ + return "Offline" + } } function saludo(idioma) { @@ -30,6 +47,15 @@ function saludo(idioma) { // Si "idioma" es "ingles", devuelve "Hello!". // Si "idioma" no es ninguno de los anteriores o es `undefined` devuelve "Hola!". // Tu código: + if(idioma == "aleman"){ + return "Guten Tag!"; + }else if(idioma == "mandarin"){ + return "Ni Hao!"; + }else if(idioma == "ingles"){ + return "Hello!" + }else{ + return "Hola!"; + } } function colors(color) { @@ -41,18 +67,43 @@ function colors(color) { // Si no es ninguno de esos colores --> "Color not found". // IMPORTANTE: utilizar el statement SWITCH. // Tu código: + switch (color) { + case 'blue': + return "This is blue"; + case 'red': + return "This is red"; + case 'green': + return "This is green"; + case 'orange': + return "This is orange"; + default: + return "Color not found"; + } + + + } function esDiezOCinco(num) { // Retornar true si "num" es 10 o 5. // De lo contrario, retornar false. // Tu código: + if(num === 10 || num === 5){ + return true; + }else{ + return false; + } } function estaEnRango(num) { // Retornar true si "num" es menor que 50 y mayor que 20. // De lo contrario, retornar false. // Tu código: + if(num < 50 && num > 20){ + return true; + } else{ + return false; + } } function esEntero(num) { @@ -62,6 +113,11 @@ function esEntero(num) { // Ejemplo: (-10) ---> true // De lo contrario, retorna false. // Tu código: + if(num % 1 === 0){ + return true; + } else{ + return false; + } } function fizzBuzz(num) { @@ -70,6 +126,16 @@ function fizzBuzz(num) { // Si "num" es divisible entre 3 y 5 (ambos), retorna "fizzbuzz". // De lo contrario, retorna false. // Tu código: + + if(num % 3 === 0 && num % 5 === 0) { + return "fizzbuzz" + } else if(num % 3 === 0){ + return "fizz"; + }else if (num % 5 === 0){ + return "buzz"; + } else{ + return false; + } } function operadoresLogicos(num1, num2, num3) { @@ -80,6 +146,19 @@ function operadoresLogicos(num1, num2, num3) { // Si todos los argumentos son cero, retornar ---> "Error". // Si no se cumple ninguna de las condiciones anteriores, retornar false. // Tu código: + if(num1 > num2 && num1 > num3 > 0 ){ + return "Numero 1 es mayor y positivo"; + } + if(num1 < 0 || num2 < 0 || num3 < 0){ + return "Hay negativos"; + } + if(num3 > num1 && num2){ + return num3 +1; + } + if(num1 === 0 || num2 === 0 || num3 === 0){ + return "Error"; + } + return false; } function esPrimo(num) { @@ -89,18 +168,38 @@ function esPrimo(num) { // [Pista 2]: puedes resolverlo utilizando un `bucle for`. // [Nota]: los números negativos, 0 y 1 NO son números primos. // Tu código: -} + if(num <= 0 || num == 1) return false; + + for (i = 2; i < num; i++){ + if(num % i == 0 ){ + return false; + } + } + return true; + + } function esVerdadero(valor) { // Si "valor" es verdadero retornar "Soy verdadero". // Caso contrario, retornar "Soy falso". // Tu código: + if(valor === true){ + return "Soy verdadero"; + }else{ + return "Soy falso"; + } } function tieneTresDigitos(num) { // Si el número recibido tiene tres dígitos retornar true. // Caso contrario, retornar false. // Tu código: + let numString = num.toString(); + if(numString.length === 3){ + return true; + }else { + return false; + } } function doWhile(num) { @@ -108,6 +207,12 @@ function doWhile(num) { // Retornar el valor final. // Utilizar el bucle Do-While. // Tu código: + let veces = 0 + do { + num += 5; + veces ++; + } while(veces < 8); + return num; } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ diff --git a/M05 JavaScript Arrays/homework.js b/M05 JavaScript Arrays/homework.js index f736cfe9f6..ae88ac1350 100644 --- a/M05 JavaScript Arrays/homework.js +++ b/M05 JavaScript Arrays/homework.js @@ -3,34 +3,45 @@ function devolverPrimerElemento(array) { // Retornar el primer elemento del arreglo recibido por parámetro. // Tu código: + return array[0]; } function devolverUltimoElemento(array) { // Retornar el último elemento del arreglo recibido por parámetro. // Tu código: + return array[array.length - 1]; } function obtenerLargoDelArray(array) { // Retornar la longitud del arreglo recibido por parámetro. // Tu código: + return array.length; } function incrementarPorUno(array) { // El arreglo recibido por parámetro contiene números. // Retornar un arreglo con los elementos incrementados en +1. // Tu código: + for (let i = 0; i < array.length; i++) { + array[i] += 1; + } + return array; } function agregarItemAlFinalDelArray(array, elemento) { // Agrega el "elemento" al final del arreglo recibido. // Retorna el arreglo. // Tu código: + array.push(elemento); + return array; } function agregarItemAlComienzoDelArray(array, elemento) { // Agrega el "elemento" al comienzo del arreglo recibido. // Retorna el arreglo. // Tu código: + array.unshift(elemento); + return array; } function dePalabrasAFrase(palabras) { @@ -39,30 +50,57 @@ function dePalabrasAFrase(palabras) { // con un espacio entre cada palabra. // Ejemplo: ['Hello', 'world!'] -> 'Hello world!'. // Tu código: + return palabras.join(" "); } function arrayContiene(array, elemento) { // Verifica si el elemento existe dentro del arreglo recibido. // Retornar true si está, o false si no está. // Tu código: + if (array.includes(elemento)) { + return true; + } else { + return false; + } } function agregarNumeros(arrayOfNums) { // El parámetro "arrayOfNums" debe ser un arreglo de números. // Suma todos los elementos y retorna el resultado. // Tu código: + var suma = 0; + for (let i = 0; i < arrayOfNums.length; i++) { + suma = suma + arrayOfNums[i]; + } + return suma; } function promedioResultadosTest(resultadosTest) { // El parámetro "resultadosTest" es un arreglo de números. // Itera (en un bucle) los elementos del arreglo y devuelve el promedio de las notas. // Tu código: + var suma = 0; + for (let i = 0; i < resultadosTest.length; i++) { + suma = suma + resultadosTest[i]; + } + var promedio = suma / resultadosTest.length; + return promedio; } function numeroMasGrande(arrayOfNums) { // El parámetro "arrayOfNums" es un arreglo de números. // Retornar el número más grande. // Tu código: + var numeroMax = arrayOfNums[0]; + for (let i = 0; i < arrayOfNums.length; i++) { + if (numeroMax < arrayOfNums[i]) { + numeroMax = arrayOfNums[i]; + } else { + continue + } + + } + return numeroMax } function multiplicarArgumentos() { @@ -70,11 +108,27 @@ function multiplicarArgumentos() { // Si no se pasan argumentos retorna 0. Si se pasa un argumento, simplemente retórnalo. // [PISTA]: "arguments" es un arreglo. // Tu código: + var acc = 1 + if (arguments.length === 0) return 0 + else if (arguments.length === 1) return arguments[0] + else { + for (let i = 0; i < arguments.length; i++) { + acc = acc * arguments[i] + } + return acc + } } function cuentoElementos(array) { // Desarrolla una función que retorne la cantidad de elementos del arreglo cuyo valor sea mayor que 18. // Tu código: + let cantidad = 0; + for (let i = 0; i < array.length; i++) { + if (array[i] > 18) { + cantidad++; + } + } + return cantidad; } function diaDeLaSemana(numeroDeDia) { @@ -82,37 +136,80 @@ function diaDeLaSemana(numeroDeDia) { // Realiza una función que, dado el número del día de la semana, retorne: "Es fin de semana" // si el día corresponde a "Sábado" o "Domingo", y "Es dia laboral" en caso contrario. // Tu código: + if (numeroDeDia === 1 || numeroDeDia === 7) return "Es fin de semana" + else return "Es dia laboral" } function empiezaConNueve(num) { // Esta función recibe por parámetro un número. // Debe retornar true si el entero inicia con 9 y false en otro caso. // Tu código: + let texto = num.toString(); + let primerValor = texto.charAt(); + if (primerValor === "9") { + return true; + } else { + return false; + } } function todosIguales(array) { // Si todos los elementos del arreglo son iguales, retornar true. // Caso contrario retornar false. // Tu código: + let comparar = array[0]; + for (let i = 1; i < array.length; i++) { + if (array[i] !== comparar) { + return false; + } + return true + } } - function mesesDelAño(array) { // El arreglo contiene algunos meses del año desordenados. Debes recorrerlo, buscar los meses "Enero", // "Marzo" y "Noviembre", guardarlos en un nuevo arreglo y retornarlo. // Si alguno de los meses no está, retornar el string: "No se encontraron los meses pedidos". // Tu código: + let nuevoArray = []; + for (let i = 0; i < array.length; i++) { + if (array[i] === "Enero") { + nuevoArray.push(array[i]); + + } else if (array[i] === "Marzo") { + nuevoArray.push(array[i]) + + } else if (array[i] === "Noviembre") { + nuevoArray.push(array[i]) + } + } + if (nuevoArray.length !== 3) { + return "No se encontraron los meses pedidos" + } + return nuevoArray } function tablaDelSeis() { // Escribe una función que muestre la tabla de multiplicar del 6 (del 0 al 60). // La función devuelve un arreglo con los resultados de la tabla de multiplicar del 6 en orden creciente. // Tu código: + let tabla = []; + for (let i = 0; i < 11; i++) { + tabla.push(i * 6); + } + return tabla; } function mayorACien(array) { // La función recibe un arreglo con enteros entre 0 y 200. // Recorrerlo y retornar un arreglo con todos los valores mayores a 100 (no incluye el 100). // Tu código: + let mayor = []; + for (let i = 0; i < array.length; i++) { + if (array[i] > 100) { + mayor.push(array[i]); + } + } + return mayor; } /* ---------------------------------------------------------------------------------- @@ -126,6 +223,20 @@ function breakStatement(num) { // la ejecución y retornar el string: "Se interrumpió la ejecución". // [PISTA]: utiliza el statement 'break'. // Tu código: + let array = []; + for (let i = 0; i < 10; i++) { + num = num + 2; + if (num === i) { + break + } else { + array.push(num); + } + } + if (array.length < 10) { + return "Se interrumpió la ejecución" + } else { + return array + } } function continueStatement(num) { @@ -135,8 +246,17 @@ function continueStatement(num) { // se continua con la siguiente iteración. // [PISTA]: utiliza el statement 'continue'. // Tu código: + let arr = []; + for (let i = 0; i < 10; i++) { + if (i === 5) { + continue; + } else { + num = num + 2; + arr.push(num) + } + } + return arr; } - /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ module.exports = { devolverPrimerElemento, From f859739d53337c7a5ad67c639570e152b674d668 Mon Sep 17 00:00:00 2001 From: Alexcarp-ar Date: Fri, 24 Feb 2023 18:06:30 -0300 Subject: [PATCH 2/4] ejercicios resueltos --- M03 JavaScript Fundamentos/Ejercicio 01.js | 12 ++--- M06 JavaScript Objetos/homework.js | 62 +++++++++++++++++++++- 2 files changed, 66 insertions(+), 8 deletions(-) diff --git a/M03 JavaScript Fundamentos/Ejercicio 01.js b/M03 JavaScript Fundamentos/Ejercicio 01.js index 9110d697a4..16f5a9f551 100644 --- a/M03 JavaScript Fundamentos/Ejercicio 01.js +++ b/M03 JavaScript Fundamentos/Ejercicio 01.js @@ -5,22 +5,22 @@ // por el correspondiente. // Crea una variable de tipo string. -const nuevoString = "hola"; +let nuevoString = "hola"; // Crea una variable de tipo number. -const nuevoNumero = 3; +let nuevoNumero = 3; // Crea una variable de tipo boolean. -const nuevoBoolean = true; +let nuevoBoolean = true; // Resuelve el siguiente problema matemático. -const nuevaResta = 10 - 7 === 3; +let nuevaResta = 10 - 7 === 3; // Resuelve el siguiente problema matemático. -const nuevaMultiplicacion = 10 * 4 === 40; +let nuevaMultiplicacion = 10 * 4 === 40; // Resuelve el siguiente problema matemático. -const nuevoModulo = 21 % 5 === 1; +let nuevoModulo = 21 % 5 === 1; /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ module.exports = { diff --git a/M06 JavaScript Objetos/homework.js b/M06 JavaScript Objetos/homework.js index c2b9c9f9a0..896c95b4aa 100644 --- a/M06 JavaScript Objetos/homework.js +++ b/M06 JavaScript Objetos/homework.js @@ -7,6 +7,12 @@ function crearGato(nombre, edad) { // La propiedad "meow" será una función que retorne el string: "Meow!". // Retornar el objeto. // Tu código: + let gato = { + nombre: nombre, + edad: edad, + meow: function() {return "Meow!"} + } + return gato } function nuevoUsuario(nombre, email, password) { @@ -14,6 +20,12 @@ function nuevoUsuario(nombre, email, password) { // Este debe tener las propiedades: "nombre", "email" y "password" con sus respectivos valores. // Retornar el objeto. // Tu código: + let newObjeto = {} + newObjeto.nombre = nombre + newObjeto.email = email + newObjeto.password = password + return newObjeto + } function agregarPropiedad(objeto, propiedad) { @@ -22,43 +34,68 @@ function agregarPropiedad(objeto, propiedad) { // Esta propiedad será igual al valor `null`. // Retornar el objeto. // Tu código: + objeto[propiedad] = null + return objeto; } function invocarMetodo(objeto, metodo) { // El parámetro "metodo" es un string que coincide con el nombre de una propiedad del objeto recibido. // Esta propiedad contiene una función en su interior. Debes invocarla/ejecutarla. // [NOTA]: no necesitar retornar nada. - // Tu código: + // Tu código: + objeto[metodo](); } function multiplicarNumeroDesconocidoPorCinco(objetoMisterioso) { // El parámetro "objetoMisterioso" posee una propiedad con el nombre "numeroMisterioso". // Debes multiplicar este número por 5 y retornar el resultado. // Tu código: + let multiplicar = objetoMisterioso.numeroMisterioso * 5 + return multiplicar + } function eliminarPropiedad(objeto, propiedad) { // El parámetro "propiedad" es una propiedad del objeto que recibes. // Debes eliminarla del objeto y retornarlo finalmente. // Tu código: + delete objeto[propiedad]; + return objeto; + } function tieneEmail(objetoUsuario) { // Verifica si el "objetoUsuario", en su propiedad "email", posee un valor definido. // En ese caso retornar true. Caso contrario, false. // Tu código: + if (objetoUsuario.email) { + return true; + }else{ + return false; + } + } function tienePropiedad(objeto, propiedad) { // Verifica si el objeto recibido posee una propiedad con el mismo nombre que el parámetro "propiedad". // En ese caso retornar true. Caso contrario, false. // Tu código: + if(objeto.hasOwnProperty(propiedad)){ + return true + } else{ + return false + } } function verificarPassword(objetoUsuario, password) { // Verifica si la propiedad "password" del "objetoUsuario" coincide con el parámetro "password". // En ese caso retornar true. Caso contrario, false. // Tu código: + if(objetoUsuario.password === password ){ + return true; + } else{ + return false; + } } function actualizarPassword(objetoUsuario, nuevaPassword) { @@ -66,6 +103,8 @@ function actualizarPassword(objetoUsuario, nuevaPassword) { // La nueva contraseña la recibes por parámetro. // Retornar el objeto. // Tu código: + objetoUsuario.password = nuevaPassword + return objetoUsuario } function agregarAmigo(objetoUsuario, nuevoAmigo) { @@ -73,6 +112,8 @@ function agregarAmigo(objetoUsuario, nuevoAmigo) { // Debes agregar el "nuevoAmigo" al final de este arreglo. // Retornar el objeto. // Tu código: + objetoUsuario.amigos = ["amigos", nuevoAmigo]; + return objetoUsuario; } function pasarUsuarioAPremium(objetoMuchosUsuarios) { @@ -81,7 +122,11 @@ function pasarUsuarioAPremium(objetoMuchosUsuarios) { // Define esta propiedad de todos los usuarios como true. // Retornar el arreglo. // Tu código: -} + let arreglo = objetoMuchosUsuarios.forEach(usuario => { + usuario.esPremium = true + }); + return objetoMuchosUsuarios + } function sumarLikesDeUsuario(objetoUsuario) { // El parámetro "objetoUsuario" tiene una propiedad llamada "posts" que es un arreglo. @@ -89,6 +134,12 @@ function sumarLikesDeUsuario(objetoUsuario) { // Cada post posee una propiedad llamada "likes". Esta propiedad es un número. // Debes sumar los likes de todos los post y retornar el resultado. // Tu código: + let suma = 0 + objetoUsuario.posts.forEach(post => { + suma = suma + post.likes + }); + + return suma; } function agregarMetodoCalculoDescuento(objetoProducto) { @@ -102,6 +153,13 @@ function agregarMetodoCalculoDescuento(objetoProducto) { // PorcentajeDeDescuento ---> 0.2 // Precio final ---> 8 // Tu código: + objetoProducto.calcularPrecioDescuento = function () { + let descuento = objetoProducto.precio * objetoProducto.porcentajeDeDescuento + objetoProducto["Precio Final"] = objetoProducto.precio - descuento + return objetoProducto["Precio Final"]; + }; + + return objetoProducto } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ From a1f4bdb673edb5050ab11c57d94a38c8d784662d Mon Sep 17 00:00:00 2001 From: Alexcarp-ar Date: Tue, 28 Feb 2023 20:00:24 -0300 Subject: [PATCH 3/4] ejercicios resueltos --- M07 JavaScript Clases/Ejercicio 01.js | 23 ++++++++++++++++++- M07 JavaScript Clases/Ejercicio 02.js | 33 +++++++++++++++++++++++---- 2 files changed, 50 insertions(+), 6 deletions(-) diff --git a/M07 JavaScript Clases/Ejercicio 01.js b/M07 JavaScript Clases/Ejercicio 01.js index 23586970d5..3f887f125f 100644 --- a/M07 JavaScript Clases/Ejercicio 01.js +++ b/M07 JavaScript Clases/Ejercicio 01.js @@ -10,18 +10,39 @@ function crearUsuario() { // El valor {{nombre}} debe ser el nombre definido para la instancia de la clase. // Retornar la clase. // Tu código: -} + + class Usuario { + constructor(usuario, nombre, email, password) { + this.usuario = usuario; + this.nombre = nombre; + this.email = email; + this.password = password; + } + saludar(){ + return 'Hola, mi nombre es ' + this.nombre; + } + } + return Usuario; + } + function agregarMetodoPrototype(Usuario) { // Agrega un método al prototipo de "Usuario". // El método debe llamarse "saludar" y debe devolver el string "Hello World!". // Tu código: + Usuario.prototype.saludar = function () { + return "Hello World!"; + } + } function agregarStringInvertida() { // Agrega un método al prototipo de "String" que devuelva la misma cadena de caracteres, pero invertida. // El método debe llamarse "reverse". // [PISTA]: necesitarás utilizar el objeto "this". + String.prototype.reverse = function() { + return this.split("").reverse().join(''); + } } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ diff --git a/M07 JavaScript Clases/Ejercicio 02.js b/M07 JavaScript Clases/Ejercicio 02.js index ed07493e66..2d91c0ca8f 100644 --- a/M07 JavaScript Clases/Ejercicio 02.js +++ b/M07 JavaScript Clases/Ejercicio 02.js @@ -1,11 +1,26 @@ /*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/ /*2️⃣ EJERCICIO 02 2️⃣*/ -class Persona { - // Crea el constructor de la clase "Persona". - // Debe tener las propiedades: "nombre", "apellido", "edad" y "domicilio". - // Debe tener un método llamado "detalle" que nos devuelva un objeto con las propiedades de la persona y - // sus valores. +// Crea el constructor de la clase "Persona". +// Debe tener las propiedades: "nombre", "apellido", "edad" y "domicilio". +// Debe tener un método llamado "detalle" que nos devuelva un objeto con las propiedades de la persona y +// sus valores. + class Persona { + constructor(nombre, apellido, edad, domicilio){ + this.nombre = nombre; + this.apellido = apellido; + this.edad = edad; + this.domicilio = domicilio; + + this.detalle = function() { + return { + nombre: nombre, + apellido: apellido, + edad: edad, + domicilio: domicilio + } + } + } } function crearInstanciaPersona(nombre, apellido, edad, domicilio) { @@ -13,6 +28,8 @@ function crearInstanciaPersona(nombre, apellido, edad, domicilio) { // Recibirás las propiedades por parámetro. // Retornar la instancia creada. // Tu código: + let instancia = new Persona(nombre, apellido, edad, domicilio) + return instancia; } function agregarMetodo() { @@ -20,6 +37,12 @@ function agregarMetodo() { // Este método toma la propiedad "nombre" y "edad", y devuelve el string: // Ejemplo: "Juan, 22 años". // Tu código: + Persona.prototype.datos = function() { + return `${this.nombre}, ${this.edad} años`; + + + } + } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/ From 58b27de16b971f733acfcd3cf03207726c0d7f37 Mon Sep 17 00:00:00 2001 From: Alexcarp-ar Date: Mon, 13 Mar 2023 19:39:59 -0300 Subject: [PATCH 4/4] ejercicios resueltos --- M08 JavaScript Callback/homework.js | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/M08 JavaScript Callback/homework.js b/M08 JavaScript Callback/homework.js index b14ff4b6f6..900e3cd181 100644 --- a/M08 JavaScript Callback/homework.js +++ b/M08 JavaScript Callback/homework.js @@ -5,12 +5,14 @@ function mayuscula(nombre) { // Debe devolver el mismo nombre, pero con la primera letra en mayúscula. // [Ejemplo]: "mario" ----> "Mario". // Tu código: + return nombre[0].toUpperCase() + nombre.slice(1); } function invocarCallback(cb) { // Invoca/ejecuta el callback `cb`. // [NOTA]: no debes reotrnar nada. // Tu código: + cb(); } function operacionMatematica(num1, num2, cb) { @@ -18,6 +20,8 @@ function operacionMatematica(num1, num2, cb) { // El callback realiza una operación matemática, por lo que necesita de los dos números. // Retorna el resultado del callback pasándole como parámetros los números. // Tu código: + let resultado = cb(num1, num2); + return resultado; } function sumarArray(arrayOfNumbers, cb) { @@ -26,6 +30,13 @@ function sumarArray(arrayOfNumbers, cb) { // Este resultado debes pasárselo como argumento al callback recibido. // [NOTA]: no debes reotrnar nada. // Tu código: + let suma = 0; + for (let i = 0; i < arrayOfNumbers.length; i++) { + suma = suma + arrayOfNumbers[i]; + } + + cb(suma); + } function forEach(array, cb) { @@ -33,6 +44,8 @@ function forEach(array, cb) { // Debes iterar sobre el arreglo, y por cada elemento ejecutar el callback. // Debes pasarle el elemento como argumento al callback. // Tu código: + + array.forEach(elem => cb(elem)); } function map(array, cb) { @@ -40,12 +53,19 @@ function map(array, cb) { // Tiene que guardar el resultado devuelto por el callback en cada elemento dentro de un nuevo arreglo. // Retorna el nuevo arreglo. // Tu código: + let resultado = []; + + for (let i = 0; i < array.length; i++) { + resultado.push(cb(array[i])) + } + return resultado; } function filter(arrayOfStrings) { // Debes identificar todos los elementos el arreglo que comiencen con la letra "a". // Luego retorna un nuevo arreglo con estos elementos. // Tu código: + return arrayOfStrings.filter(elem => elem[0] === 'a'); } /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/