Necesito validar el siguiente rango a través de regex en javascript.

-20.00 a +20.00 con un incremento de 0.5.

El usuario también debería poder ingresar 1.50 en lugar de +01.50.

Traté de investigar mucho en google, aunque regex no es fácil. Si lo entiendo correctamente, tendré que dividir la expresión regular en grupos más pequeños. Desde el punto de vista de los programadores, creo que necesito validar cada "char" que se ingresó en el campo de entrada. Si entiendo cómo funciona la agrupación en expresiones regulares, entonces creo que podría hacer la expresión regular yo mismo. Así que, por favor, ayúdame a comprender la expresión regular con el problema anterior, no solo la regex :)

Gracias

1
vikasde 5 ago. 2009 a las 16:09

6 respuestas

La mejor respuesta

Lo siguiente debería hacerlo

var myregexp = /^[+-]?(20\.00|[01?][0-9]\.[05]0)$/m;
if (subject.match(myregexp)) {
    // Successful match
} else {
    // Match attempt failed
}

// ^[+-]?(20\.00|[01?][0-9]\.[05]0)$
// 
// Options: ^ and $ match at line breaks
// 
// Assert position at the beginning of a line (at beginning of the string or after a line break character) «^»
// Match a single character present in the list below «[+-]?»
//    Between zero and one times, as many times as possible, giving back as needed (greedy) «?»
//    The character “+” «+»
//    The character “-” «-»
// Match the regular expression below and capture its match into backreference number 1 «(20\.00|[01?][0-9]\.[05]0)»
//    Match either the regular expression below (attempting the next alternative only if this one fails) «20\.00»
//       Match the characters “20” literally «20»
//       Match the character “.” literally «\.»
//       Match the characters “00” literally «00»
//    Or match regular expression number 2 below (the entire group fails if this one fails to match) «[01?][0-9]\.[05]0»
//       Match a single character present in the list “01?” «[01?]»
//       Match a single character in the range between “0” and “9” «[0-9]»
//       Match the character “.” literally «\.»
//       Match a single character present in the list “05” «[05]»
//       Match the character “0” literally «0»
// Assert position at the end of a line (at the end of the string or before a line break character) «$»
1
Lieven Keersmaekers 5 ago. 2009 a las 12:59

La expresión regular que desea es:

/[-+]?([01]?[0-9](\.[05]0?)?|(20(\.00?)?)/

Esto se descompone en:

[-+]?  : an optional - or +
( 
 [01]?  : an optional 0 or
 [0-9]  : number 0-9
 (...)? : Optional
  \.    : .
  [05]  : 0 or 5
  0?    : Optional 0

  |      : OR

  20     : numbers 20
  (...)? : Optional
   \.    : .
   00?   : O or OO
)

Tenga en cuenta que esto permitiría el caso de esquina impar de "-00.00"

0
Callum 5 ago. 2009 a las 12:42

Como se mencionó, los rangos se combinan mejor usando números, pero use expresiones regulares para asegurarse de que el formato después del decimal sea correcto.

var value = ... // eg. "-20.05"
var number = parseFloat(value);
if (number >= -20 && number <= 20 && /[+-]?\d+\.[05]0/.test(value)) {
   alert("in range")
} else {
   alert("out of range")
}
0
Ben Lings 5 ago. 2009 a las 12:28

Puede ser la forma más simple de verificar que tiene 2 números flotantes de números válidos (regex es bueno pero también podría usarse parseFloat) y, en el último paso, verifique programáticamente que estos números estén en el rango [-20.0 - 20.0]

0
Dewfy 5 ago. 2009 a las 12:18

Realmente no tiene sentido usar una expresión regular para validar un valor numérico.

Tratar:

function checkRange(input) {
    var value = parseFloat(input);
    return (!isNaN(value) && (value >= -20) && (value <= 20) && (value % 0.5 == 0));
}
3
NickFitz 5 ago. 2009 a las 12:26

La siguiente expresión regular debería funcionar:

^[+-]?(?:20\.?0{0,2}?|[01]?[0-9]\.?[05]?0?)$

Explicación:

^                             # anchor the match at the start of the string
   [+-]?                      # optional sign
   (?:                        # non-capturing group for alternation:
      20\.?0{0,2}?            # match either 20 (optionally followed by . or .0 or .00)
   |                          # or
      [01]?[0-9]\.?[05]?0?    # match 00-19 (optionally followed by . or .0 or .5 or .50 or .00)
   )                          # end of alternation
$                             # anchor the match at the end of the string
0
Tim Pietzcker 5 ago. 2009 a las 12:34