Avec nombres decimaux et opérateur

Version imprimable

26/03/2012, 18h17
ireolax

Avec nombres decimaux et opérateur

Bonjour,

Mon expression :

Code:

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.
26/03/2012, 18h36
SpaceFrog

un truc du genre

Code:

^\d+(\.\d+)([+*/-]\d+(\.\d+))*$
26/03/2012, 19h12
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.:?
26/03/2012, 20h00
SpaceFrog

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

Code:

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

Citation:

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:

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:roll:):

Code:

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;
               }
            }

26/03/2012, 20h44
SpaceFrog

var regx = /^\d+((\.(?=\d)\d*)?([+*/-](?=\d)(\d+(\.(?=\d)\d*)?)?))?/;
26/03/2012, 20h51
ireolax

Code:

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

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

6.3+....:aie:
27/03/2012, 11h09
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:

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:

\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:

[-+*/](\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:

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

Ce qui donne au final :

Code:

^((\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:

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

;)
27/03/2012, 13h39
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:

^\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 ?
02/04/2012, 18h29
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:

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:

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

Concrètement :

Code:

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

Et avec les espaces :

Code:

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

;)
04/04/2012, 12h29
ireolax

Merci Beaucoup Mr Watilin ! :ccool::zoubi::D

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 !