{doublons}

Utilisation de base : ne pas retrouver des éléments déjà traités dans la page

Un exemple nous est donné dans le squelette sommaire de dist [3]

<BOUCLE_articles_recents(ARTICLES) {par date}{inverse} {0,2} {doublons}>
éléments à afficher, par exemple #TITRE
</BOUCLE_articles_recents>
<BOUCLE_autres_articles(ARTICLES) {par date}{inverse} {doublons} >
éléments à afficher, par exemple #TITRE
</BOUCLE_articles>

Il s’agit de lister les articles du site par ordre chronologique inversé ET de réserver aux deux derniers articles publiés un traitement particulier. Comme vous le voyez, les boucles "_articles_recents" et "_autres_articles" sont construites de la même manière. En toute logique, elles doivent donc retourner la même liste d’articles.

C’est grâce au travail du critère "doublons" que les 2 articles les plus récents, déjà traités dans la première boucle, ne se retrouveront pas dans la liste affiché avec la boucle "_autres_articles" .

Autre utilisation courante : exclure des éléments

Notre grand classique : exclure suivant un mot-clé

On voit régulièrement sur la liste spip-users posé ce type de problème :

"Je n’arrive pas a exclure des éléments en fonction de leur mot-clé.
j’essaie :

<BOUCLE_rubriques(RUBRIQUES) {racine} {titre_mot!=invisible}{par num titre, titre}>

mais cela ne fonctionne pas"

Et pour cause !

Ce que veut l’utilisateur ici, c’est sélectionner toutes les rubriques qui n’ont pas reçu le mot clé "invisible". Or, ce que comprend la base de données avec {titre_mot != invisible}, c’est qu’elle doit sélectionner toutes les rubriques qui ONT un mot clé ET que le dit mot clé soit différent de "invisible".

Et cela change tout. Car dans le résultat figurera par exemple une rubrique à laquelle a été affecté un mot clé "bidule", donc différent de "invisible" (ok !), y compris si la rubrique est liée au mot clé "invisible" (arg !) et, n’y figurera pas, une rubrique qui n’a aucun mot clé (l’inverse du résultat souhaité !). [4]

La solution : enchaîner une boucle vide qui sélectionne selon le mot-clé et une autre boucle qui retourne les résultats en utilisant le critère {doublons}.

En reprenant notre exemple ci-dessus cela donne :

<BOUCLE_exclure(RUBRIQUES) {racine} {titre_mot=invisible}{doublons}>
</BOUCLE_exclure>

Cette boucle sélectionne toutes les rubriques qui ont le mot-clé "invisible" , mais elle n’affiche rien.

<BOUCLE_rubriques(RUBRIQUES) {racine}{par num titre, titre} {doublons}>
{le traitement  à effectuer ici}
</BOUCLE_rubriques>

Cette deuxième boucle va sélectionner grâce au critère doublons toutes les autres rubriques et leur appliquera le traitement choisi.

Nommer les doublons pour en utiliser plusieurs dans le même fichier

Objectif : gérer sur une page d’accueil l’affichage de liens vers des articles et vers des communiqués. La présentation des deux derniers articles publiés et des deux derniers communiqués est différente des autres.

Pour l’exemple, on retrouve ici le même schéma déjà vu avec les boucles de la DIST. Il s’agit simplement ici de faire cohabiter sans conflit des boucles très proches. Nommer les doublons évitera que les tris de l’une interfèrent dans les tris de l’autre.

<BOUCLE_communiques_recents(ARTICLES) {!par date}{id_mot=1} {0,2} {doublons com}>
éléments à afficher, par exemple #TITRE
</BOUCLE_communiques_recents>
<BOUCLE_autres_communiques(ARTICLES) {!par date}{id_mot=1} {doublons com} >
éléments à afficher, par exemple #TITRE
</BOUCLE_autres_communiques>

<BOUCLE_articles_recents(ARTICLES) {!par date} {0,2} {doublons art}>
éléments à afficher, par exemple #TITRE
</BOUCLE_articles_recents>
<BOUCLE_autres_articles(ARTICLES) {!par date} {doublons art} >
éléments à afficher, par exemple #TITRE
</BOUCLE_articles>

De manière générale, nommer ses doublons est une bonne pratique pour éviter tout télescopage actuel mais aussi futur (des squelettes cela évoluent). C’est aussi un élément qui donne de la lisibilité à votre code.

Dans le cadre d’une utilisation avancée, vous pouvez essayer l’utilisation de balises SPIP. Par exemple : {doublons #TITRE} ou même {doublons #_mabouboucle:TITRE} voire même {doublons (#_mabouboucle:TITRE|supprimer_numero)}.

Utilisation avancée : anti-doublons ou comment constituer une pile de données à traiter

Mécanique de l’anti-doublons

Ici "doublons" va permettre de rassembler le résultats de plusieurs boucles utilisant différents critères et " !doublons" d’appliquer à cet empilement d’items les traitements souhaités.

Le schéma d’utilisation est celui-ci :

On sélectionne un première série d’articles (on n’affiche rien)...

<BOUCLE0(ARTICLES){id_mot=2}{doublons A}></BOUCLE0>

...puis une deuxième série d’articles (on n’affiche toujours rien)....

<BOUCLE1(ARTICLES){id_auteur=1}{doublons A}></BOUCLE1>

... on trie selon ses besoins et on affiche le tout grâce à l’anti-doublons.

<BOUCLE2(ARTICLES){par date}{!doublons A}>#TITRE<br></BOUCLE2>

Un Exemple d’anti-doublons

Objectif : faire une boucle qui récupère les articles de toutes les rubriques à l’exception des rubriques 2 et 3, ET pour ce qui concerne les articles de la rubrique 4, seulement ceux de moins de 60 jours.

La solution : il nous faut une première boucle qui ira chercher tous les articles en excluant ceux des rubriques 2, 3 mais aussi 4...

<BOUCLE0(ARTICLES) {id_rubrique !IN 2,3,4}{doublons tri1}></BOUCLE0>

....puisqu’il faut dédier à cette rubrique une deuxième boucle...
<BOUCLE1(ARTICLES) {id_rubrique=4}{age<60}{doublons tri1}></BOUCLE1>

...et c’est dans une dernière boucle que l’on affiche grâce à l’anti-doublons les articles sélectionnés triés avec les critères de son choix.

<BOUCLE2(ARTICLES){par date}{!doublons tri1}>#TITRE<br></BOUCLE2>