Necesito una función en Javascript puro y sin otras dependencias, para evaluar una…
- 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.
- 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 utilizareval, 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. - 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.
- User
Ok, pero debo implementar yo mismo la función evaluarExpresionLogica
- Assistant
Entiendo, si necesitas implementar la función
evaluarExpresionLogica, sin usar elevalde 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 NOTEste 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
tokenizese utiliza para dividir la expresión en elementos individuales, como números y operadores.infixToPostfixdebería convertir esta lista de elementos a la notación postfija utilizando el algoritmo de Shunting-yard. La funciónevaluarPostfixluego 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.