Populaire cette année
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.
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
Un Lambda a la particularité de piocher les items contenus dans un tableau sans avoir a créer une boucle avec la balise<b:loop>
.Syntaxe
array operator (var => expression)
Exemple
data:posts map (p => p.title)
Syntaxes opérateurs
Noms | Opérateurs | Opérandes | Syntaxe par défaut | Résultat |
---|---|---|---|---|
Au moins 1 | any |
2 | array any (var => boolean) |
boolean |
Tout | all |
array all (var => boolean) |
||
Aucun | none |
array none (var => boolean) |
||
Compteur | count |
array count (var => boolean) |
number | |
Map | map |
array map (var => criterion) |
array[criterion] | |
select |
array select (var => criterion) |
|||
Filtre | filter |
array filter (var => boolean) |
array | |
where |
array where (var => boolean) |
|||
Premier | first |
array first (var => boolean) |
Child type of the array |
Les opérateurs conditionnels
Les opérateursany
, 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 l'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>
all - Tous
<b:if cond='data:posts all (p => p.numComments gt 5)'> </b:if>
none - Aucun
<b:if cond='data:posts none (p => p.numComments gt 5)'> </b:if>
Le compteur
L'opérateurcount
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)'/>
L'opérateur de sélection
L'opérateurmap
(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>
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>
Les opérateurs filtres
Les opérateursfilter
(ou where
) et first
renvoient un nouvel array ne contenant les sets correspondants au critère.where / filter
: 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>
first
<b:with value='data:posts first (p => p.numComments gt 5)' var='post'> </b:with>
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
/first
), tandis que le second lambda doit impérativement contenir un opérateur conditionnel (any
/all
/none
).Condition - any - Au moins 1
<b:if cond='data:posts any (p => p.labels any (l => l.name == "My photos"))'> </b:if>
Condition - all - Tous
<b:if cond='data:posts all (p => p.labels any (l => l.name == "My photos"))'> </b:if>
Condition - none - Aucun
<b:if cond='data:posts none (p => p.labels any (l => l.name == "My photos"))'> </b:if>
Compteur - count
<b:eval expr='data:posts count (p => p.labels any (l => l.name == "My photos"))'/>
Sélection - map
<b:loop values='data:posts map (p => p.labels any (l => l.name == "My photos"))' var='newArray'> <data:newArray/> </b:loop>
Filtre - where
<b:loop values='data:posts where (p => p.labels any (l => l.name == "My photos"))' var='post'> </b:loop>
Filtre - first
<b:with value='data:posts first (p => p.labels any (l => l.name == "My photos"))' var='post'> </b:with>
Exercices
Afin de vous familiariser avec les opérateurs Lambdas, nous avons créé un petit gadget contenant un tableau avec les Présidents Américains des années 70's à nos jours.Schéma du tableau
"data": { "presidents": [{ "name": string, "startTerm": number, "endTerm": number, "party": string, }] }
Ajoutez le gadget sur votre blog expérimental et exercez-vous à créer des opérations ou à modifier les exemples.
Les autres opérateurs
+ (concatenate)
+ (addition)
- (substraction)
* (multiplication)
/ (division)
% (modulus)
?: (selector)
all
and (&&)
any
appendParams
contains (array)
contains (string)
count
eq (==)
filter
first
format
fragment
gt (>)
gte (>=)
in
limit
lt (<)
lte (<=)
map
neq (!=)
none
not (!)
offset
or (||)
params
path
resizeImage
select
Skip
snippet
sourceSet
take
to
where