Javascript Regex aide pour débutant

Question

Je dois valider la gamme ci-dessous via regex en javascript.

-20,00 à +20,00 avec un incrément de 0,5.

L'utilisateur devrait pouvoir entrer le 1.50 au lieu de +01.50.

J'ai essayé de faire beaucoup de recherches sur google, même si regex n'est pas facile. Si je comprends bien, alors je vais devoir diviser l'expression rationnelle en plus petits groupes. Du point de vue des programmeurs, je pense, que je dois valider chaque "char" qui a été saisi dans le champ de saisie. Si je comprends comment fonctionne le regroupement dans la regex alors je suppose que je pourrais faire l'expression régulière moi-même. Alors, s'il vous plaît aidez-moi à comprendre regex le problème ci-dessus, ne jetez pas l'expression rationnelle dans :)

Merci,

Answer 1

Après devrait le faire

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) «$» 

Answer 2

Peut-être le plus simple moyen de vérifier que vous avez 2 numéros valides flottent numéros (regex est bon mais aussi parseFloat pourrait être utilisé) et lors de l'enregistrement à la dernière étape programmaticly que ces chiffres sont dans l'intervalle [-20,0 à 20,0]

Answer 3

le regex que vous voulez est:

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

Cela se décompose 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 
) 

Notez cela permettrait le cas d'angle impair de « -00,00 »

Answer 4

Il ne fait pas vraiment de sens d'utiliser une expression régulière pour valider une valeur numérique.

Essayez:

function checkRange(input) { 
    var value = parseFloat(input); 
    return (!isNaN(value) && (value >= -20) && (value <= 20) && (value % 0.5 == 0)); 
} 

Answer 5

Cela devrait être fait en deux étapes. La première étape consiste à utiliser une expression régulière pour s'assurer que la valeur entrée est textuellement valide (c'est-à-dire qu'elle a x nombre de nombres décimaux, un signe, etc.) Ensuite, convertissez-la en valeur pour vous assurer qu'elle est logiquement valide.

Alors tout d'abord, vous voudrez peut-être une expression régulière comme ceci:

/^[+-]?\d{1,2}\.(00|50)$/ 

Il:

• Assurez-vous que la chaîne en option commence par + ou -.
• Suivi d'un ou deux chiffres.
• Suivie d'un point.
• Suivi par 00 ou 50

Après cela, vous pouvez vous assurer qu'il est dans la gamme de -20 à 20:

var floatValue = Number(value); 
if (floatValue < -20 || floatValue > 20) { 
    // Invalid! 
} 

Answer 6

Comme mentionné précédemment, les plages sont mieux adaptées en utilisant des nombres, mais utilisez regexes pour vous assurer que le format après la décimale est correct.

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") 
} 

Answer 7

Le regex devrait fonctionner:

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

Explication:

^        # 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