validacion - validar formulario javascript onclick

¿Cómo verificar si el número de llaves abiertas es igual al número de llaves abiertas?

Question

¿Cómo verificar si la cantidad de llaves abiertas es igual a la cantidad de llaves cerradas que usan expresiones regulares?

Aquí está el código:

var expression1 = "count(machineId)+count(toolId)";
var expression2 = "count(machineId)+count(toolId))";

Estas son las 2 expresiones, donde en la expression1 , el número de corchetes abiertos es igual al número de corchetes y en expression2 , el número de corchetes abiertos no es igual al número de corchetes. Necesito una expresión regular que cuente la cantidad de paréntesis abiertos y los corchetes cerrados y me dé la alerta. Necesito verificar la sintaxis válida también.

if(expression1.......){ // here goes the regular expression
    alert("Matched");
}
else{
    alert("Not matched");
}

Answer 1

1. "Necesito hacer coincidir el no de llaves abiertas igual a no de llaves cerradas usando expresiones regulares"

2. "También necesito verificar la sintaxis válida".

Si 2 es verdadero, entonces 1 también es verdadero. Por lo tanto, busque coincidencias para lo que sabe que es una sintaxis válida, en este caso: {} . Ejecute un bucle que elimine todas las coincidencias válidas de la "pila" hasta que no queden coincidencias válidas. Si lo que queda al final no es nada, entonces significa que su argumento es 100% válido. Si lo que queda al final es algo , significa que los "restos" no pasaron su prueba de validez y, por lo tanto, no son válidos:

var foo = function(str) {
    while(str.match(/{}/g))           // loop while matches of "{}" are found
        str = str.replace(/{}/g, ''''); // "slices" matches out of the "stack"
    return !str.match(/({|})/g);      // `false` if invalids remain, otherwise `true`
};

foo(''{{{}}}''); // true
foo(''{{}}}}}}}}}}{}''); // false

Answer 2

Aquí hay otra manera de hacerlo:

function validParenNesting(text) {
    var re = //([^()]*/)/g; // Match innermost matching pair.
    // Strip out matching pairs from the inside out.
    while (text.match(re))
        text = text.replace(re, '''');
    // If there are any parens left then no good
    if (text.match(/[()]/))
        return false;
    // Otherwise all parens part of matching pair.
    return true;
}

Answer 3

La tarea se puede resolver de manera simple sin expresiones regulares, solo contar las llaves.

var a = ''count(machineId)+count())toolId)''
var braces = 0;
for (var i=0, len=a.length; i<len; ++i) {
   switch(a[i]) {
       case ''('' : 
          ++braces;
          break;
       case '')'' : 
           --braces;
           break;
   }
   if (braces < 0) {    
      alert(''error'');
      break;
   }
}

if (braces)
    alert(''error'');

Answer 4

Lo siguiente puede aplicarse para encontrar el número de paréntesis. Sin embargo, no usa RegExp y usa lógica simple.

var l = 0;
var r = 0;
//Count the number of brackets.
for(var i=0;i<str.length;i++){
  if(str[i]=="("){
    l++;
  }
  else if(str[i]==")"){
    r++;
  }
}
if(l==r){ //The number of opening and closing brackets are equal.
  doSomething();
}

Answer 5

Si solo te importa el conteo, ¿por qué no intentas algo como esto?

if(expression1.split(''('').length == expression1.split('')'').length) {
  alert(''matched'');
}

Answer 6

Si su objetivo es verificar si una expresión es válida (también significa que su subcadena que contiene solo corchetes forma una secuencia de corchetes correcta), las expresiones regulares no lo ayudarán.

Las expresiones regulares solo pueden manejar los llamados " lenguajes regulares " (aunque las expresiones regulares de JS pueden ser algo más poderosas que sus equivalentes teóricas, el precio de tal poder es una mayor complejidad) mientras que el lenguaje de las secuencias de corchetes correctas no es regular.

Vea esas slides ; pueden darle una idea de por qué las expresiones regulares no pueden reconocer la secuencia de corchetes correcta.

Sin embargo, el problema no es tan difícil. Solo debes mantener una pila y repasar tu cadena de izquierda a derecha. Cada vez que se encuentra con un soporte de apertura, lo empuja hacia la pila. Cuando se encuentra con un corchete de cierre, se abre el elemento superior de la pila y se comprueba si su tipo coincide con el de uno (sí, este algoritmo puede manejar corchetes de varios tipos). Al final solo debes verificar si la pila está vacía.

En caso de que no necesite manejar diferentes tipos de corchetes (solo tiene ''('' y '')'', por ejemplo, puede mantener una variable openBrackets (esencialmente, representaría el tamaño de la pila) y no dejar que se convierta negativo.

Answer 7

Tratar ...

function matchBraces(s) {
  return s.match(//(/g).length === s.match(//)/g).length;
}

... entonces, su código para las alertas sería el siguiente ...

if(matchBraces(expression1)) {
    alert("Matched");
} else {
   alert("Not matched");
}

Copia de trabajo: jsFiddle

Answer 8

if (expression1.match(//(/g).length === expression2.match(//)/g).length) {
    // is equal
}

Para que funcione con cadenas que no contengan llaves, puede utilizar la siguiente solución:

((expression1.match(//(/g) || []).length

Answer 9

var expression1 = "count(machineId)+count(toolId)";
var expression2 = "count(machineId)+count(toolId))";

if (matches(expression1)) {
    alert("Matched"); // Triggered!
}
else {
    alert("Not matched");
}

if (matches(expression2)) {
    alert("Matched");
}
else {
    alert("Not matched"); // Triggered!
}

function matches(str) {
    try {
        new Function(str);
        return true;
    }
    catch (e) {
        return !(e instanceof SyntaxError);
    }
}

Esto funciona porque la new Function() causará un error de sintaxis si su código es incorrecto. Capturar el error significa que puedes manejarlo de manera segura y hacer lo que quieras. Otra cosa buena es que no ejecuta el código, simplemente lo analiza. Básicamente, está aprovechando su tarea para el analizador del navegador.

No usa expresiones regulares, pero sí verifica si su código es válido. Por lo tanto, le dice si los paréntesis coinciden.