avpath - Prédicats

Les prédicats avpath vous permettent d’écrire des règles très spécifiques concernant les éléments que vous souhaitez sélectionner lors de la construction d’expressions. Les prédicats sont des filtres restreignant les éléments sélectionnés par emplacement. Il existe deux types possibles de prédicats : sur les objets et sur la position d’éléments.

Pour plus d’informations concernant l’emplacement, consultez avpath - Emplacement.

Prédicats sur des objets

Les prédicats sur les objets peuvent être utilisés dans une expression de chemin afin de filtrer un sous-ensemble d’éléments en se basant sur les expressions booléennes fonctionnant sur les propriétés de chaque élément. Les prédicats sur les objets sont inscrits dans des accolades.

Les expressions simples dans les prédicats sur l’objet :

littéraux numériques (par exemple 1.23)
littéraux de chaînes de caractères (par exemple "John Gold")
littéraux booléens (true/false)
sous-chemins (par exemple : nestedProp.deeplyNestedProp)

avpath vous permet d’utiliser les types suivants d’opérateurs dans les expressions de prédicat :

opérateurs de comparaison
opérateurs de comparaison de chaînes de caractères
opérateurs logiques
opérateurs arithmétiques

opérateurs de comparaison
Opérateur	Description	Exemple
==	Retourne true si les deux arguments sont égaux	.customers{.id == "1"}
===	Retourne true si les deux arguments sont strictement égaux sans conversion de type	.customers{.id == "1"}
!=	Retourne true si les arguments ne sont pas égaux	.customers{.id == "1"}
!==	Retourne true si les arguments ne sont pas égaux et/ou que leur type n’est pas le même	.customers{.id == "1"}
>	Retourne true si l’argument de gauche est supérieur à l’argument de droite	.customers{.id == "1"}
>=	Retourne true si l’argument de gauche est supérieur ou égal à l’argument de droite	.customers{.id == "1"}
<	Retourne true si l’argument de gauche est inférieur à l’argument de droite	.customers{.id < 1}
<=	Retourne true si l’argument de gauche est inférieur ou égal à l’argument de droite	.customers{.id < 1}

Règles de comparaison :

si les deux arguments à comparer sont des tableaux, la comparaison est vraie (true) s’il y a un élément dans le premier tableau et un élément dans le second tableau, de sorte que le résultat de la comparaison des deux éléments retourne true
si un argument est un tableau et l’autre n’en est pas un, alors la comparaison sera vraie (true) si un élément est dans un tableau, de sorte que le résultat de la comparaison de l’élément et d’un autre argument retourne true
les primitives seront comparées comme des primitives Javascript

Si les deux arguments sont des chaînes de caractères, des opérateurs de comparaison supplémentaires sont disponibles :

opérateurs de comparaison de chaînes de caractères
Opérateur	Description	Exemple
==	Fonctionne comme == mais n’est pas sensible à la casse	.customers{.Lastname == "Von Celaeno"}
^==	Retourne true si la valeur de l’argument de gauche commence par la valeur de l’argument de droite	.customers{.Lastname ^== "Celaeno"}
^=	Fonctionne comme ^== mais n’est pas sensible à la casse	.customers{.Lastname ^= "celaeno"}
$==	Retourne true si la valeur de l’argument de gauche termine par la valeur de l’argument de droite	.customers{.Lastname $== "Von"}
$=	Fonctionne comme $== mais n’est pas sensible à la casse	.customers{.Lastname $== "Von"}
*==	Retourne true si la valeur de l’argument de gauche contient la valeur de l’argument de droite	.customers{.Lastname ^= "celaeno"}
*=	Fonctionne comme *== mais n’est pas sensible à la casse	.customers{.Lastname ^= "celaeno"}

Opérateurs logiques
Opérateur	Description	Exemple
&&	Retourne true si les deux arguments sont vrais (true)	.customers{.Revenue > 77000 && .customers.Lastname === "Von Celaeno"}
\|\|	Retourne true si un des deux arguments est vrai (true)	.customers{.Firstname === "Quentin" \|\| .State === "AZ"}
!	Rend l’argument négatif	.customers{!.Firstname}

Les opérateurs logiques convertissent leurs arguments en valeurs booléennes :

si l’argument est un tableau (le résultat de l’application du sous-chemin est également un tableau) :
- si la longueur du tableau est supérieure à zéro, le résultat sera true
- les autres résultats seront false
en appliquant une double négation (!!) à l’opérateur JavaScript à utiliser dans les autres cas.

Opérateurs arithmétiques
Opérateur	Description
+	addition
-	soustraction
*	multiplication
/	division
%	modulo

Priorité des opérateurs
Opérateur	Description
1 (la plus importante)	! -unary
2	* / %
3	+ -binary
4	>=
5	== === != !== ^= ^== $== $= = ==
6	&&
7	\|\|

Les parenthèses sont utilisées pour indiquer explicitement la priorité en regroupant les parties d’une expression devant être évaluées en premier.

Exemples :

// find the last name of the customer who lives in South Roosevelt Drive
avpath.select(doc, ".customers{.Address.Street === \"South Roosevelt Drive\"}.Lastname", schema)
// ['Novo']

// find all States where the customers revenue is less than 78000
avpath.select(doc, ".customers{.Revenue < 78000}.States", schema)
// ['AZ', 'CT']

Prédicats sur la position d'éléments dans un tableau

Les prédicats sur les positions vous permettent de filtrer les éléments selon leur position dans le contexte. Les prédicats sont toujours entre crochets.

Quatre formes sont disponibles :

[index] — retourne un élément positionné par rapport à l’index dans le contexte (le premier élément est à l’index 0), par exemple [3] retourne le quatrième élément dans le contexte
[index:] — retourne les éléments dont l’index en contexte est supérieur ou égal à l’index, par exemple [2:] retourne des éléments dont l’index en contexte est supérieur ou égal à 2
[:index] — retourne des éléments dont l’index en contexte est inférieur à l’index, par exemple [:5] retourne les cinq premiers éléments dans le contexte
[indexFrom:indexTo] — retourne des éléments dont l’index en contexte est supérieur ou égal à indexFrom et inférieur à indexTo, par exemple [2:5] retourne trois éléments avec des index 2, 3 et 4

Vous pouvez également utiliser des nombres négatifs de position :

[-1] — retourne le dernier élément dans le contexte
[-3:] — retourne les trois derniers éléments dans le contexte

Exemples :

// find first customer state
avpath.select(doc, ".customers[0].States")
// ['AZ']

// find last customer state
avpath.select(doc, ".customers[-1].States")
// ['CT']

// find two customer states from second position
avpath.select(doc, ".customers[1:3].States")
// ['NC', 'CT']

Prédicats clés de correspondance

Les prédicats clés vous permettent de filtrer les éléments selon leur clé, via des expressions régulières (regex). Les prédicats regex sont toujours inclus dans des ().

("key" | ~"key regex") — retourne les éléments dans le contexte (qui correspondent à l’expression régulière)

Plusieurs prédicats

Vous pouvez utiliser plusieurs prédicats. Le résultat contiendra uniquement les éléments correspondant à tous les prédicats

// find first customer name whose revenue less than 70000 and greater than 50000
avpath.select(doc, ".customers{.Revenue < 70000}{.Revenue > 50000}[0].Firstname")
// ['Quentin']

Cette page vous a-t-elle aidé ?

Si vous rencontrez des problèmes sur cette page ou dans son contenu – une faute de frappe, une étape manquante ou une erreur technique – dites-nous comment nous améliorer !

Laissez vos commentaires ici