Populaire
ThéorieRéférences XMLOpérateurs

Les opérateurs Lambdas [any/all/none/count/map/where/first]

Les opérateurs Lambdas [any/all/none/count/map/where/first]
Les opérateurs Lambdas permettent de traiter des tableaux.


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 définir un quelconque nom de variable qui peut être employé à des items d'un tableau sans avoir a créer 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 chapitre syntaxes opérateurs.
La seconde opérande est le lambda (var => ...). C'est dans cet opérande que les noms des données issues du tableau de la 1ère opérande doivent être intégrés. var est un quelconque nom de variable. Il sera utilisé pour recomposer les données du tableau : 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.
p est un quelconque nom de variable.
title est un item de type string contenu dans le tableau data: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"]





Syntaxes opérateurs

Classification/Appellation Nom Syntaxe Résultat
Condition Au moins 1 any array any (var => boolean) boolean
Tout all array all (var => boolean) boolean
Aucun none array none (var => boolean) boolean
Compteur count array count (var => boolean) number
Sélection map
select
array map (var => allType) array
Filtre where
filter
array where (var => boolean) array
Premier first array first (var => boolean) array


Les opérateurs conditionnels

Les opérateurs any, all et none renvoient toujours une valeur booléenne.
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 : Aucun set du tableau ne correspond au critère.

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

L'opérateur count renvoie une valeur de type number.
Le résultat de l'expression imbriquée dans le Lambda doit toujours être une valeur booléenne.
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.


L'opérateur de sélection

L'opérateur map (ou select) crée un nouveau tableau à 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 :
  • string devient array[string]
  • number devient array[number]
  • boolean devient array[boolean]
  • object devient array[object]

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 opérateurs filtres

Les opérateurs filter (ou where) et first renvoient un nouveau tableau ne contenant les sets correspondants au critère.
  • where / filter : Tous les sets du tableau correspondants au critère.
  • first : Uniquement le premier set du tableau correspondant au critère.

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:loop values='data:posts first (p => p.numComments gt 5)' var='post'>

</b:loop>
Le tableau data:posts ne contient que le premier post ayant plus de 5 commentaires.


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>
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".

Sélection - 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:loop values='data:posts first (p => p.labels any (l => l.name == "My photos"))' var='post'>

</b:loop>
Le tableau data:posts ne contient que le premier post ayant le libellé "My photos".
Dernière modification :
Assistance publique pour le produit Blogger sur les Forums d'aides :

Certifiée par Google - Experte TC :
  • Affectation Google France, produit Blogger, du 11/07/2011 au 28/07/2014.
  • Affectation Google US, produit Blogger depuis le 28/07/2014.

Posts les plus consultés de ce blog

DéveloppementsMulti-versions
Facebook : Bouton J'aime [Like button]
Populaire
ThéorieRéférences XMLParamètres des données
Le paramètre Image redimensionnable [isResizable]
Populaire
DéveloppementsFichiers XML
Résumés des articles avec images réactives [Pack 2016]
Populaire
DéveloppementsFichiers XML
Populaire