Latitude et longitude xml

Version imprimable

Bonjour,

j'ai développé cette méthode au niveau de mon service java pour vérifier la validité d'une coordonné (latitude ou longitude)

Je voulais savoir si je peux faire le test au niveau xml avant d'accepter les données. c-à-d l'équivalent de ce test au niveau xml.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 static  boolean isValidLatitudeLongitude(String s)
    {
        boolean valid = false;
        String regex_coords = "[+-]?\\d+\\.?\\d+";
        Pattern compiledPattern = Pattern.compile(regex_coords, Pattern.CASE_INSENSITIVE);
        Matcher matcher = compiledPattern.matcher(s);
        System.out.println("Matchers: " + matcher);
        while (matcher.find()) {
            if(matcher.group().equals(s)){
                valid = true;
            }
            else{
                valid = false;
            }           
        }
 
        return valid;
    }

Merci d'avance

12/09/2018, 13h27
psychadelic

rien compris,
tu parles de service Java et on voit du code JavaScript.

Et si c'est ce code que tu veux tester, vu que c'est une fonction tu n'a qu'a faire tes tests localement sur n'importe quel navigateur....:roll:
13/09/2018, 06h21
CosmoKnacki
Citation:

Envoyé par cheyma

Je voulais savoir si je peux faire le test au niveau xml avant d'accepter les données. c-à-d l'équivalent de ce test au niveau xml.

Oui c'est possible en utilisant XML Schema qui permet de décrire précisément un document XML et notamment de contrôler les types de valeurs et les domaines de validité.

À noter que ta fonction comporte des erreurs:
- Tu utilises une boucle while et la méthode find() pour ensuite tester si la correspondance trouvée est égale à ta chaîne. C'est farfelu. Pour tester une chaîne de bout en bout, il suffit d'utiliser la méthode matches(), et là, plus besoin de boucle, ni même de if...else puisque cette méthode renvoie un booléen.
- Ta pattern est fausse car \\d+\\.?\\d+ ne peut pas matcher un entier d'un seul chiffre (tu peux donc dire adieu à Greenwich). Pour rendre le point optionnel sans qu'il se retrouve en fin de chaîne, tu peux utiliser un groupe: \\d+(?:\\.\\d+)?.
- L'option Pattern.CASE_INSENSITIVE n'est pas utile, il n'y a pas de lettres dans ta pattern.
Fait donc des essais avec XML Schema et si tu as des problèmes, oriente toi plutôt vers cette section du forum.

Bonjour,

Merci pour votre interaction :)

* Tu utilises une boucle while et la méthode find() pour ensuite tester si la correspondance trouvée est égale à ta chaîne. C'est farfelu. Pour tester une chaîne de bout en bout, il suffit d'utiliser la méthode matches(), et là, plus besoin de boucle, ni même de if...else puisque cette méthode renvoie un booléen.

--> je l'ai fait ex-prêt, parce-que et si j'ai bien compris que matcher.find() va me retourner une latitude valide à chaque fois qu'elle fait le découpage du texte en entré et élimine la partie invalide.
[exemple si la valeur 2.abc687 le retour est 2.687] du coupe j'ai fait un test en comparant [2.abc678 et 2.687 ] dans ce cas mon input est invalide.

* Donc j'élimine Pattern.CASE_INSENSITIVE et je corrige \\d+(?:\\.\\d+)? pour accepter rendre le point optionnel
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 static boolean isValidLatitudeLongitude(String s) { boolean valid = false; String regex_coords = "[+-]?\\d+(?:\\.\\d+)?"; Pattern compiledPattern = Pattern.compile(regex_coords); Matcher matcher = compiledPattern.matcher(s); while (matcher.find()) { if(matcher.group().equals(s)){ valid = true; } else{ valid = false; } } return valid; }

13/09/2018, 13h22
CosmoKnacki
Citation:

Envoyé par cheyma

