Unidad 3: Funciones y Manejo de Errores

3.1 Funciones en JavaScript

Las funciones son bloques de código reutilizables que permiten organizar y estructurar mejor nuestros programas. Nos ayudan a reducir la repetición de código y mejorar la legibilidad.

¿Cómo se ejecutan las funciones en un programa?

Cuando declaramos una función en JavaScript, esta no se ejecuta inmediatamente, sino que se almacena en memoria y solo se ejecuta cuando es llamada en el código. Esto nos permite definir funciones al inicio de un programa y utilizarlas en cualquier momento posterior.

Ejemplo de declaración y llamada de función
Ejemplo básico de función
1
2
3
4
5
6
function mensaje() {
    console.log("Este mensaje se muestra solo cuando se llama a la función.");
}

// Llamamos a la función
mensaje();

3.1.1 Declaración y Uso de Funciones

Las funciones en JavaScript se pueden declarar utilizando la palabra clave function. Estas permiten organizar el código en bloques reutilizables.

Ejemplo de función simple

Función que muestra un mensaje
1
2
3
4
5
function saludar() {
    console.log("Hola, bienvenido a JavaScript!");
}

saludar(); // Llamada a la función

Las funciones pueden aceptar parámetros para hacerlas más dinámicas:

Ejemplo con parámetros

Función con parámetros
1
2
3
4
5
6
function saludar(nombre) {
    console.log("Hola, " + nombre + "!");
}

saludar("Carlos"); // Salida: Hola, Carlos!
saludar("María"); // Salida: Hola, María!

3.1.2 Parámetros y Valores de Retorno

Las funciones pueden devolver valores utilizando la palabra clave return. Esto permite que el resultado de una función pueda ser utilizado posteriormente en el programa.

Ejemplo con valor de retorno

Función que retorna un valor
1
2
3
4
5
6
function sumar(a, b) {
    return a + b;
}

let resultado = sumar(5, 3);
console.log("La suma es:", resultado);

Si una función no tiene return, devuelve undefined de forma implícita.

Ejemplo de función sin retorno

Función sin return
1
2
3
4
5
6
function mostrarMensaje() {
    console.log("Este es un mensaje de prueba");
}

let mensaje = mostrarMensaje();
console.log(mensaje); // undefined

3.1.3 Funciones Anónimas

Las funciones anónimas son aquellas que no tienen un nombre definido. Se suelen asignar a variables:

Ejemplo de función anónima

Función anónima asignada a una variable
1
2
3
4
5
let multiplicar = function(a, b) {
    return a * b;
};

console.log(multiplicar(4, 5)); // Salida: 20

Las funciones anónimas son útiles para definir comportamientos que solo se usan en un contexto específico.

3.1.4 Funciones como Expresiones

En JavaScript, las funciones pueden ser declaradas como expresiones y asignadas a variables.

Ejemplo de función como expresión

Función como expresión
1
2
3
4
5
6
7
8
9
function sumar(num1, num2) {
    return num1 + num2;
}
function mult(num1, num2) {
    return num1 * num2;
}
// (8 + 4) * 2 = 24
let resultado = mult(sumar(8, 4), 2);
console.log(resultado); // 24

Las funciones expresadas se usan cuando queremos definir una función y almacenarla en una variable para luego ejecutarla en un momento determinado.

3.1.5 Paso de Parámetros por Valor y por Referencia

En JavaScript, los tipos primitivos (números, cadenas, booleanos) se pasan por valor, mientras que los objetos y arrays se pasan por referencia.

Nota

Pasar por valor significa que se crea una copia del valor original, mientras que pasar por referencia significa que se comparte la misma referencia en memoria. En los casos de los tipos primitivos, cualquier cambio dentro de la función no afectará a la variable original. Por tanto el paso es por valor.

Ejemplo de paso por valor

Paso por valor
1
2
3
4
5
6
7
8
function cambiarValor(numero) {
    numero = 100;
    console.log("Dentro de la función:", numero);
}

let x = 10;
cambiarValor(x);
console.log("Fuera de la función:", x); // x sigue siendo 10

Nota

En el caso de los objetos y arrays, si modificamos el objeto dentro de la función, los cambios se reflejarán fuera de la función. Por tanto en este caso se pasa siempre por referencia.

Ejemplo de paso por referencia

Paso por referencia
1
2
3
4
5
6
7
function modificarObjeto(objeto) {
    objeto.nombre = "Modificado";
}

