Discussion :

[ireolax]

Bonjour,

Mon expression :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var reg2 = new RegExp("^[0-9]+([.]?[0-9]+)*[/*+-]?([0-9]*[.]?[0-9]*)?[0-9]*$");

Pour le moment cette expression fonctionne pas trop mal sauf dans les cas ou :

Exemple : 3.3.
Exemple : 3.3+.

Je voudrais que cet éventuel 2eme point ne soit autorisé qu'après l'opérateur et un chiffre.

Exemple: 3.3*3.3

Merci pour vos réponses.

[SpaceFrog]

un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^\d+(\.\d+)([+*/-]\d+(\.\d+))*$

[ireolax]

Oui, sauf que la vérification se fait sur le cumul à chaque nouvelle saisie d'un caractère.
3 -> vérification
3. -> vérification
3.3 -> vérification
3.3* -> vérification...
Donc tout doit être optionnel en fait, enfin je crois.

[SpaceFrog]

sauf que pour moi ça ne doit pas valider lorsque la chaine se termine par un . ou un operateur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^\d+((\.(?>\d)\d*)?([+*/-](?>\d)(\d+(\.(?>\d)\d*)?)?))?

[ireolax]

sauf que pour moi ça ne doit pas valider lorsque la chaine se termine par un . ou un operateur

Oui, mais ça c'est testé seulement si j’appuie sur la touche = avec un autre schéma.

Sinon pour ton expression ça me dit 'invald quantifier'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var regx = new RegExp("^\\d+((\\.(?>\\d)\\d*)?([+*/-](?>\\d)(\\d+(\\.(?>\\d)\\d*)?)?))?");

la partie de mon code qui traite la saisie (si ça peut t'aider à m'aider):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var reg1 = new RegExp("[^<C=][0-9]?[./*+-]?");
            var reg2 = new RegExp("^[0-9]+([.]?[0-9]+)?[/*+-]?[0-9]*([0-9]*[.]?[0-9]*)?[0-9]*$");
            var regtest = new RegExp("^\\d+((\\.(?>\\d)\\d*)?([+*/-](?>\\d)(\\d+(\\.(?>\\d)\\d*)?)?))?");
            var saisieCumule="";
            function checkEnter(enter){
               if(reg1.test(enter)){
                   saisieCumule += enter;
                   if(regtest.test(saisieCumule)){
                       return true;
 
                   }else{
                       saisieCumule = saisieCumule.slice(0, -1);
                       return false;
                   }
               }else{
                   return false;
               }
            }

[SpaceFrog]

var regx = /^\d+((\.(?=\d)\d*)?([+*/-](?=\d)(\d+(\.(?=\d)\d*)?)?))?/;

[ireolax]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var regtest = new RegExp("^\\d+((\\.(?=\\d)\\d*)?([+*/-](?=\\d)(\\d+(\\.(?=\\d)\\d*)?)?))?");

Malheureusement, ça m'autorise ce genre de saisie :

6.3+....

[Watilin]

Salut !

Il suffit de procéder avec un peu de méthode. Il y a un schéma classique pour les chaînes item-séparateur-item, qui colle exactement avec ta forme nombre-opérateur-nombre :

Code pseudo regex :

Sélectionner tout - Visualiser dans une fenêtre à part

nombre (opérateur nombre)*

Reprenant la 1re proposition de Spaffy, je pense que \d+(\.\d+)? est suffisant pour les nombres, et [-+*/] pour les opérateurs.
Concrètement, ça donne :

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

\d+(\.\d+)?([-+*/]\d+(\.\d+)?)*

Ceci permet déjà de reconnaître les chaînes complètes. Ensuite, quand l'utilisateur est en train de taper, il faut imaginer que la chaîne est composée de deux parties : une partie complète et une partie incomplète. Il suffit d'ancrer la partie complète au début de la chaîne (^) et la partie incomplète à la fin ($) pour éviter de reconnaître une partie trop courte de la chaîne.
Pour la partie incomplète, on sait qu'elle devra commencer par un opérateur, car la partie complète finit forcément par un nombre. Et pour les parties optionnelles, le secret est de les imbriquer de droite à gauche ! On utilise rarement cette méthode car ça peut produire des regex monstrueuses, mais heureusement ce n'est pas le cas ici.

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

