Discussion :

[Nicolas_LesPaul]

Bonsoir à tous,
J'ai une question très bateau, mais je préfère demander l'avis de gens qui maîtrisent le sujet avant de faire n'importe quoi.
J'ai besoin de parser ce fichier JSON: http://drive.google.com/open?id=1hCa...rN8mqky71JLMJP

On me demande
1) de parser tous les identifiants uniques du type "SV350".

Le regex que je suggère est: "[A-Z]{2}[1-9]{3}":{
Qu'en pensez-vous s'il vous plaît ?

2) de parser tous les identifiants uniques du type "SV350" en ajoutant la condition "land":"ESP".
La solution que je propose est: (?(?="land":"ESP")"[A-Z]{2}[1-9]{3}":{)
Qu'en pensez-vous s'il vous plaît ? Je ne parviens pas à comprendre comment faire en sorte que ce soit le bon identifiant qui soit sorti et pas l'identifiant suivant par exemple.

Merci d'avance pour votre aide,
Nicolas.

[grunk]

Tu compte pas parser le json comme une chaine de caractère a coup de regex quand même ?

Code :

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

$datas = json_decode($chainejson,true);

Va te donner un tableau de toutes les données que tu peux ensuite facilement parcourir pour appliquer le traitement que tu veux.

http://php.net/manual/fr/function.json-decode.php

[Nicolas_LesPaul]

Hello grunk,
Merci pour ton retour.

On me demande pas d'introduire du php dans cette histoire, à vrai dire on ne me demande pas le livrable final seulement le regex.
Voilà les consignes exactes: https://drive.google.com/drive/folde...MHyB21lPgdudWl
Il s'agit du 2.2

Merci d'avance,
Nicolas.

[Celira]

On me demande
1) de parser tous les identifiants uniques du type "SV350".

Le regex que je suggère est: "[A-Z]{2}[1-9]{3}":{
Qu'en pensez-vous s'il vous plaît ?

Si aucune autre chaine n'a le même format dans ton json, ça devrait fonctionner. (sauf que les chiffres commencent à 0, pas à 1 )

2) de parser tous les identifiants uniques du type "SV350" en ajoutant la condition "land":"ESP".
La solution que je propose est: (?(?="land":"ESP")"[A-Z]{2}[1-9]{3}":{)
Qu'en pensez-vous s'il vous plaît ? Je ne parviens pas à comprendre comment faire en sorte que ce soit le bon identifiant qui soit sorti et pas l'identifiant suivant par exemple.

Hum... là ça dépasse mes maigres compétences en regex.

[grunk]

Pour la première OK , je supprimerais la partie ":{" pour pas être embété avec d’éventuels espace qui pourraient être (ou non) présents.

Pour la seconde comme Celira , je sais pas faire.

Ceci étant dit c'est stupide de faire ce genre d'exercice sur du json , qui est un formatage justement pensé pour ne pas avoir à faire ça puisque largement intégré dans plein de langage.

Pour tes tests de regex , tu peux utiliser https://regex101.com/ , très pratique !

[Nicolas_LesPaul]

Bonjour à tous,
Merci pour vos retours !

Pour le 1) on est d'accord que les parenthèses sont facultatives ?

Pour le 2) il s'agit d'une syntaxe conditionnelle respectant le pcre ?

Merci encore,
Nicolas.

[Nicolas_LesPaul]

Merci pour ton retour, cela dit inutile de monter sur tes grands chevaux.
Si tu ne souhaites pas me répondre pour une raison x ou y, éh bien ne me réponds pas...
J'ai pris soin de lire ton message avec attention, je n'y ai pas trouvé d'explication justifiant la nécessaire utilisation de parenthèses.

Tiens, intéresse-toi à la notion de nexus savoir-pouvoir théorisée par Michel Foucault et mets ça en parallèle avec l'enseignement socratique sur les liens entre le savoir, l'intelligence et l'humilité.

[Celira]

Pour autant que je sache, les parenthèses servent à capturer un groupe de façon pouvoir l'extraire ou le remplacer. Donc si le but est uniquement de vérifier si l'expression est valide, les parenthèses ne sont pas nécessaires.