let persona = { nombre: "Original" };
modificarObjeto(persona);
console.log("Después de la función:", persona.nombre); // "Modificado"

3.1.6 Alcance de las Variables: Local y Global

Las variables en JavaScript pueden tener ámbito global o ámbito local dependiendo de dónde sean declaradas.

  • Variables globales: Son accesibles desde cualquier parte del código.
  • Variables locales: Solo existen dentro de la función donde fueron declaradas.

Ejemplo de variables globales y locales

Ámbito de variables
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
let global = "Soy global";

function mostrarAmbito() {
    let local = "Soy local";
    console.log(global); // Accede a la variable global
    console.log(local);  // Accede a la variable local
}

mostrarAmbito();
console.log(global); // Funciona
// console.log(local); // Error: local no está definida fuera de la función

3.1.7 Funciones recursivas (Introducción)

Una función recursiva es aquella que se llama a sí misma dentro de su propio cuerpo. Es una técnica muy poderosa y útil en programación, especialmente para resolver problemas que se pueden dividir en subproblemas más pequeños.

Algunos ejemplos típicos de resolución de problemas mediante funciones recursivas son el cálculo de factoriales, la serie de Fibonacci, la búsqueda de elementos en árboles, entre otros.

Vamos a ver como ejercicios prácticos algunos ejemplos de funciones recursivas.

Ejemplo de función recursiva: Factorial