[-+*/](\d+(\.\d*)?)?

Il reste à traiter le cas où l'utilisateur commence tout juste à taper : c'est une chaîne incomplète, mais qui ne commence pas par un opérateur. Dans l'état actuel des choses, elle n'est pas reconnue par notre regex. Le plus simple est de faire une alternative :

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

^((... gros morceau ...)|(\d+(\.\d*)?))$

Ce qui donne au final :

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

^((\d+(\.\d+)?([-+*/]\d+(\.\d+)?)*[-+*/](\d+(.\d*)?)?)|(\d+(.\d*)?))$

Après, je ne sais pas toi, mais pour ma part la tolérance aux espaces c'est bien agréable, alors voilà.

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

^\s*((\d+(\.\d+)?(\s*[-+*/]\s*\d+(\.\d+)?)*\s*[-+*/]\s*(\d+(.\d*)?)?)|(\d+(.\d*)?))\s*$

[ireolax]

Bonjour et merci pour cette explication très bien détaillée !

L'expression que tu me proposes fonctionne à merveille, sauf qu'elle autorise la saisi de plusieurs opérateurs, ce que je n'avais peut être pas précisé est que je voudrais qu'il y est qu'un seul opérateur possible.

Ex: 3.6+2.8...ensuite d'éventuelle chiffres c'est tout.

Débutant en dév et en particulier avec les expressions régulières, une question de débutant me taraude :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

^\d+(\.\d+)?

Ce morceau de schéma, dit bien que la chaine testé:
1- ^\d+ devra commencer obligatoirement par un chiffre de 0 à 9.
2- (\.\d+)? et pourra éventuellement être suivi d'un point qui sera lui même obligatoirement suivi d'un chiffre...enfin c'est ce que je comprends.
Mais pourquoi quand je test ce simple schéma, je peux saisir plusieurs point d'affilés, alors qu'il doit obligatoirement être suivi d'un chiffre ?

[Watilin]

Ça c'est parce que tu n'as pas mis de $ à la fin, autrement dit tu n'as pas précisé que la chaîne entière devait être testée.
Ta regex peut être lue comme ceci : « La chaîne doit commencer par un ou plusieurs chiffres, puis il y a une partie optionnelle ».
Par exemple, si tu tapes 5.., le 5 est reconnu, et .. ne correspond pas à la partie optionnelle. Le test s'arrête donc sur une chaîne qui commence par un chiffre, ce qui est positif !
De manière générale, toute chaîne commençant par un chiffre est positive, par exemple 5xfjz.

Pour ce qui est des opérateurs… Ça change tout ! Comme il n'y a plus de partie répétitive, la regex devient beaucoup, beaucoup plus simple*!

La structure à respecter du coup c'est ça :

Code pseudo regex :

Sélectionner tout - Visualiser dans une fenêtre à part

nombre opérateur nombre

où un nombre sera reconnu par \d+(\.\d*)?.

Pour autoriser les saisies incomplètes, on va simplement imbriquer les parties de droite à gauche comme je t'ai montré l'autre fois. Sans oublier les ancres.

Code pseudo regex :

Sélectionner tout - Visualiser dans une fenêtre à part

^nombre (opérateur (nombre)?)?$

Concrètement :

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

^\d+(\.\d*)?([-+*/](\d+(\.\d*)?)?)?$

Et avec les espaces :

Code regex :

Sélectionner tout - Visualiser dans une fenêtre à part

^\s*\d+(\.\d*)?(\s*[-+*/]\s*(\d+(\.\d*)?)?)?\s*$

[ireolax]

Merci Beaucoup Mr Watilin !

Ca fonctionne plutôt bien, même si j'ai pas encore tout à fait, tout saisi, mais ça va venir... les ancres surtout !
En tout cas super explication !