[CosmoKnacki]

Je ne sais pas trop comment prendre "Please check it[']s structure first": S'agit-il de vérifier en premier lieu si la chaîne est bien du JSON? Dans ce cas, tu peux utiliser cette pattern:

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
19
20
21
$json = file_get_contents('sample.json');
$pattern = <<<'EOD'
~
(?(DEFINE)
    (?<number> -?(?:[1-9][0-9]*(?:\.[0-9]+)?|0(?:\.[0-9]+)?)(?:[eE][-+]?[0-9]+)? )
    (?<null> null )
    (?<boolean> true | false )
    (?<string> " [^"\\]*+ (?:\\.[^"\\]*)*+ " )
 
    (?<list> \[ \s* (?: \g<value> (?: \s* , \s* \g<value> )*+ )?+ \s* ] )
    (?<object> { \s* (?: \g<keyval> (?: \s* , \s* \g<keyval> )*+ )?+ \s* } )
 
    (?<value> \g<number> | \g<null> | \g<boolean> | \g<string> | \g<list> | \g<object> )
    (?<keyval> \g<string> \s* : \s* \g<value> )
)
 
\A \g<object> $
 
~x
EOD;
var_dump(preg_match($pattern, $json)); // int(1)

Remarques à propos de ce code:

• Cette pattern est en deux parties: la première partie (?(DEFINE) ... ) définie les différents éléments à l'aide de groupes nommés ainsi que leurs rapports entre eux: un groupe peut se définir par rapport à un autre groupe voire à lui même, ce qui éventuellement implique une structure récursive (comme l'est le JSON). Cette première partie sert juste à nommer les choses et à établir des rapports entre elles, mais concrètement c'est une sous-pattern vide, elle ne matche rien (zero-width assertion) et n'impose rien non plus comme le ferait un test avant (lookahead) ou arrière (lookbehind) ou encore une ancre (^, $, \A, \z).
  La seconde partie \A \g<object> $ est la pattern comme on l'entend communément, c-à-d la description de la chaîne en elle-même, et ce, même si elle fait référence aux éléments précédemment définis.
• Comme pcre est un moteur à backtracking et afin de limiter celui-ci (le backtracking), nombre de quantificateurs sont passés en "possessif" (?+, *+, ++). Ceci dit, l'impact de cette mesure reste à nuancer puisque une des particularités de pcre (contrairement à Perl) est de rendre atomique tout appel à une sous-pattern. Concrètement, si je fais un appel à, disons, \g<number> et que celui-ci réussi, il ne sera plus possible d'effectuer un backtracking sur les caractères consommés par \g<number> si la sous pattern suivante échoue, sauf à éliminer l'appel en question d'un seul bloc.
• J'utilise l'ancre $ au lieu de l'ancre \z car elle est plus permissive (celle-ci réussit dans deux cas: soit à la fin de la chaîne, soit juste avant le dernier caractère de la chaîne quand celui-ci est un \n, alors que \z matche strictement la fin de la chaîne). Or il se trouve que ton fichier json se termine par un \n juste après la dernière accolade fermante. On aurait aussi pu écrire \A \g<object> \n? \z ou encore \A \g<object> \s* \z.
• La pattern est écrite pour décrire un format JSON de la manière la plus laxe possible, c'est à dire qu'elle autorise entre chaque token un nombre quelconque de caractères blancs. C'est pourquoi les sous-patterns sont parsemées de \s*. Mais dans ton cas, il semblerait que tous ces espaces blancs inutiles ne sont pas présents. Donc tu peux éventuellement enlever tous ces \s*. À toi de voir.
• Pour écrire cette pattern en php, j'ai utilisé la syntaxe NOWDOC. Bien entendu, si je devais l'écrire entre quotes simples ou doubles, je devrais remplacer tous les \\ par \\\\. Maintenant je n'ai aucune idée du format attendu pour ton exercice, mais d'instinct j'utiliserai celui de la syntaxe NOWDOC.

