Peut-on trier les tableaux de nombres ?

Blogger - XML operators - sort array[number]

Notre cher ami Toto revient sur Blogger Code PE avec un nouveau casse-tête dans les poches et un soupçon de désespoir dans les yeux. Cette fois-ci, il cherche à trier une liste de nombres… sans sortir du langage XML de Blogger.

Pas de JavaScript, pas d’aide extérieure. Juste lui, un tableau, et une bonne vieille balise <b:loop>.

Est-ce qu’un tel tri est même possible, alors que Blogger ne propose aucun opérateur de tri comme sort() ou orderBy() ?

Spoiler : oui, mais c’est un peu tordu. Et c’est ce qui le rend intéressant.

On vous embarque dans cette mini-aventure logique à la sauce Blogger Code PE : une méthode élégante, 100% native XML, qui contourne l’impossible en simulant l’ordre croissant… sans jamais trier pour de vrai.

Le problème posé

Avant de plonger dans le vif du code, il faut comprendre une chose essentielle :

  • Blogger ne propose aucun opérateur pour trier une liste.

Dans d’autres langages, on aurait utilisé quelque chose comme array.sort() ou sortBy(p => p.value). Mais ici, rien de tout ça. Ni sort, ni order, ni même groupBy. Le langage XML de Blogger est volontairement minimaliste, et l’équipe n’a jamais mis à disposition un opérateur de tri natif.

Ce n’est pas un oubli. C’est un choix d’ingénierie.

Pourtant, Blogger offre plusieurs opérateurs puissants, en particulier ceux issus des lambdas. On peut filtrer (where), compter (count), vérifier des conditions (any, all, none)… mais pas réorganiser les éléments d’un tableau.

Conclusion : si l’on veut trier quelque chose, il va falloir ruser. Et c’est exactement ce qu’on va faire.

L’astuce

Si l’on ne peut pas trier une liste, on peut au moins simuler un ordre.

Et pour ça, Blogger nous offre un outil inattendu :

  • L’opérateur to, qui permet de générer une suite de nombres, de min à max (ou inversement).

Ensuite, il suffit d’afficher uniquement les valeurs présentes dans notre liste initiale, en les testant une à une. Pour ça, on combine to avec un opérateur lambda comme any :

  • Est-ce que le nombre courant est présent dans ma liste ? Si oui, je l’affiche.

C’est une approche simple, presque naïve, mais redoutablement efficace tant que :

  • les bornes sont connues (minimum et maximum),

  • la liste n’est pas trop longue,

  • et que vous êtes prêt à perdre un peu de performance pour gagner en élégance XML.

On appelle ça un tri par inclusion simulée. Et si vous n’avez jamais entendu ce terme, c’est normal. On vient de l’inventer. 😎

Exemple de tri avec une liste statique

Prenons un exemple simple.

On veut trier la liste suivante : [25, 31, 5, 18, 13, 4, 3]

Voici comment on peut l’afficher en ordre croissant grâce à la méthode vue plus haut :

Le code
<ul>
  <b:with value='[25, 31, 5, 18, 13, 4, 3]' var='numbers'>
    <b:loop values='0 to 35' var='sort'>

      <b:if cond='data:numbers any (n => n == data:sort)'>
        <li><data:sort/></li>
      </b:if>

    </b:loop>
  </b:with>
</ul>

Ce que fait ce code :

  • La balise <b:loop> génère une suite de nombres de 0 à 35.

  • À chaque tour, on vérifie si ce nombre (data:sort) est présent dans le tableau numbers.

  • S’il y est, on l’affiche dans un <li>.

Le résultat produit sera
3
4
5
13
18
25
31

Magie Blogger : les doublons sont ignorés automatiquement, puisqu’on parcourt chaque valeur une seule fois. Et pour inverser l’ordre ? Facile : on remplace 0 to 35 par 35 to 0.

Bien sûr, cette astuce fonctionne aussi avec un tableau récupéré dynamiquement, du moment qu’on connaît ses bornes min et max. On verra ça juste après avec un exemple plus “bloggerien”.

