Les opérateurs Lambdas / Lambda operators : any
, all
, none
, count
, map
, where
, first
Les opérateurs Lambdas sont des expressions spécifiques au langage Blogger, qui permettent de traiter des tableaux en fonction de critères contenus dans ce tableau.
Prérequis !
La mise en œuvre des opérateurs Lambdas requiert une maitrise des autres opérateurs et une connaissance approfondie des types de données !
Syntaxe de base d'une expression lambda
Un Lambda a la particularité de piocher les items contenus dans un tableau sans avoir à recourir à l'usage d'une boucle avec la balise <b:loop>
.
Syntaxe
array operator var => expression
La première opérande est un tableau.
Entre les opérandes, vous mentionnez un opérateur. Au total, il y en a 7. Chacun renvoie un résultat spécifique. (Voir plus bas le chapitre Les syntaxes opérateurs).
La seconde opérande est le lambda
var => ...
. C'est dans cette opérande que les noms des données issues du tableau de la 1ère opérande doivent être intégrés. Souvent, cette opérande est encadrée de parenthèses pour une raison purement "esthétique". Dans sa syntaxe simplifiée, elles sont facultatives mais peuvent devenir obligatoires lorsque lorsqu'il faut définir des priorités.var
est un quelconque nom de variable. Il sera utilisé pour recomposer les données du tableau. Par exemple :var.item
.
En résumé, le lambda est une opération imbriquée qui permet d'inclure des éléments d'un tableau.
Exemple
data:posts map p => p.title
data:posts
est un tableau d'objets.map
est l'opérateur qui a pour fonction de recréer un tableau en fonction des critères injectés dans le lambda.p
est un quelconque nom de variable.title
est un item de type string contenu dans le tableaudata:posts
.
Dans cet exemple, le résultat de l'opération sera un nouveau tableau de type array[string] ne contenant que l'item data:posts[p].title
.
["title1","title2","title3"]
Les syntaxes des opérateurs lambdas
Noms | Opérateurs | Syntaxes | Opérandes | Résultat |
---|---|---|---|---|
Au moins 1 |
any |
Syntaxe par défaut array any var => boolean |
Nombre d'opérandes : 2 | Résultat : boolean |
Tout |
all |
Syntaxe par défaut array all var => boolean |
Nombre d'opérandes : 2 | Résultat : boolean |
Aucun |
none |
Syntaxe par défaut array none var => boolean |
Nombre d'opérandes : 2 | Résultat : boolean |
Compteur |
count |
Syntaxe par défaut array count var => boolean |
Nombre d'opérandes : 2 | Résultat : number |
Mappage |
map ou select |
Syntaxes par défaut array map var => criterion array select var => criterion |
Nombre d'opérandes : 2 | Résultat : array[criterion] |
Filtre |
filter ou where |
Syntaxes par défaut array filter var => boolean array where var => boolean |
Nombre d'opérandes : 2 | Résultat : array |
Premier |
first |
Syntaxe par défaut array first var => boolean |
Nombre d'opérandes : 2 | Résultat : Type enfant du tableau |
Les lambdas conditionnels : Any
, all
et any
Les opérateurs any
, all
et none
renvoient toujours une valeur boolean.
Le résultat de l'expression imbriquée dans le Lambda doit toujours être une valeur booléenne.
any
: Au moins un des sets du tableau correspond au critère.all
: Tous les sets du tableau correspondent au critère.none
: Inverse deall
.
any
- Au moins 1
<b:if cond='data:posts any (p => p.numComments gt 5)'> </b:if>
Le résultat de l'opération sera : true
si au moins l'un des posts du tableau contient plus de 5 commentaires.
all
- Tous
<b:if cond='data:posts all (p => p.numComments gt 5)'> </b:if>
Le résultat de l'opération sera : true
si tous les posts du tableau contiennent plus de 5 commentaires.
none
- Aucun
<b:if cond='data:posts none (p => p.numComments gt 5)'> </b:if>
Le résultat de l'opération sera : true
si aucun post du tableau ne contient plus de 5 commentaires.
Le compteur lambda : count
L'opérateur count
renvoie une valeur de type number.
Le résultat de l'expression imbriquée dans le Lambda doit toujours être boolean.
Le compteur renvoie le nombre de sets du tableau correspondant au critère.
count
<b:eval expr='data:posts count (p => p.numComments gt 5)'/>
Le résultat de l'opération sera le nombre de posts du tableau contenant plus de 5 commentaires.
Le lambda de mappage (ou de sélection) : map
et select
L'opérateur map
(ou select
) crée un nouvel array à partir d'un item contenu dans ce tableau ou à partir du résultat de l'expression imbriquée.
Le nouveau tableau sera du même type que le résultat de l'expression imbriquée :
- object devient array[object]
- string devient array[string]
- number devient array[number]
- boolean devient array[boolean]
- etc...
A partir d'une donnée
<b:loop values='data:posts map (p => p.numComments)' var='newArray'> <data:newArray/> </b:loop>
Le résultat de l'opération sera un tableau de type array[number], puisque le critère est une donnée de type number.
Le nouveau tableau contiendra un set de nombres. Dans ce cas-ci, les nombres de commentaires des posts.
A partir du résultat d'une expression
<b:loop values='data:posts map (p => p.numComments gt 5)' var='newArray'> <data:newArray/> </b:loop>
Le résultat de l'opération sera un tableau de type array[boolean], puisque le critère est une expression dont le résultat est boolean.
Le nouveau tableau contiendra un set de booléens. Dans ce cas-ci, une série de valeurs true
ou false
en fonction des posts contenant plus de 5 commentaires.
Les lambdas filtreurs : filter
, where
et first
Les opérateurs filter
(ou where
) et first
renvoient un nouvel array ne contenant les sets correspondants au critère.
where
oufilter
: Sélectionne tous les sets du tableau correspondants au critère.first
: Sélectionne uniquement le premier set du tableau correspondant au critère. Le type de résultat sera le type enfant du tableau.
where
<b:loop values='data:posts where (p => p.numComments gt 5)' var='post'> </b:loop>
Le tableau data:posts
ne contient que les posts ayant plus de 5 commentaires.
first
<b:with value='data:posts first (p => p.numComments gt 5)' var='post'> </b:with>
Le tableau data:posts
ne contient que le premier post ayant plus de 5 commentaires. Comme il ne contient qu'un seul set, la création d'une boucle n'est pas nécessaire.
Les tableaux imbriqués
Dans la bibliothèque des données Blogger, vous trouverez quelques tableaux imbriqués, comme par exemple, la liste hiérarchique dans le gadget Archive, ou encore les commentaires, les libellés, les pièces jointes des articles dans le gadget Blog, etc...
Dans ces cas, vous pouvez imbriquer un lambda dans un lambda.
Par exemple, les articles ayant ce libellé.
Le premier lambda peut contenir un opérateur quelconque (any
, all
, none
, count
, map
, where
ou first
), tandis que le second lambda doit impérativement contenir un opérateur conditionnel (any
, all
ou none
).
Condition - any
- Au moins 1
<b:if cond='data:posts any (p => p.labels any (l => l.name == "My photos"))'> </b:if>
Le résultat de l'opération sera : true
si au moins l'un des posts du tableau contient le libellé « My photos ».
Condition - all
- Tous
<b:if cond='data:posts all (p => p.labels any (l => l.name == "My photos"))'> </b:if>
Le résultat de l'opération sera : true
si tous les posts du tableau contiennent le libellé « My photos ».
Condition - none
- Aucun
<b:if cond='data:posts none (p => p.labels any (l => l.name == "My photos"))'> </b:if>
Le résultat de l'opération sera : true
si aucun post du tableau ne contient pas le libellé « My photos ».
Compteur - count
<b:eval expr='data:posts count (p => p.labels any (l => l.name == "My photos"))'/>
Le résultat de l'opération sera le nombre de posts du tableau contenant le libellé « My photos ».
Mappage - map
<b:loop values='data:posts map (p => p.labels any (l => l.name == "My photos"))' var='newArray'> <data:newArray/> </b:loop>
Le résultat de l'opération sera un tableau de type array[boolean], puisque le critère est la seconde opération lambda dont la valeur du résultat est de type boolean.
Le nouveau tableau contiendra un set de valeurs booléennes [true,false,true,false]
.
Filtre - where
<b:loop values='data:posts where (p => p.labels any (l => l.name == "My photos"))' var='post'> </b:loop>
Le tableau data:posts
ne contient que les posts ayant le libellé « My photos ».
Filtre - first
<b:with value='data:posts first (p => p.labels any (l => l.name == "My photos"))' var='post'> </b:with>
Le tableau data:posts
ne contient que le premier post ayant le libellé « My photos ».
Et si vous voulez afficher les libellés de ce post en économisant une boucle, vous pouvez écrire :
L'Astuce du boss
<b:loop values='(data:posts first (p => p.labels any (l => l.name == "My photos"))).labels' var='label'> <data:label.name/> </b:loop>
Les autres opérateurs
+ (concatenate)
+ (addition)
- (substraction)
* (multiplication)
/ (division)
% (modulus)?: (selector)
and (&&)
or (||)
not (!)eq (==)
neq (!=)
lt (<)
lte (<=)
gt (>)
gte (>=)appendParams
fragment
params
pathin
contains (array)contains (string)
format
limit / take
skip / offset
toresizeImage
sourceSetsnippet
any
all
none
count
map / select
filter / where
first