Pour obtenir toutes les clefs, il suffit de remplacer la pattern principale:

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
19
20
21
22
23
24
25
26
27
28
$pattern = <<<'EOD'
~
(?(DEFINE)
    (?<number> -?(?:[1-9][0-9]*(?:\.[0-9]+)?|0(?:\.[0-9]+)?)(?:[eE][-+]?[0-9]+)? )
    (?<null> null )
    (?<boolean> true | false )
    (?<string> " [^"\\]*+ (?:\\.[^"\\]*)*+ " )
 
    (?<list> \[ \s* (?: \g<value> (?: \s* , \s* \g<value> )*+ )?+ \s* ] )
    (?<object> { \s* (?: \g<keyval> (?: \s* , \s* \g<keyval> )*+ )?+ \s* } )
 
    (?<value> \g<number> | \g<null> | \g<boolean> | \g<string> | \g<list> | \g<object> )
    (?<keyval> \g<string> \s* : \s* \g<value> )
)
(?:
    \G(?!\A) : \g<object> ,
  |
    \A
    { "objekte" :
        {
            (?: \g<keyval> (?: \s* , \s* \g<keyval>)*? , "objekte" : | "objekte" : ) {
)
" (?<ID> [^"\\]*+ (?:\\.["\\]*)*+ ) "
~x
EOD;
if ( preg_match_all($pattern, $json, $matches) ) {
    print_r($matches['ID']);
}

Il s'agit là d'une structure classique utilisant l'ancre \G qui matche la position qui suit une correspondance réussie: (?: \G(?!\A) (?# préfixe des correspondances suivantes )| (?# prefixe de la première correspondance ) ) (?# ce que l'on veut ). Cette structure permet de rechercher des correspondances contiguës.

Ensuite reste à filtrer, toutes les annonces qui ne sont pas localisées en Espagne. Pour réussir cela, il suffit de consommer toutes les annonces des autres pays avant en prenant le soin de placer l'ensemble des annonces non-voulues dans un groupe auquel on applique un quantificateur possessif pour ne pas subir le backtracking.

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
$pattern = <<<'EOD'
~
(?(DEFINE)
    (?<number> -?(?:[1-9][0-9]*(?:\.[0-9]+)?|0(?:\.[0-9]+)?)(?:[eE][-+]?[0-9]+)? )
    (?<null> null )
    (?<boolean> true | false )
    (?<string> " [^"\\]*+ (?:\\.[^"\\]*)*+ " )
 
    (?<list> \[ \s* (?: \g<value> (?: \s* , \s* \g<value> )*+ )?+ \s* ] )
    (?<object> { \s* (?: \g<keyval> (?: \s* , \s* \g<keyval> )*+ )?+ \s* } )
 
    (?<value> \g<number> | \g<null> | \g<boolean> | \g<string> | \g<list> | \g<object> )
    (?<keyval> \g<string> \s* : \s* \g<value> )
)
(?:
    \G(?!\A) : \g<object> ,
  |
    \A
    { "objekte" :
        {
            (?: \g<keyval> (?: \s* , \s* \g<keyval>)*? , "objekte" : | "objekte" : ) {
)
(?:
    \g<string> : {
    (?: \g<keyval> (?: \s*, \g<keyval> )*? , "land" : | "land" : ) (?!"ESP") \g<value>
    (?: , \g<keyval> )* } ,
 
)*+
" (?<ID> [^"\\]*+ (?:\\.["\\]*)*+ ) "
~x
EOD;
if ( preg_match_all($pattern, $json, $matches) ) {
    print_r($matches['ID']);
}

ps: inutile de t'acharner à tester ces codes sur des testeurs en ligne car la chaîne est trop longue et les patterns trop complexes. Ceci dit, je rejoins Grunk en ce qui concerne l'intérêt pédagogique de s'entraîner aux regex sur des données structurées comme le JSON ou le html, alors que dans la vrai vie, il y a des parsers prévus à cet effet. (Je mettrai d'ailleurs au passage, dans le même sac les exemples de poo illustrés par des bagnoles avec options).