Exemple avec les articles du blog

Passons à un cas concret très utile dans un thème Blogger :

  • trier les articles selon leur nombre de libellés.

Pourquoi ce critère ? Parce que :

  1. le nombre de libellés est facilement accessible avec data:post.labels.size,

  2. Blogger limite à 20 libellés maximum par article (merci pour ça… ou pas 😅),

  3. et c’est un excellent moyen de mettre en avant les articles les plus “catégorisés” (même si ça paraît totalement idiot).

Voici à quoi cela ressemble, avec un tri décroissant cette fois :

Le code
<ul>
  <b:loop values='20 to 0' var='sort'>

    <b:loop values='data:posts where (p => p.labels.size == data:sort)' var='post'>

      <li><data:post.title/> (nombre de libellés : <data:post.labels.size/>)</li>

    </b:loop>

  </b:loop>
</ul>

Ce que fait ce code :

  • La première boucle génère les valeurs de 20 à 0.

  • Pour chaque valeur, on filtre les articles ayant exactement ce nombre de libellés.

  • Les articles sont ensuite affichés un à un.

Résultat : les articles sont listés du plus étiqueté au moins étiqueté.

Cette astuce est parfaitement transposable à d’autres critères numériques, tant qu’on connaît les bornes à l’avance : nombre de commentaires, longueur du titre, score personnalisé, etc.

Limites et considérations

Cette méthode de tri fonctionne bien dans l’environnement XML de Blogger, mais elle a ses limites. Voici ce qu’il faut garder en tête avant de l’adopter.

  1. Il faut connaître les bornes min et max

    Cette astuce repose sur une boucle min to max.

    Mais si vous ne connaissez pas ces bornes à l’avance, vous risquez :

    • soit de rater des éléments (si la plage est trop étroite),
    • soit de gaspiller des ressources (si elle est trop large).

    Pour les données dynamiques, vous devrez donc anticiper ou fixer une fourchette raisonnable, en vous appuyant sur les règles de Blogger (comme la limite des 20 libellés par article) ou sur une estimation.

  2. La méthode ne trie que des entiers

    Les opérateurs to, any, where, etc. fonctionnent avec des valeurs entières.

    On ne peut pas trier :

    • des décimaux (ex : 3.14),
    • ou des chaînes de caractères (ex : des noms, des titres, des dates textuelles).

    Si vous tentez de trier du texte, vous aurez besoin d’un traitement client-side (JavaScript) ou d’une structure pré-triée.

  3. La performance dépend de la plage choisie

    Blogger exécute une boucle pour chaque valeur de la plage.

    Donc si vous faites 0 to 10 000, alors que votre tableau contient 7 valeurs... c’est lourd pour rien.

    Restez raisonnable :

    • Une plage de 20 à 100 valeurs passe crème.
    • Au-delà de 300, le temps de chargement pourrait se faire sentir, surtout sur mobile ou avec plusieurs gadgets.
  4. Les doublons sont ignorés... naturellement

    C’est un petit bonus de cette méthode : comme on affiche chaque nombre une seule fois (au moment où il apparaît dans la boucle to), les doublons sont mécaniquement filtrés, sans aucune action supplémentaire.

  5. Et le tri alphabétique, alors ?

    Eh bien… non Toto. Là, tu en demandes trop 😅

    Comme il n’existe aucun opérateur de tri lexical (par ordre alphabétique), on ne peut pas réorganiser une liste de chaînes de caractères.

    Il faudrait :

    • soit trier ces éléments à l’avance (manuellement),
    • soit passer par un script JavaScript.

    Mais côté expressions XML pures, ce n’est pas possible.

Alors la prochaine fois que vous entendrez un “on ne peut pas trier dans Blogger”, pensez à Toto.

Il a peut-être l’air perdu… mais il connaît ses boucles par cœur. 😉

Spotlight

Ajouter son blog dans l’omnibox de Firefox

Populaires cette semaine

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