Les opérateurs de comparaison

De la balance au booléen

Comparer fait partie des besoins humains les plus anciens. Bien avant l’invention des chiffres, les chasseurs-cueilleurs savaient distinguer qui avait plus de bêtes, plus de fruits ou plus d’armes. Les premières civilisations ont formalisé cette intuition à l’aide de balances et de bâtons gradués : autant d’outils pour vérifier l’égalité ou constater une différence. Les Égyptiens, par exemple, utilisaient déjà des signes hiéroglyphiques pour exprimer des rapports de grandeur.

Chez les Grecs, les mathématiques ont poussé cette logique plus loin. Euclide a défini les proportions et les rapports entre grandeurs, tandis qu’Aristote posait les bases d’une logique où une proposition est soit vraie, soit fausse. Cette idée simple allait devenir, bien des siècles plus tard, la clé de tout raisonnement booléen.

Au Moyen Âge, les savants arabes comme Al-Khwarizmi ont donné naissance à l’algèbre, rendant les comparaisons manipulables sous forme de symboles et d’équations (x < y, x = y). Puis, à l’époque moderne, Leibniz a pressenti que toute logique pouvait se réduire à des 0 et des 1. Au XIXᵉ siècle, George Boole formalisa cette intuition en créant la logique booléenne, où chaque comparaison conduit à un résultat binaire : vrai ou faux.

Avec l’informatique, ces concepts sont devenus des opérateurs standards : ==, !=, <, <=, >, >=. Sur Blogger, on retrouve cette même tradition : les opérateurs de comparaison permettent de tester des valeurs (nombres, chaînes, booléens) et de décider de l’affichage d’un bloc, d’une condition ou d’un style, toujours sur la base d’un résultat booléen (true ou false).

Les syntaxes d'écriture

Les opérateurs de comparaison peuvent s’écrire de deux façons. La syntaxe infixe est la plus naturelle : l’opérateur est placé entre deux valeurs (a == b). La syntaxe fonctionnelle, moins courante, place l’opérateur avant les valeurs entre parenthèses (==(a, b)). Les deux sont équivalentes et produisent le même résultat.

Ce principe n’est pas propre à Blogger : la syntaxe infixe est la même qu’en JavaScript, Python ou PHP (a == b), tandis que la syntaxe fonctionnelle rappelle les appels de fonction classiques (eq(a, b)).

allType == allType

allType eq allType

==(allType,allType)

eq(allType,allType)

allType != allType

allType neq allType

!=(allType,allType)

neq(allType,allType)

number < number

number lt number

<(number,number)

lt(number,number)

number <= number

number lte number

<=(number,number)

lte(number,number)

number >= number

number gte number

>=(number,number)

gte(number,number)

number > number

number gt number

>(number,number)

gt(number,number)

Utilisations et règles

• Les opérateurs de comparaison renvoient toujours une valeur booléenne (true ou false).

• Les règles dépendent du type des opérandes :

  • Nombre : peut être comparé avec un autre nombre pour tous les opérateurs (==, !=, <, >, <=, >=).

  • Chaîne : peut uniquement être comparée avec une autre chaîne via l’égalité ou l’inégalité (==, !=). Les opérateurs < et > ne prennent pas en charge la comparaison lexicographique.

  • Booléen : ne peut être comparé qu’avec un autre booléen par égalité/inégalité.

  • Tableaux : peuvent être comparés entre eux par égalité/inégalité, à condition que les deux soient du même type et de même taille.

  • Objets et tableaux d’objets : toute comparaison renvoie null.

• Les opérandes peuvent être :

  • Une valeur explicite (ex. "Photos", 10, true)

  • Une donnée Blogger (ex. data:view.type)

  • Le résultat d’une autre expression (comparaison imbriquée).

• Une opération de comparaison peut être imbriquée dans une autre opération qui attend un résultat booléen (opérateurs logiques, ternaires, lambdas, etc.).

Les opérateurs

Quelques exemples

Égalité

<b:if cond='data:view.search.label == data:blog.pageName'>

</b:if>

inégalité

<b:if cond='data:view.type != "item"'>

</b:if>

Inférieur ou égal à

<b:if cond='data:posts.size lte 10'>

</b:if>

Imbrication dans une opération Lambda

<b:eval expr='data:posts count (p => p.date.year eq 2025)'/>

Imbrication dans une opération ternaire

<b:eval expr='data:view.search.label == "Photos"
    ? "Vous êtes dans la catégorie Photos"
    : "Vous n'êtes pas dans la catégorie Photos"'/>

Imbrication dans une opération logique

<b:if cond='data:view.description.size gte 150
            and data:view.isPage'>

</b:if>

Conditions en cascade

<b:if cond='data:posts any (p => p.date.year lt 2000)'>
  <p>Articles anciens (avant 2000)</p>
<b:elseif cond='data:posts any (p => p.date.year lt 2010)'/>
  <p>Articles de la décennie 2000</p>
<b:elseif cond='data:posts any (p => p.date.year lt 2020)'/>
  <p>Articles de la décennie 2010</p>
<b:else/>
  <p>Articles récents (2020 et plus)</p>
</b:if>

Afficher une liste séparée par des virgules

<b:loop index='i' values='data:items' var='item'>
  <data:item.name/>
  <b:if cond='(data:i + 1) lt data:items.size'>,</b:if>
</b:loop>

Quiz récapitulatif