Les opérateurs Lambdas / Lambda operators : `any`, `all`, `none`, `count`, `map`, `where`, `first`

Extrait de la documentation personnelle de Soraya Lambrechts – 13/04/2016

Blogger - Opérateurs Lambdas / Lambda operators

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

Exemple de résultat

["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 de all.

`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 ou 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>

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>

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


  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.

<b:includable id='main'>
<b:comment>data dictionary definition</b:comment>
<b:with value='[ { name: "Gerald Ford", startTerm: 1974, endTerm: 1977, party: "Republican" }, { name: "Jimmy Carter", startTerm: 1977, endTerm: 1981, party: "Democratic" }, { name: "Ronald Reagan", startTerm: 1981, endTerm: 1989, party: "Republican" }, { name: "George H. W. Bush", startTerm: 1989, endTerm: 1993, party: "Republican" }, { name: "Bill Clinton", startTerm: 1993, endTerm: 2001, party: "Democratic" }, { name: "George W. Bush", startTerm: 2001, endTerm: 2009, party: "Republican" }, { name: "Barack Obama", startTerm: 2009, endTerm: 2017, party: "Democratic" }, { name: "Donald Trump", startTerm: 2017, party: "Republican" }]' var='presidents'>

<h3>Liste des présidents</h3>
  <div class='widget-content'>
    <ul>

<b:loop values='data:presidents' var='president'>

</b:loop>

</ul>
  </div>

<ul>
      <li>Des présidents ont été élus après l'an 2000 ? <b:eval expr='data:presidents any (p => p.startTerm gt 2000)'/></li>
      <li>Des présidents ont été élus entre 1990 et 2000 ? <b:eval expr='data:presidents any (p => p.startTerm gte 1990 and p.startTerm lte 2000)'/></li>
    </ul>

</div>

<ul>
      <li>Tous les présidents sont Républicains ? <b:eval expr='data:presidents all (p => p.party == "Republican")'/></li>
      <li>Tous les présidents ont terminé leur mandat ? <b:eval expr='data:presidents all (p => p.endTerm)'/></li>
      <li>Les présidents ne sont pas Démocrate ou Républicain ? <b:eval expr='data:presidents none (p => p.party in ["Republican", "Democratic"])'/></li>
    </ul>

</div>

<h3>Count</h3>
  <div class='widget-content'>

<ul>
      <li>Nombre de présidents élus après 1990 : <b:eval expr='data:presidents count (p => p.startTerm gt 1990)'/></li>
      <li>Nombre de présidents "Bush" : <b:eval expr='data:presidents count (p => p.name contains "Bush")'/></li>
      <li>Nombre de présidents Démocrates entre 1974 et 2011 : <b:eval expr='data:presidents count (p => p.party == "Democratic" and p.startTerm gte 1974 and p.startTerm lte 2011)'/></li>
    </ul>

</div>

<ul>
      <li>Début des mandats :
        <ul>
          <b:loop values='data:presidents map (p => p.startTerm)' var='president'>
            <li><data:president/></li>
          </b:loop>
        </ul>
      </li>
      <li>Sont Républicains :
        <ul>
          <b:loop values='data:presidents map (p => p.party == "Republican")' var='president'>
            <li><data:president/></li>
          </b:loop>
        </ul>
      </li>
    </ul>

</div>

<h3>Filter</h3>
  <div class='widget-content'>

<ul>
      <li>Les présidents Républicains :
        <ul>
          <b:loop values='data:presidents filter (p => p.party == "Republican")' var='president'>
            <li><data:president.name/></li>
          </b:loop>
        </ul>
      </li>
      <li>Présidents élus entre 1980 et 2000 :
        <ul>
          <b:loop values='data:presidents filter (p => p.startTerm gte 1980 and p.startTerm lte 2000)' var='president'>
            <li><data:president.name/></li>
          </b:loop>
        </ul>
      </li>
    </ul>

</div>

<h3>First</h3>
  <div class='widget-content'>

<ul>
      <li>Premier président Démocrate élu après 1981 :
        <b:eval expr='(data:presidents first (p => p.party == "Democratic" and p.startTerm gte 1981)).name'/>
      </li>
      <li>Président en fonction pendant la naissance de Blogger :
        <b:eval expr='(data:presidents first (p => p.endTerm gte 1999)).name'/>
      </li>
      <li>Parti du président Jimmy Carter :
        <b:eval expr='(data:presidents first (p => p.name == "Jimmy Carter")).party'/>
      </li>
      <li>Président actuellement en fonction :
        <b:eval expr='(data:presidents first (p => not p.endTerm)).name'/>
      </li>
      <li>Fin de mandat du président Gerald Ford :
        <b:eval expr='(data:presidents first (p => p.name == "Gerald Ford")).endTerm'/>
      </li>
      <li>Mandats exercés par le président Ronald Reagan :
        <b:with value='data:presidents first (p => p.name == "Ronald Reagan")' var='president'>
          <b:eval expr='(data:president.endTerm - data:president.startTerm) / 4'/>
        </b:with>
      </li>

</ul>

</div>

</b:with>
</b:includable>

Les autres opérateurs

+ (concatenate)
+ (addition) - (substraction) * (multiplication) / (division) % (modulus)
?: (selector)
and (&&) or (||) not (!)
eq (==) neq (!=) lt (<) lte (<=) gt (>) gte (>=)
appendParams fragment params path
in contains (array)
contains (string)
format
limit / take skip / offset to
resizeImage sourceSet
snippet
any all none count map / select filter / where first

Retourner à l'introduction

Licence - La reproduction du contenu de ce blog n'est pas autorisée

Aucune disposition des Conditions d'Utilisation de ce blog ne pourra être interprétée comme conférant à l'Utilisateur une licence sur les Droits de Propriété Intellectuelle.

Le blog Blogger Code PE ne concède qu'une autorisation de visualisation de son contenu à titre personnel et privé. Les copies ou reproductions doivent être strictement réservées à l'usage privé du copiste.

Toute reproduction abusive, totale ou partielle du blog Blogger Code PE, représentation, modification, publication, traduction, adaptation totale ou partielle de l'un quelconque de ces éléments, accompagnée ou non d'un lien de référence, quel que soit le moyen ou le procédé utilisé, est interdite et sera considérée comme constitutive d’une contrefaçon et passible de poursuite (Les peines prévues à cet effet sont une condamnation de 3 ans d'emprisonnement et une amende de 300.000€) conformément aux dispositions des articles L.335-2 et suivants du Code de Propriété Intellectuelle.

Notifications d'infraction à la loi DMCA en relation avec le contenu de ce document et déposées par les représentants agréés du blog Blogger Code PE :

CLAIM #1 CLAIM #2

Soraya Lambrechts

Affiliée au Google Product Experts Program - Ambassador & Troubleshooter.

Affectation Google France, produit Blogger, du 11/07/2011 au 28/07/2014.
Affectation Google US, produit Blogger depuis le 28/07/2014.

Spécialisation : Technologie des thèmes Blogger.

Auteur originel de la théorie du langage XML Blogger : Règles syntaxiques, directives d'usage, classifications, compilations et corrélations des composants.
Cela représente près de 10 années de travail. Je remercie tous ceux qui ont respecté ma propriété intellectuelle et j'offre mes meilleurs sentiments aux nombreux contributeurs (Amis, Utilisateurs, Experts Produits Google, Blogger Team et Ingénieurs).

Les opérateurs Lambdas / Lambda operators : `any`, `all`, `none`, `count`, `map`, `where`, `first`

Syntaxe de base d'une expression lambda

Syntaxe

Exemple

Les syntaxes des opérateurs lambdas

Les lambdas conditionnels : `Any`, `all` et `any`

`any` - Au moins 1

`all` - Tous

`none` - Aucun

Le compteur lambda : `count`

`count`

Le lambda de mappage (ou de sélection) : `map` et `select`

A partir d'une donnée

A partir du résultat d'une expression

Les lambdas filtreurs : `filter`, `where` et `first`

`where`

`first`

Les tableaux imbriqués

Condition - `any` - Au moins 1

Condition - `all` - Tous

Condition - `none` - Aucun

Compteur - `count`

Mappage - `map`

Filtre - `where`

Filtre - `first`

L'Astuce du boss

Exercices

Schéma du tableau

Les autres opérateurs

Licence - La reproduction du contenu de ce blog n'est pas autorisée

Spotlight

L'Éditeur XML de Thème Blogger : Quand le BackEnd Rencontre le FrontEnd

Populaires cette semaine

Foire aux questions Blogger (Novembre 2021)

Les libellés des articles

`locked` : L'attribut de verrouillage du gadget

Outils de sauvegarde et suppression du blog

`data:posts[i].comments[i].inReplyTo` (Blog)

Les opérateurs Lambdas / Lambda operators : any, all, none, count, map, where, first

Syntaxe de base d'une expression lambda

Syntaxe

Exemple

Les syntaxes des opérateurs lambdas

Les lambdas conditionnels : Any, all et any

any - Au moins 1

all - Tous

none - Aucun

Le compteur lambda : count

count

Le lambda de mappage (ou de sélection) : map et select

A partir d'une donnée

A partir du résultat d'une expression

Les lambdas filtreurs : filter, where et first

where

first

Les tableaux imbriqués

Condition - any - Au moins 1

Condition - all - Tous

Condition - none - Aucun

Compteur - count

Mappage - map

Filtre - where

Filtre - first

L'Astuce du boss

Exercices

Schéma du tableau

Les autres opérateurs

Licence - La reproduction du contenu de ce blog n'est pas autorisée

Spotlight

L'Éditeur XML de Thème Blogger : Quand le BackEnd Rencontre le FrontEnd

Populaires cette semaine

Foire aux questions Blogger (Novembre 2021)

Les libellés des articles

locked : L'attribut de verrouillage du gadget

Outils de sauvegarde et suppression du blog

data:posts[i].comments[i].inReplyTo (Blog)

Les opérateurs Lambdas / Lambda operators : `any`, `all`, `none`, `count`, `map`, `where`, `first`

Les lambdas conditionnels : `Any`, `all` et `any`

`any` - Au moins 1

`all` - Tous

`none` - Aucun

Le compteur lambda : `count`

`count`

Le lambda de mappage (ou de sélection) : `map` et `select`

Les lambdas filtreurs : `filter`, `where` et `first`

`where`

`first`

Condition - `any` - Au moins 1

Condition - `all` - Tous

Condition - `none` - Aucun

Compteur - `count`

Mappage - `map`

Filtre - `where`

Filtre - `first`

`locked` : L'attribut de verrouillage du gadget

`data:posts[i].comments[i].inReplyTo` (Blog)