java - parsestring - string.parse c#

Evaluar la cadena como una condición Java

Question

Tengo que recuperar un conjunto de valores de columna de D / B y verificarlo como condición.

Por ejemplo, tendré cadenas como "value > 2" , "4 < value < 6" en una columna D / B. (El valor es el que se compara todo el tiempo). Tendré un valor variable declarado en mi código y debería evaluar esta condición.

int value = getValue();
if (value > 2)  //(the string retrieved from the D/B)
  doSomething();

¿¿Cómo puedo hacer esto?? Cualquier ayuda es apreciada muceh. Gracias.

Answer 1

Aquí hay un ejemplo usando la biblioteca de scripts estándar (Java 1.6+):

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

public class Test {

    public static void main(String[] args) throws Exception {
        ScriptEngineManager factory = new ScriptEngineManager();
        ScriptEngine engine = factory.getEngineByName("JavaScript");

        engine.eval("value = 10");
        Boolean greaterThan5 = (Boolean) engine.eval("value > 5");
        Boolean lessThan5 = (Boolean) engine.eval("value < 5");

        System.out.println("10 > 5? " + greaterThan5); // true
        System.out.println("10 < 5? " + lessThan5); // false
    }
}

Answer 2

Básicamente estás evaluando una expresión con guión. Dependiendo de lo que esté permitido en esa expresión, puede salirse con algo muy simple (expresión regular que identifica los grupos) o muy complejo (¿incrustar un motor de JavaScript?).

Supongo que está viendo el caso simple, donde la expresión es: [límite0] [operador] "valor" [operador] [límite1]

Donde se puede omitir uno, pero no los dos grupos [límite] [operador]. (Y si ambos están presentes, el operador debe ser el mismo)

Yo usaría una expresión regular para eso con la captura de grupos.

Algo como: (?: (/ D +) / s * ([<>]) / s *)? Value (?: / S * ([<>]) / s * (/ d +))?

Y luego: límite1 = grupo (1); operador1 = grupo (2); operador2 = grupo (3); límite2 = grupo (4)

Answer 3

Debes intentar analizar la cadena dentro de la sentencia if haciendo algo como

if(parseMyString(getValue()))
    doSomething();

En parseMyString puede determinar lo que necesita evaluar para la condición. Si no sabe cómo crear un analizador, eche un vistazo a: http://www.javapractices.com/topic/TopicAction.do?Id=87

Answer 4

Esto no responde tu pregunta per se; Ofrece una solución alternativa que puede afectar el mismo resultado.

En lugar de almacenar una sola columna de la base de datos con pseudocódigo que define una condición, haga una tabla en la que el esquema defina los tipos de condiciones que deben satisfacerse y los valores de esas condiciones. Esto simplifica la evaluación programática de esas condiciones, pero puede complicarse si tiene una variedad de tipos de condiciones para evaluar.

Por ejemplo, puede tener una tabla que se parece a la siguiente.

CONDITION_ID | MINIMUM | MAXIMUM | IS_PRIME  |   ETC.
______________________________________________________
      1      |    2    |   NULL  |   NULL    |   ...
      2      |    4    |    6    |   NULL    |   ...

Esas entradas de fila, respectivamente, se asignan al value > 2 las reglas value > 2 y 6 > value > 4 .

Esto le confiere una serie de beneficios sobre el enfoque que proporciona.

• Mejora el rendimiento y la limpieza.
• Sus condiciones se pueden evaluar en el nivel de la base de datos y se pueden usar para filtrar consultas
• No tiene que preocuparse por manejar escenarios en los que la sintaxis de su pseudocódigo está rota

Answer 5

La última versión de java (Java 7) permite las declaraciones de Switch Case en cadenas, si no hay muchas variaciones posibles, puedes hacer esto o algo similar:

int value = getValue();
Switch(myString) {
  Case "value > 2" : if (value > 2) {  doSomething();} break;
  Case "4 < value < 6" : if (4 < value < 6) {  doSomethingElse();} break;
  default : doDefault();
}

Answer 6

No va a ser trivial: necesita un analizador para el lenguaje de expresión utilizado en su base de datos. Si se trata de un lenguaje estándar y bien especificado, es posible que pueda encontrar uno en Internet, pero si es algo interno, es posible que deba escribir el suyo propio (tal vez utilizando un generador de analizadores como ANTLR).

El paquete javax.script contiene algunas herramientas para integrar motores de secuencias de comandos externos como un intérprete de Javascript. Una idea alternativa sería traer un motor de secuencias de comandos y alimentar las expresiones a eso.

Answer 7

Para evaluar las condiciones con la máxima flexibilidad, use un lenguaje de secuencias de comandos diseñado para incrustar, por ejemplo, MVEL puede analizar y evaluar expresiones condicionales simples como las de la pregunta.

El uso de MVEL tiene una gran ventaja sobre el uso del motor de secuencias de comandos en Java 1.6+ (en particular, con JavaScript): con MVEL puede compilar los scripts a bytecode, lo que hace que su evaluación sea mucho más eficiente en tiempo de ejecución.

Answer 8

Una muy buena manera de hacer esto, aparte de usar Java 7, es usar enumeraciones. Declare enum como se muestra abajo

La enumeración anterior tiene una colección de constantes cuyos valores se establecen en las cadenas que espera que se devuelvan desde la base de datos. Como puede usar enumeraciones en los casos de cambio, el código restante se vuelve fácil

enum MyEnum
{
    val1("value < 4"),val2("4<value<6");
    private String value;

    private MyEnum(String value)
    {
        this.value = value;
    }
}


public static void chooseStrategy(MyEnum enumVal)
{   
    int value = getValue();
    switch(enumVal)
    {
        case val1:
        if(value > 2){}
        break;
        case val2:
        if(4 < value && value < 6) {}
        break;
        default:
    }
}

public static void main(String[] args)
{
    String str = "4<value<6";
    chooseStrategy(MyEnum.valueOf(str));
}

Todo lo que tiene que hacer es pasar su cadena al método enum.valueof y devolverá la enumeración adecuada que se coloca en un bloque de mayúsculas y minúsculas para realizar la operación condicional. En el código anterior puede pasar cualquier cadena en lugar de lo que se pasa en este ejemplo