Peut-on trier les tableaux de nombres ?

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 :

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

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 :

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