Función recursiva: Factorial
1
2
3
4
5
6
7
8
9
function factorial(n) {
    if (n === 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

console.log(factorial(5)); // 5! = 120

3.1.8 Retorno de Funciones

Las funciones en JavaScript pueden devolver un valor mediante la palabra clave return. Esto permite que el resultado de una función pueda ser utilizado posteriormente en el programa.

Ejemplo de retorno en funciones

Uso del return en funciones
1
2
3
4
5
6
function sumar(a, b) {
    return a + b;
}

let resultado = sumar(5, 3);
console.log("El resultado de la suma es:", resultado);

Cuando una función no tiene return, devuelve undefined de forma implícita.

Ejemplo de función sin retorno

Función sin return
1
2
3
4
5
6
function mostrarMensaje() {
    console.log("Este es un mensaje de prueba");
}

let mensaje = mostrarMensaje();
console.log(mensaje); // undefined

Las funciones pueden retornar distintos tipos de valores:

  1. Valores primitivos (números, cadenas, booleanos):

    Retorno de valores primitivos
    1
2
3
4
5
    function obtenerNombre() {
    return "Carlos";
}

console.log(obtenerNombre());

  2. Expresiones o cálculos:

    Retorno de una expresión
    1
2
3
4
5
    function calcularDoble(x) {
    return x * 2;
}

console.log(calcularDoble(10)); // Salida: 20

  3. Objetos (tema que veremos más adelante):

    Retorno de un objeto
    1
2
3
4
5
6
    function crearPersona(nombre, edad) {
    return { nombre: nombre, edad: edad };
}

let persona = crearPersona("Ana", 30);
console.log(persona.nombre, persona.edad); // Salida: Ana 30

  4. Otras funciones:

    Retorno de una función
    1
2
3
4
5
6
7
8
    function crearFuncion() {
    return function() {
        console.log("Soy una función retornada");
    };
}

let nuevaFuncion = crearFuncion();
nuevaFuncion();

El uso adecuado de return permite que las funciones sean más reutilizables y organizadas dentro del código.

3.1.9 Funciones Anónimas Autoejecutadas (IIFE)

Las funciones anónimas autoejecutadas (IIFE, Immediately Invoked Function Expressions) son funciones que se ejecutan inmediatamente después de ser definidas. Se usan para evitar contaminar el ámbito global y encapsular variables.

Ejemplo de función autoejecutada

IIFE básica
1
2
3
(function() {
    console.log("Esta función se ejecuta inmediatamente");
})();

También pueden recibir parámetros:

IIFE con parámetros

IIFE con parámetros
1
2
3
(function(nombre) {
    console.log("Hola, " + nombre);
})("Carlos");

En este punto podemos añadir la función cierre o closure que es una función anidada dentro de otra función que tiene acceso a las variables de la función exterior. Veamos un ejemplo con una función contador con un atributo valor y métodos getValor y incrementar y decrementar:

Ejemplo de función cierre

Función cierre
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
var miContador = (function contador() {
    let valor = 0;

    return {
        getValor: function() {
            return valor;
        },
        incrementar: function() {
            valor++;
        },
        decrementar: function() {
            valor--;
        }
    };
})();

console.log(miContador.getValor()); // 0
miContador.incrementar();
miContador.incrementar();
console.log(miContador.getValor()); // 2
miContador.decrementar();
console.log(miContador.getValor()); // 1

Este patrón de diseño es muy útil para proteger variables y métodos de ser accedidos desde fuera de la función. Su principal diferencia con los objetos (clases) es que no se pueden crear instancias de la función contador y solo se puede acceder a sus métodos a través de la función contador.

3.1.10 Funciones Flecha (Arrow Functions)

Las funciones flecha (=>) son una forma más concisa de escribir funciones en JavaScript. Se utilizan sobre todo en funciones cortas y expresiones de retorno rápido.

Sintaxis básica:

Sintaxis de una función flecha
1
2
const sumar = (a, b) => a + b;
console.log(sumar(5, 3)); // Salida: 8

Si la función tiene una sola línea, el return es implícito. Si tiene varias líneas, se necesita escribir un bloque con {} y return:

Ejemplo con varias líneas

Función flecha con varias líneas
1
2
3
4
5
const multiplicar = (a, b) => {
    let resultado = a * b;
    return resultado;
};
console.log(multiplicar(4, 5)); // Salida: 20

Las funciones flecha no tienen su propio this, lo que las hace útiles en ciertos casos (aunque esto se verá más adelante).

Ejercicios: Funciones en JavaScript

Ejercicio 1: Función para determinar si un número es positivo, negativo o cero

  • Crea una función llamada determinarSigno que reciba un número como parámetro.
  • La función debe devolver "positivo" si el número es mayor que cero, "negativo" si es menor que cero, y "cero" si es exactamente cero.
Solución
Función para determinar signo de un número
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function determinarSigno(numero) {
    if (numero > 0) {
        return "positivo";
    } else if (numero < 0) {
        return "negativo";
    } else {
        return "cero";
    }
}

console.log(determinarSigno(10));  // positivo
console.log(determinarSigno(-5));  // negativo
console.log(determinarSigno(0));   // cero

Ejercicio 2: Función para verificar si una palabra es un palíndromo

  • Crea una función esPalindromo que reciba una palabra y devuelva true si se lee igual de izquierda a derecha que de derecha a izquierda, y false en caso contrario.
Solución
Función para verificar palíndromos usando bucles
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function esPalindromo(palabra) {
    let longitud = palabra.length;
    for (let i = 0; i < longitud / 2; i++) {
        if (palabra[i].toLowerCase() !== palabra[longitud - 1 - i].toLowerCase()) {
            return false;
        }
    }
    return true;
}

console.log(esPalindromo("reconocer")); // true
console.log(esPalindromo("javascript")); // false

Ejercicio 3: Función para calcular la media de tres números

  • Crea una función llamada calcularMedia que reciba tres números como parámetros y devuelva la media aritmética de los tres.
Solución
Función para calcular la media
1
2
3
4
5
6
function calcularMedia(a, b, c) {
    return (a + b + c) / 3;
}

console.log(calcularMedia(5, 10, 15)); // 10
console.log(calcularMedia(7, 14, 21)); // 14

Ejercicio 4: Función para determinar si un número es primo

  • Crea una función esPrimo que reciba un número entero positivo y devuelva true si es primo y false en caso contrario.
Solución
Función para verificar si un número es primo
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
function esPrimo(numero) {
    if (numero < 2) return false;
    for (let i = 2; i < numero; i++) {
        if (numero % i === 0) {
            return false;
        }
    }
    return true;
}

console.log(esPrimo(7)); // true
console.log(esPrimo(10)); // false
Ejercicio adicional

Teiendo en cuenta la función esPrimo() crea funciones a las que seles pase un array de números enteros y:

- Devuelva un array con los números primos.
- Compruebe si exeiste algún número primo en el array.
- Compruebe si todos los números del array son primos.
- Devuelva la cantidad de números primos en el array.

Ejercicio 5: Función que devuelve la cantidad de vocales en una palabra

  • Crea una función contarVocales que reciba una palabra y devuelva cuántas vocales contiene.
Solución
Función para contar vocales en una palabra
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
function contarVocales(palabra) {
    let contador = 0;
    let vocales = "aeiouAEIOU";
    for (let i = 0; i < palabra.length; i++) {
        if (vocales.includes(palabra[i])) {
            contador++;
        }
    }
    return contador;
}

console.log(contarVocales("javascript")); // 3
console.log(contarVocales("programación")); // 5

Ejercicio 6: Función para generar un número aleatorio entre dos valores

  • Crea una función numeroAleatorio que reciba dos números (min y max) y devuelva un número entero aleatorio dentro de ese rango, incluyendo ambos valores.
Solución
Función para generar un número aleatorio
1
2
3
4
5
6
function numeroAleatorio(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

console.log(numeroAleatorio(1, 10)); // Número aleatorio entre 1 y 10
console.log(numeroAleatorio(50, 100)); // Número aleatorio entre 50 y 100

Ejercicio 7: Función como expresión

  • Crea una función como expresión que calcule el cuadrado de un número y la almacene en una variable.
Solución
Función como expresión
1
2
3
4
5
let cuadrado = function(n) {
    return n * n;
};

console.log(cuadrado(5)); // Salida: 25

Ejercicio 8: Diferencia entre paso por valor y referencia

  • Declara una función que intente modificar una variable primitiva y otra que modifique un objeto. Explica la diferencia.
Solución
Paso por valor y referencia
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
function cambiarNumero(num) {
    num = 50;
}

function cambiarObjeto(obj) {
    obj.nombre = "Nuevo";
}

let numero = 10;
let persona = { nombre: "Viejo" };

cambiarNumero(numero);
cambiarObjeto(persona);

console.log(numero); // Sigue siendo 10 (paso por valor)
console.log(persona.nombre); // "Nuevo" (paso por referencia)

Ejercicio 9: Comprender el ámbito de variables

  • Crea una función que defina una variable local e intenta acceder a ella desde fuera de la función. ¿Qué sucede?
Solución
Ámbito de variables
1
2
3
4
5
6
7
function definirVariable() {
    let local = "Solo existo aquí";
    console.log(local); // Funciona dentro de la función
}

definirVariable();
// console.log(local); // Error: local no está definida fuera de la función

Ejercicios adicionales

Ejercicio 10: Validar la letra del DNI

  • Crea una función que reciba un número de DNI y su letra.
  • Comprueba si la letra es correcta (usando el método oficial de cálculo del DNI en España).
  • Pista: define y utiliza la constante const letras = "TRWAGMYFPDXBNJZSQVHLCKE";
  • Pide al usuario el número de DNI y su letra y verifica si son correctos.
Solución
Validación de letra del DNI
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const prompt = require("prompt-sync")();

function calcularLetraDNI(numero) {
    const letras = "TRWAGMYFPDXBNJZSQVHLCKE";
    return letras[numero % 23];
}

let dni = prompt("Introduce el número del DNI: ");
let letra = prompt("Introduce la letra del DNI: ").toUpperCase();

let letraCalculada = calcularLetraDNI(parseInt(dni));

if (letra === letraCalculada) {
    console.log("DNI correcto.");
} else {
    console.log("DNI incorrecto. La letra debería ser:", letraCalculada);
}

Ejercicio 11: Contar repeticiones de una letra en una cadena

  • Crea una función que reciba una cadena y una letra.
  • Devuelve cuántas veces aparece esa letra en la cadena.
  • Pide al usuario una cadena y una letra y muestra el resultado.
Solución
Contar letras en una cadena
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
const prompt = require("prompt-sync")();

function contarLetra(cadena, letra) {
    let contador = 0;
    for (let i = 0; i < cadena.length; i++) {
        if (cadena[i].toLowerCase() === letra.toLowerCase()) {
            contador++;
        }
    }
    return contador;
}

let cadenaUsuario = prompt("Introduce una cadena: ");
let letraUsuario = prompt("Introduce una letra: ");

console.log(`La letra '${letraUsuario}' aparece`, contarLetra(cadenaUsuario, letraUsuario), "veces en la cadena.");

Ejercicio 12: Cálculo área de diferentes figuras

  • Crea funciones que calculen el área de diferentes figuras geométricas. ("cuadrado", "triangulo", "circulo").
  • Crea una función para pedir al usuario un número positivo y validar que sea un número, devolver -1 si no es válido.
  • Pide al usuario la figura y dependiendo d la figura pide los parámetros necesarios.
  • Calcula el área de la figura y muéstrala (utilizando la función correspondiente).
Solución con if...else
Cálculo de áreas de figuras geométricas
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
const prompt = require("prompt-sync")();

function pedirNumero() {
    let numero = prompt("Introduce un número positivo (el símbolo decimal es la ','): ");
    if (isNaN(numero) || numero <= 0) {
        return -1;
    }
    return parseFloat(numero);
}

function calcularAreaCuadrado(lado) {
    return lado * lado;
}

function calcularAreaTriangulo(base, altura) {
    return (base * altura) / 2;
}

function calcularAreaCirculo(radio) {
    return Math.PI * radio * radio;
}

let figura = prompt("Introduce la figura (cuadrado, triangulo, circulo): ").toLowerCase();

if (figura === "cuadrado") {
    let lado = pedirNumero();
    if (lado !== -1) {
        console.log("El área del cuadrado es:", calcularAreaCuadrado(lado));
    } else {
        console.log("Número inválido.");
    }
} else if (figura === "triangulo") {
    let base = pedirNumero();
    let altura = pedirNumero();
    if (base !== -1 && altura !== -1) {
        console.log("El área del triángulo es:", calcularAreaTriangulo(base, altura));
    } else {
        console.log("Número inválido.");
    }
} else if (figura === "circulo") {
    let radio = pedirNumero();
    if (radio !== -1) {
        console.log("El área del círculo es:", calcularAreaCirculo(radio));
    } else {
        console.log("Número inválido.");
    }
} else {
    console.log("Figura no válida.");
}
Solución con switch
Cálculo de áreas de figuras geométricas con switch
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
const prompt = require("prompt-sync")();
function pedirNumero() {
    let numero = prompt("Introduce un número positivo (el símbolo decimal es la ','): ");
    if (isNaN(numero) || numero <= 0) {
        return -1;
    }
    return parseFloat(numero);
}

function calcularAreaCuadrado(lado) {
    return lado * lado;
}
function calcularAreaTriangulo(base, altura) {
    return (base * altura) / 2;
}
function calcularAreaCirculo(radio) {
    return Math.PI * radio * radio;
}
let figura = prompt("Introduce la figura (cuadrado, triangulo, circulo): ").toLowerCase();

switch (figura) {
    case "cuadrado":
        let lado = pedirNumero();
        if (lado !== -1) {
            console.log("El área del cuadrado es:", calcularAreaCuadrado(lado));
        } else {
            console.log("Número inválido.");
        }
        break;
    case "triangulo":
        let base = pedirNumero();
        let altura = pedirNumero();
        if (base !== -1 && altura !== -1) {
            console.log("El área del triángulo es:", calcularAreaTriangulo(base, altura));
        } else {
            console.log("Número inválido.");
        }
        break;
    case "circulo":
        let radio = pedirNumero();
        if (radio !== -1) {
            console.log("El área del círculo es:", calcularAreaCirculo(radio));
        } else {
            console.log("Número inválido.");
        }
        break;
    default:
        console.log("Figura no válida.");
}

Ejercicio 13: Filtro de articulos (JSON)

Dado un JSON con datos sobre mobiles, y un JSON con datos por los que quiere filtrar el cliente, crear la funciones necesarias para leer el JSON de artículos y el JSON de filtro. A partir de la información debemos obtener un array de artículos que cumplan el filtro, y mostrarlo por consola.

Artículos de ejemplo 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
{
    "articulos": [                    
    {
        "marca": "Samsung",
        "modelo": "Galaxy S23",
        "memoria_RAM": "8GB",
        "memoria_SD": "128GB",
        "nucleos": 8,
        "pulgadas": 6.1,
        "precio": 799.99
        },
        {
        "marca": "Apple",
        "modelo": "iPhone 14",
        "memoria_RAM": "6GB",
        "memoria_SD": "256GB",
        "nucleos": 6,
        "pulgadas": 6.1,
        "precio": 899.99
        },
        {
        "marca": "Xiaomi",
        "modelo": "Redmi Note 12",
        "memoria_RAM": "6GB",
        "memoria_SD": "128GB",
        "nucleos": 8,
        "pulgadas": 6.5,
        "precio": 299.99
        },
        {
        "marca": "OnePlus",
        "modelo": "Nord 2",
        "memoria_RAM": "12GB", 
        "memoria_SD": "256GB",
        "nucleos": 8,
        "pulgadas": 6.4,
        "precio": 499.99
        },
        {
        "marca": "Google",
        "modelo": "Pixel 7",
        "memoria_RAM": "8GB",
        "memoria_SD": "128GB",
        "nucleos": 8,
        "pulgadas": 6.3,
        "precio": 599.99
        },
        {
        "marca": "Motorola",
        "modelo": "Edge 30",
        "memoria_RAM": "8GB",
        "memoria_SD": "256GB",
        "nucleos": 8,
        "pulgadas": 6.7,
        "precio": 549.99
        },
        {
        "marca": "Realme",
        "modelo": "GT Neo 3",
        "memoria_RAM": "12GB",
        "memoria_SD": "256GB",
        "nucleos": 8,
        "pulgadas": 6.6,
        "precio": 429.99
        },
        {
        "marca": "Huawei",
        "modelo": "P50 Pro",
        "memoria_RAM": "8GB",
        "memoria_SD": "256GB",
        "nucleos": 8,
        "pulgadas": 6.6,
        "precio": 799.99
        },
        {
         "marca": "Sony",
        "modelo": "Xperia 1 IV",
        "memoria_RAM": "12GB",
        "memoria_SD": "512GB",
        "nucleos": 8,
        "pulgadas": 6.5,
        "precio": 1199.99
        },
        {
        "marca": "Nokia",
        "modelo": "G50",
        "memoria_RAM": "4GB",
        "memoria_SD": "128GB",
        "nucleos": 8,
        "pulgadas": 6.8,
        "precio": 299.99
        }
    ]
}
Filtro de ejemplo 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
{
    "marca": "Samsung",
    "modelo": "",
    "memoria_RAM": "",
    "memoria_SD": "",
    "nucleos": 0,
    "pulgadas_min": 6.1,
    "pulgadas_max": 8.1,
    "precio_min": 799.99,
    "precio_max": 999.99
}
Solución
Filtrar artículos por criterios
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
const fs = require("fs");
// 1. Función para cargar un archivo JSON desde el sistema de archivos
function cargarJSON(ruta) {
    try {
        const datos = fs.readFileSync(ruta, "utf8"); // Leemos el archivo de forma síncrona
        return JSON.parse(datos); // Convertimos el contenido a un objeto JavaScript
    } catch (error) {
        console.error(`Error al cargar el archivo ${ruta}:`, error);
        return null;
    }
}

// 2. Función principal para ejecutar el filtrado
function iniciarFiltrado() {
    // Cargar datos desde los archivos JSON
    const articulos = cargarJSON("articulos.json");
    const filtros = cargarJSON("filtros.json");
    if (!articulos || !filtros) {
        console.error("No se pudieron cargar los datos.");
        return;
    }

    // Aplicamos el filtrado
    const articulosFiltrados = filtrarArticulos(articulos.articulos, filtros);

    // Mostramos los resultados en la consola
    console.log("Artículos filtrados:", articulosFiltrados);
}

// 3. Función para filtrar los artículos según los criterios
function filtrarArticulos(articulos, filtros) {
    let articulosFiltrados = [];

    for (let i = 0; i < articulos.length; i++) {
            et articulo = articulos[i];

        // Usamos la función cumpleFiltros para verificar si el artículo debe incluirse
        if (cumpleFiltros(articulo, filtros)) {
            articulosFiltrados.push(articulo);
        }
    }

    return articulosFiltrados;


// 4. Función para verificar si un artículo cumple los filtros
function cumpleFiltros(articulo, filtros) {
    return cumpleMarca(articulo.marca, filtros.marca) &&
        cumplePulgadas(articulo.pulgadas, filtros.pulgadas_min, filtros.pulgadas_max) &&
        cumplePrecio(articulo.precio, filtros.precio_min, filtros.precio_max);
}

// 5. Función para comprobar si la marca coincide (si está vacía, acepta todas)
function cumpleMarca(marcaArticulo, marcaFiltro) {
    if (marcaFiltro === "" || marcaFiltro === undefined) {
        return true; // No se aplica filtro de marca
    }
    return marcaArticulo === marcaFiltro;
}

// 6. Función para comprobar si el artículo está dentro del rango de pulgadas
function cumplePulgadas(pulgadasArticulo, min, max) {
    if (min === 0 && max === 0) {
        return true; // No se aplica filtro de pulgadas
    }
    return pulgadasArticulo >= min && pulgadasArticulo <= max;
}

// 7. Función para comprobar si el artículo está dentro del rango de precios
function cumplePrecio(precioArticulo, min, max) {
    if (min === 0 && max === 0) {
        return true; // No se aplica filtro de precio
    }
    return precioArticulo >= min && precioArticulo <= max;
}

// 8. Ejecutamos la función principal
iniciarFiltrado();