--> je l'ai fait ex-prêt, parce-que et si j'ai bien compris que matcher.find() va me retourner une latitude valide à chaque fois qu'elle fait le découpage du texte en entré et élimine la partie invalide.
[exemple si la valeur 2.abc687 le retour est 2.687] du coupe j'ai fait un test en comparant [2.abc678 et 2.687 ] dans ce cas mon input est invalide.

find() cherche si quelque part une sous chaîne vérifie la pattern, puis cherche la sous-chaîne suivante, etc. Donc dans le cas de 2.abc678, find() va trouver 2 au premier tour de boucle, puis 678 au deuxième, en aucun cas le retour ne saurait être 2.687 (le point n'a jamais été trouvé et quand bien même find() ne recolle pas les morceaux tout seul comme un grand!).

Ta fonction est une fonction de validation qui renvoie soit true soit false, son rôle n'est pas de filtrer l'entrée ou de chercher si quelque part dans la chaîne il y a quelque chose qui pourrait ressembler à ce que devrait être l'entrée. Soit l'entrée est correcte, soit elle ne l'est pas. De plus, vu que tu testes si la correspondance est égale à la chaîne en entrée avec if(matcher.group().equals(s)), cela revient strictement à utiliser la fonction matches(), en d'autres termes, cela revient à tester si la pattern décrit bien l'intégralité de la chaîne.

Concrètement:
Code:

1 2 3 static boolean isValidLatitudeLongitude(String s) { return Pattern.matches("[+-]?\\d+(?:\\.\\d+)?", s); }
produit exactement le même résultat.
13/09/2018, 16h48
NoSmoking
Bonjour,
j'aurais deux petites questions :
- la vérification doit se faire à quel moment, lecture/écriture fichier XML, réception donnée du client ...
- ne manquerait-il pas la vérification des bornes, ± 180 et/ou ± 90, pour que cela soit complet ?
13/09/2018, 18h14
CosmoKnacki
Citation:
Envoyé par NoSmoking

ne manquerait-il pas la vérification des bornes, ± 180 et/ou ± 90, pour que cela soit complet ?
Effectivement le domaine de validité n'est pas contrôlé, il faudrait soit faire deux fonctions (une pour la latitude, une pour la longitude) ou plutôt faire une seule fonction plus générale qui permette de passer un minimum et un maximum en paramètre.

Bonsoir

Oui pour tester les intervalles de latitude et longitude :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
static boolean isValidLatitudeLongitude(String s)
 
   {
 
      return Pattern.matches("[+-]?\\d+(?:\\.\\d+)?", s);
 
   }
 
 
 
   static boolean latitudeInInterval(String s)
 
   {
 
 
 
      if (s.charAt(0) == '-' || s.charAt(0) == '+')
 
      {
 
         s = s.substring(1);
 
      }
 
      Float lat = Float.parseFloat(s);
 
      return (lat < 90);
 
   }
 
 
 
   static boolean longitudeInInterval(String s)
 
   {
 
 
 
      if (s.charAt(0) == '-' || s.charAt(0) == '+')
 
      {
 
         s = s.substring(1);
 
      }
 
      Float lat = Float.parseFloat(s);
 
      return (lat < 180);
 
   }

Sauf que il manque le contrôle de nombre d'occurrence des signes.
Le cas de : ++1.54 n'est pas contrôlé

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
static boolean isValidLatitudeLongitude(String s)
 
   {
     if (s.lastIndexOf('-')=0 || s.lastIndexOf('-') = 0) return Pattern.matches("[+-]?\\d+(?:\\.\\d+)?", s);
       return false
 
   }
 
 
 
   static boolean latitudeInInterval(String s)
 
   {
 
 
 
      if (s.charAt(0) == '-' || s.charAt(0) == '+')
 
      {
 
         s = s.substring(1);
 
      }
 
      Float lat = Float.parseFloat(s);
 
      return (lat < 90);
 
   }
 
 
 
   static boolean longitudeInInterval(String s)
 
   {
 
 
 
      if (s.charAt(0) == '-' || s.charAt(0) == '+')
 
      {
 
         s = s.substring(1);
 
      }
 
      Float lat = Float.parseFloat(s);
 
      return (lat < 180);
 
   }