Regex pour valider JSON

Question

Je cherche une Regex qui me permette de valider le json.

Je suis très novice en matière de Regex et je sais assez bien que l'analyse syntaxique avec Regex est mauvaise, mais peut-on l'utiliser pour valider ?

Answer 1

Oui, une validation regex complète est possible.

La plupart des implémentations modernes de regex permettent des regexpressions récursives, qui peuvent vérifier une structure sérialisée JSON complète. Le site Spécification de json.org rend les choses assez simples.

$pcre_regex = '
  /
  (?(DEFINE)
     (?<number>   -? (?= [1-9]|0(?!\d) ) \d+ (\.\d+)? ([eE] [+-]? \d+)? )    
     (?<boolean>   true | false | null )
     (?<string>    " ([^"\\\\]* | \\\\ ["\\\\bfnrt\/] | \\\\ u [0-9a-f]{4} )* " )
     (?<array>     \[  (?:  (?&json)  (?: , (?&json)  )*  )?  \s* \] )
     (?<pair>      \s* (?&string) \s* : (?&json)  )
     (?<object>    \{  (?:  (?&pair)  (?: , (?&pair)  )*  )?  \s* \} )
     (?<json>   \s* (?: (?&number) | (?&boolean) | (?&string) | (?&array) | (?&object) ) \s* )
  )
  \A (?&json) \Z
  /six   
';

Cela fonctionne très bien en PHP avec la fonction Fonctions PCRE . devrait fonctionner sans modification en Perl ; et peut certainement être adapté à d'autres langages. Il réussit également avec le Cas de test JSON .

Vérification simplifiée de la RFC4627

Une approche plus simple est le contrôle de cohérence minimal tel que spécifié dans le document RFC4627, section 6 . Il s'agit toutefois d'un test de sécurité et d'une précaution de base contre la non-validité :

  var my_JSON_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
         text.replace(/"(\\.|[^"\\])*"/g, ''))) &&
     eval('(' + text + ')');

Answer 2

Oui, c'est une erreur commune que les Expressions Régulières peuvent correspondre seulement à langues régulières . En effet, les fonctions PCRE peuvent correspondre à bien plus que des langages réguliers Ils peuvent même correspondre à certains langages sans contexte ! Article de Wikipedia sur les RegExps a une section spéciale à ce sujet.

JSON peut être reconnu par PCRE de plusieurs façons ! @mario a montré une excellente solution en utilisant des sous-modèles nommés et des modèles de type rétro-références . Il a ensuite fait remarquer qu'il devrait y avoir une solution utilisant motifs récursifs (?R) . Voici un exemple d'une telle regexp écrite en PHP :

$regexString = '"([^"\\\\]*|\\\\["\\\\bfnrt\/]|\\\\u[0-9a-f]{4})*"';
$regexNumber = '-?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?';
$regexBoolean= 'true|false|null'; // these are actually copied from Mario's answer
$regex = '/\A('.$regexString.'|'.$regexNumber.'|'.$regexBoolean.'|';    //string, number, boolean
$regex.= '\[(?:(?1)(?:,(?1))*)?\s*\]|'; //arrays
$regex.= '\{(?:\s*'.$regexString.'\s*:(?1)(?:,\s*'.$regexString.'\s*:(?1))*)?\s*\}';    //objects
$regex.= ')\Z/is';

J'utilise (?1) au lieu de (?R) car ce dernier fait référence à la tout le site mais nous avons \A et \Z les séquences qui ne doivent pas être utilisées à l'intérieur des sous-modèles. (?1) des références à l'expression rationnelle marquée par les parenthèses les plus extérieures (c'est la raison pour laquelle l'expression rationnelle la plus extérieure ( ) ne commence pas par ?: ). Ainsi, la RegExp devient longue de 268 caractères :)

/\A("([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"|-?(?=[1-9]|0(?!\d))\d+(\.\d+)?([eE][+-]?\d+)?|true|false|null|\[(?:(?1)(?:,(?1))*)?\s*\]|\{(?:\s*"([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"\s*:(?1)(?:,\s*"([^"\\]*|\\["\\bfnrt\/]|\\u[0-9a-f]{4})*"\s*:(?1))*)?\s*\})\Z/is

De toute façon, ceci doit être considéré comme une "démonstration technologique", et non comme une solution pratique. En PHP, je vais valider la chaîne JSON en appelant la fonction json_decode() (comme l'a noté @Epcylon). Si je dois utiliser ce JSON (s'il est validé), alors c'est la meilleure méthode.

Answer 3

En raison de la nature récursive de JSON (imbriqués {...} -s), regex n'est pas adapté pour le valider. Bien sûr, certaines formes de regex peuvent faire correspondre des motifs de manière récursive. * (et peut donc correspondre à JSON), mais les modèles résultants sont horribles à regarder, et ne devraient jamais être utilisés dans un code de production IMO !

* Attention toutefois, de nombreuses implémentations de regex font pas supportent les motifs récursifs. Parmi les langages de programmation les plus populaires, ceux-ci supportent les motifs récursifs : Perl, .NET, PHP et Ruby 1.9.2.

Answer 4

Vous ne pouvez pas utiliser une seule expression régulière pour décrire toutes les chaînes JSON valides. Comme JSON est un langage irrégulier en raison des objets {} et les tableaux [] qui peuvent être imbriqués arbitrairement, mais les expressions régulières classiques ne peuvent pas décrire de motifs récursifs (bien qu'il existe des implémentations modernes d'expressions régulières qui le peuvent). Il n'existe donc aucune expression régulière (classique) capable de décrire une chaîne JSON valide.

Mais vous pouvez utiliser une série d'expressions régulières pour vérifier si une chaîne est JSON. Voici un exemple utilisant Javascript :

// array or object
var re = [
    // is array or object
    /^\s*(?:\[.*]|\{.*\})\s*$/,
    // strings and numbers
    /"(?:[^"\\]|\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})*)"|-?(?:0|[1-9]\d*)(?:\.\d+)(?:[eE][+-]\d+)?/g,
    // "empty" arrays and objects without values like "[,,,]" and "{:,:,:,:}"
    /\s*(?:\[\s*(?:,\s*)*]|\{(?:\s*:\s*(?:,\s*:\s*)*)?})/g
];
var isArrayOrObject = re[0].test(str), tmp;
// remove strings and numbers
str = str.replace(re[1], "");
// remove "empty" arrays and objects
while ((tmp = str.replace(re[2], "")) !== str) {
    str = tmp;
}
alert(isArrayOrObject && /^\s*$/.test(str));

Cette fonction vérifie si la chaîne JSON est un tableau ou un objet. En supprimant les chaînes et les nombres, il ne reste que des tableaux "vides" et des objets sans valeur, qui peuvent ensuite être supprimés jusqu'à ce qu'il ne reste que des espaces :

1. {"foo":"bar", "baz":[0,2]}
2. {:, :[,]}
3. {:, :}
4. ε

Answer 5

Pour "chaînes et chiffres", je pense que l'expression régulière partielle pour les chiffres :

-?(?:0|[1-9]\d*)(?:\.\d+)(?:[eE][+-]\d+)?

devrait être à la place :

-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+\-]?\d+)?

puisque la partie décimale du nombre est facultative, et qu'il est probablement plus sûr d'échapper à l'élément - symbole dans [+-] puisqu'il a une signification particulière entre parenthèses