Skip to content
The Chat Archive
gpt-4-1106-preview· OpenAI WildChat-4.8M (AI2)

Necesito una función en Javascript puro y sin otras dependencias, para evaluar una…

  1. User

    Necesito una función en Javascript puro y sin otras dependencias, para evaluar una expresión lógica; si con MExp, ya vencí la evaluación de expresiones matemáticas con variables y funciones, deseo incluir los operadores lógicos AND, OR, NOT y los relacionales =, >, >=, <, <= y <> para diferencia.

  2. Assistant

    Para evaluar expresiones lógicas en JavaScript, puedes crear una función personalizada que acepte una cadena con una expresión y la evalue utilizando una combinación de evaluación de expresiones aritméticas (que ya tienes con MExp) y lógica adicional para manejar los operadores lógicos y relacionales.

    Aquí tienes un ejemplo básico de cómo podrías hacerlo:

    function evaluarExpresionLogica(expr) {
      // Primero reemplazar los símbolos lógicos y relacionales por su equivalente en JavaScript
      const exprConSimbolosJavaScript = expr
        .replace(/<>/g, '!=')
        .replace(/AND/gi, '&&')
        .replace(/OR/gi, '||')
        .replace(/NOT/gi, '!')
        .replace(/=/g, '==')
        .replace(/>=/g, '>=')
        .replace(/<=/g, '<=')
        .replace(/>/g, '>')
        .replace(/</g, '<');
    
      // Este helper evalúa las expresiones matemáticas, suponiendo que es la funcionalidad de MExp
      function evaluarExpresionMatematica(expMatematica) {
        // Aquí deberías de llamar a tu función de MExp o cualquier
        // otra lógica que ya tengas para evaluar expresiones matemáticas.
        return eval(expMatematica); // usando `eval` como ejemplo, reemplaza con MExp.
      }
    
      // Para evaluar expresiones lógicas, necesitas dividir las expresiones matemáticas de los
      // operadores lógicos que las separan y luego unirlas de nuevo.
      const partes = exprConSimbolosJavaScript.split(/\b(&&|\|\||!|==|!=|>=|<=|>|<)\b/);
      for (let i = 0; i < partes.length; i++) {
        // Si la parte es un operador lógico o relacional, lo dejamos.
        if (['&&', '||', '!', '==', '!=', '>=', '<=', '>', '<'].includes(partes[i])) {
          continue;
        }
        // Si no, es una expresión matemática y la evaluamos.
        partes[i] = evaluarExpresionMatematica(partes[i]).toString();
      }
    
      // Volver a unir las partes y evaluar la expresión lógica resultante.
      const exprFinal = partes.join(' ');
      
      try {
        return eval(exprFinal);
      } catch (e) {
        console.error('Error al evaluar la expresión:', exprFinal);
        throw e;
      }
    }
    
    // Ejemplo de uso:
    const resultado = evaluarExpresionLogica("1 > 0 AND (NOT 3 = 2 OR 5 < 10)");
    console.log(resultado); // Debería imprimir `true`.
    

    Ten en cuenta que este código de ejemplo está utilizando la función eval, que ejecuta cadenas como código de JavaScript. Esto puede ser peligroso si no tienes control sobre el contenido de las expresiones que estás evaluando, ya que podría ser una vía para la ejecución de código arbitrario y malicioso (por ejemplo, un ataque de inyección). Por lo tanto, si decides utilizar eval, asegúrate de que la entrada que estás evaluando proviene de una fuente confiable o está debidamente sanitizada.

    Para una seguridad mejorada y si es posible, es recomendable escribir un pequeño parser que pueda interpretar las expresiones lógicas sin tener que usar eval, o usar una biblioteca existente con buenas prácticas de seguridad.

  3. Assistant

    Parece que no se ha incluido ninguna pregunta adicional o contexto en su último mensaje. Si tiene más preguntas, inquietudes o necesita más detalles sobre la implementación de una función JavaScript para evaluar expresiones lógicas, siéntase libre de preguntar y estaré encantado de ayudarle.

  4. User

    Ok, pero debo implementar yo mismo la función evaluarExpresionLogica

  5. Assistant

    Entiendo, si necesitas implementar la función evaluarExpresionLogica, sin usar el eval de JavaScript por las razones de seguridad mencionadas, puedes por ejemplo construir un pequeño analizador de expresiones (parser) para esto. A continuación, presento un ejemplo simplificado de cómo podrías comenzar a crear un parser para evaluar expresiones lógicas y matemáticas:

    function evaluarExpresionLogica(expr) {
        let tokens = tokenize(expr); // Convertir la expresión en tokens
        let postfix = infixToPostfix(tokens); // Convertir la notación infija a notación postfija para fácil evaluación
        return evaluarPostfix(postfix); // Evaluar la expresión en notación postfija
    }
    
    function tokenize(expr) {
        // Implementación de una simple tokenización
        // Divide la expresión en tokens (números, operadores, etc.)
        let regex = /(\bAND\b|\bOR\b|\bNOT\b|<>|<=|>=|==|=|>|<|\+|\-|\*|\/|\(|\)|\s+)/;
        return expr.split(regex).filter(token => token.trim() !== '');
    }
    
    function infixToPostfix(tokens) {
        // Convertir la lista de tokens a notación postfija (RPN)
        // Esto es solo un esbozo de la lógica; necesitas implementar un algoritmo completo de Shunting-yard aquí
        let outputQueue = [];
        let operatorStack = [];
        // ... (implementación del algoritmo)
        // Retorna el arreglo en notación postfija
        return outputQueue.concat(operatorStack.reverse());
    }
    
    function evaluarPostfix(postfix) {
        let stack = [];
        postfix.forEach(token => {
            if (esOperador(token)) {
                let rhs = stack.pop();
                let lhs = stack.pop();
                stack.push(aplicarOperador(lhs, rhs, token));
            } else {
                stack.push(parseFloat(token));
            }
        });
        return stack.pop();
    }
    
    function esOperador(token) {
        // Determinar si el token es un operador
        return ['AND', 'OR', 'NOT', '=', '<>', '>', '>=', '<', '<=', '+', '-', '*', '/'].includes(token);
    }
    
    function aplicarOperador(lhs, rhs, operador) {
        // Aplica el operador a los operandos
        switch (operador) {
            case 'AND': return lhs && rhs;
            case 'OR': return lhs || rhs;
            case 'NOT': return !rhs; // NOT es un operador unario
            case '=': return lhs == rhs;
            case '<>': return lhs != rhs;
            case '>': return lhs > rhs;
            case '>=': return lhs >= rhs;
            case '<': return lhs < rhs;
            case '<=': return lhs <= rhs;
            // Operadores matemáticos
            case '+': return lhs + rhs;
            case '-': return lhs - rhs;
            case '*': return lhs * rhs;
            case '/': return lhs / rhs;
            default: throw new Error('Operador desconocido: ' + operador);
        }
    }
    
    // Ejemplo de uso:
    const resultado = evaluarExpresionLogica("1 > 0 AND NOT (3 = 2 OR 5 < 10)");
    console.log(resultado); // Debería imprimir `false` debido al operador NOT
    

    Este código es solo un esquema y requiere que implementes el algoritmo completo de conversión de la notación infija a postfija (a menudo usando el algoritmo Shunting-yard) y que tomes en cuenta correctamente la precedencia de los operadores y el manejo de paréntesis.

    La función tokenize se utiliza para dividir la expresión en elementos individuales, como números y operadores. infixToPostfix debería convertir esta lista de elementos a la notación postfija utilizando el algoritmo de Shunting-yard. La función evaluarPostfix luego camina por la lista de elementos en notación postfija, realiza las operaciones adecuadas y devuelve el resultado.

    Advertencia: Este código es solo un punto de partida y necesita una implementación más detallada y pruebas para manejar correctamente todas las expresiones lógicas y matemáticas posibles.