Le critère doublons : sa mécanique et son utilisation avancée

Le critère {doublons} une fois découvert devient rapidement indispensable à vos squelettes. Il permet des tris très intéressants mais son emploi n’est pas immédiatement perceptible à la première lecture de la documentation de “spip.net”.

Le critère {doublons} une fois découvert devient rapidement indispensable à vos squelettes [1]. S’il est d’un emploi un poil curieux, il permet des tris très intéressants mais qui n’apparaissent pas immédiatement à la lecture de la documentation de base sur Spip.net qui nous dit :

Le critère {doublons} ou {unique} [2] :
permet d’interdire l’affichage des résultats déjà affichés dans d’autres boucles utilisant ce critère. Ces deux critères sont rigoureusement identiques.

Identiques ? Pas tout à fait ! Au fil des versions de SPIP, doublons s’est enrichi de possibilités supplémentaires :
-  on peut nommer ses doublons, donc en faire coexister plusieurs dans un même code,
-  il permet aussi des pirouettes spipiennes avec l’anti-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>

Footnotes

[2Attention, ne pas confondre le critère “unique” et le filtre “unique” dont on peut trouver des applications ici et .

[3Il s’agit du squelette par défaut de SPIP que l’on trouve dans le dossier /DIST. Rappel : vous ne devez pas toucher à ces fichiers et ranger les fichiers de votre propre squelette dans un dossier /squelettes à créer au même niveau que /DIST, c’est à dire à la racine du site.

[4ce point est tiré de ce fil de discussion (Merci Cédric)

updated on 2 October 2019

Discussion

10 discussions

  • Thiébaut

    Bonjour, je dois oublier quelque chose, parce que je n’arrive pas à exclure un groupe de mots clé dans la boucle des groupes frères du squelette mot.html. Voici ce que j’ai fait :

    <B_groupes_freres>
    <div class="menu">
    <h2><:autres_groupes_mots_clefs:></h2>
    <ul>
    <BOUCLE_exclure_groupe4(GROUPES_MOTS) {id_groupe=4} {doublons}>
    </BOUCLE_exclure_groupe4>
    <BOUCLE_groupes_freres(GROUPES_MOTS) {!id_groupe} {par titre} {doublons}>
    <BOUCLE_mot_cousin(MOTS) {id_groupe} {par titre} {0,1} {doublons}>
    <li><a href="#URL_MOT">#TYPE</a></li>
    </BOUCLE_mot_cousin>
    </BOUCLE_groupes_freres>
    </ul>
    </div>
    </B_groupes_freres>

    Il s’agit de ce genre de groupe de mots qui sert par exemple aux squelettes, ou à exclure certains objets.... Bref, que l’on ne souhaite pas voir apparaître côté public.

    Merci par avance de me dire ce qui ne va pas !

    Reply to this message

  • 4

    Faites attention aux pré-boucles (celles qui commencent par “B” et non par “Boucle”) :

    Il ne faut pas oublier qu’elles entraînent l’évaluation de la boucle en question.

    Par exemple si on utilise des doublons dynamiques dans une boucle imbiquée comme ici :

     [(#REM) On n'affiche pas les articles invisibles]
      <B_sous_rubriques>
       <ul>
       <BOUCLE_sous_rubriques_invisibles(ARTICLES){id_rubrique}{titre_mot='invisible'}{doublons #id_rubrique}>
       </BOUCLE_sous_rubriques_invisibles>
    
       [(#REM) On affiche les autres articles]
       <BOUCLE_sous_rubriques(ARTICLES){id_rubrique}{par num titre, titre}{doublons #id_rubrique}>
         <li><a href="#URL_ARTICLE"[ class="(#EXPOSE)"]>[(#TITRE|couper{80})]</a></li>
       </BOUCLE_sous_rubriques>
      </ul>
     </B_sous_rubriques>

    nos articles invisibles vont s’afficher car la préboucle entraîne l’évaluation de la “boucle_sous_rubriques”.
    Avec l’évaluation de cette boucle, le doublon est déjà constitué avant l’évaluation de la boucle_sous_rubrique_invisible et donc de jeux de doublons ne contiendra pas nos articles invisibles.

    La solution est donc de déplacer un peu plus bas notre pré-boucle comme ci-dessous :

     [(#REM) On n'affiche pas les articles invisibles]
      <BOUCLE_sous_rubriques_invisibles(ARTICLES){id_rubrique}{titre_mot='invisible'}{doublons #id_rubrique}>
      </BOUCLE_sous_rubriques_invisibles>
    
      <B_sous_rubriques>
       <ul>
       [(#REM) On affiche les autres articles]
       <BOUCLE_sous_rubriques(ARTICLES){id_rubrique}{par num titre, titre}{doublons #id_rubrique}>
         <li><a href="#URL_ARTICLE"[ class="(#EXPOSE)"]>[(#TITRE|couper{80})]</a></li>
       </BOUCLE_sous_rubriques>
      </ul>
     </B_sous_rubriques>

    Cela retarde la constitution de notre jeux de doublons et permet aux articles invisibles de ne pas s’afficher.

    Merci pour la fabuleuse doc de spip et à touTEs ceuses qui contribuent aux fora de spip.

    Steff
    PS : un dernier petit détail. Je ne comprends pas clairement l’anti-doublon, qq1 voudrait bien expliquer plus clairement comment ce mot-clef marche, sans baser les explications uniquement sur un exemple ?

    • Dans ma page “sommaire.html” :

      <INCLURE ...selection_d_articles...> doublons
      <INCLURE ... derniers_articles...> doublons

      Les deux fichiers inclus sont composés d’une boucle sur ARTICLES.

      J’espérais ne pas pas retrouver dans les “derniers articles publiés” des articles qui auraient déjà été affichés dans la 1e boucle...
      ...mais si : ils reviennent immanquablement, quoique je fasse.

      MAIS si j’inclus en dur les codes des deux boucles directement dans “sommaire.html” (ie sans utiliser INCLURE), ça marche !

      Ce comportement est-il ...attendu ? Pouvez-vous me pointer vers une doc pertinente ? Y a-t-il un secret quant au passage de variables ?

      _M_E_R_C_I_!_

      ps : mm question au sujet des commentaires dans le code, qui sont qd m interprétés par SPIP...

    • Il stéfano

      Veux tu bien détailler davantage tes boucles stp ?

      Et si tu les mets dans le même fichier html, sans inclure, est-ce que le comportement est celui que tu veux ?

      As tu essayé en mode debug pour voir comment tes boucles sont nommées par spip après un inclure dans ton fichier php ?

      Stéphane

    • Bonjour,

      Les inclure ne prennent pas en compte les doublons de son squelette parent... C’est son fonctionnement normal.

    • Merci pour ces réponses. J’ai pu constater que c’est bien le comportement normal de (SPIP 2.0.10).

      Mais le fait de devoir inclure inline certaine boucle dans plusieurs fichiers me pose un problème de maintenance. Je ne devrais pas être seul dans ce cas. Pensez-vous qu’il soit, mettons, à l’ordre du jour d’une prochaine édition de faire glisser ce comportement normal vers un comportement plus attendu ?

      Je tempère tout de suite mon post en remerciant l’équipe de développement et toute la spiposphère pour le super cms que vous nous proposez !

      Bonne Année !

      ps : je vais chercher de l’info sur le mode debuggage

    Reply to this message

  • Tu peux d ailleurs t’assurer que les doublons ne sont pas les memes quand la page est générée en php.
    Pour cela, utilise les options de débuggage et regarde le code qui résulte de ton squelettes, ce sera peut-être plus clair.

    Spip c’est vraiment cool !
    Stéphane

    Reply to this message

  • J’essaye en vain d’utiliser dans mon sommaire:

    <B_articles_recents>
     
    <BOUCLE_avec_mot(ARTICLES){tout}{id_mot=21}{par date}{doublons motcleexcept}>
    </BOUCLE_avec_mot>
     
    <BOUCLE_articles_recents(ARTICLES){id_rubrique !IN 7,8,19}{pagination 5}{par date}{inverse}{doublons motcleexcept}>
              #TITRE
    </BOUCLE_articles_recents>
             
    </B_articles_recents>

    La syntaxe me paraît ok…

    Reply to this message

  • Bonjour,
    Je cherche à faire quelque chose de ce genre:

    boucle1 doublons
    /boucle1

    boucle2 doublons
    /boucle2

    Où le nombre total de résultats, des deux boucles, est fixé (à 50.000, en l’occurence, pour un sitemap...).

    Une idée?

    Reply to this message

  • 1

    Merci pour cet article clair et plein de petites astuces croustillantes.

    Effectivement, je me rend compte maintenant que j’étais totalement passé à coté des possibilités de ce critère doublons

    encore merci
    Peetdu

    • PetarouxRay

      Bonjour,

      dans le cas d’une structure comme celle la :

      — rubrique 1

      ---- Sous-rubrique A (avec un article publié)

      ---- Sous-rubrique B

      ---- Sous-rubrique C (avec un article publié)

      — rubrique 2

      ---- Sous-rubrique A

      ---- Sous-rubrique B (avec un article publié)

      ---- Sous-rubrique C

      — rubrique 3

      ---- Sous-rubrique A (avec un article publié)

      ---- Sous-rubrique B

      ---- Sous-rubrique C

      .

      Les sous-rubrique on le même nom pour chaque rubrique mère.

      Je souhaite afficher les sous-rubriques ou un article est publié, mais en évitant les doublons.
      comment puis-je faire pour que “Sous-rubrique A” ne s’affiche pas deux fois ?

      merci pour vos réponses, en espérant avoir été clair

    Reply to this message

  • Fil a encore enrichi les possibilités de doublons dans la prochaine version de spip. On pourra passer doublons aux inclusions et dans l’url.

    Voir http://comments.gmane.org/gmane.comp.web.spip.devel/46926
    et
    http://trac.rezo.net/trac/spip/changeset/11390

    Reply to this message

  • 5

    doublons ne fonctionne pas dans une boucle imbriquée. Comment faire dans ce cas?

    • Est-ce que tu peux préciser ?

    • Par exemple une boucle articles doublons et dans cette boucle une autre boucle articles doublons. Donc une boucle imbriquée. Et bien doublons ne fonctionne pas; et ce n’est pas indiqué dans la doc.

    • En demandant des précisions je m’attendais à ce que tu exposes un cas de figure, que tu expliques ce que tu cherches à obtenir avec tes boucles et que tu donnes un exemple de code.

    • Impossible de mettre du code spip dans le message car il est interprété. Mais une boucle imbriquée çà me semble assez parlant.

    • L’instit

      Pour mettre du code spip dans un message de forum, il suffit de le mettre entre les balises

      <code> et </code>

      C’est dans la doc ;-)

    Reply to this message

  • 2

    Bonjour,
    Dans l’article sur spip je n’avais pas compris çà : {doublons xxxx} et je ne vois toujours pas ce que xxxx exprime. Une partie du titre de l’article, un mot clés associé...

    Dans l’exemple on trouve {doublons com} ; que représente com ?

    Cordialement
    Philippe Avi

    • L’instit

      Salut

      Tu représentes... ce que tu veux ! Le nom est choisi par toi, même pas vraiment en fonction de ce que tu veux trier. C’est juste pour identifier un doublons des autres.

      Je crois que dans l’article d’origine, on parle de doublons rouge et de doublon vert. Le mot n’a d’importance que pour celui qui crée le squelette, il n’est pas en rapport avec un mot clé, ni avec le nom de la boucle. c’est simplement que cela permet à Spip de savoir qu’on fait le tri uniquement en comparaison de la boucle qui contient CE “doublons” là.

      Ici, on a choisi le com parce qu’on trie sur les communiqués, on aurait pu écrire aussi bien tartempion ou salsepareille, quel que soit le nom de la boucle

    • Merci, c’est clair maintenant ; cela ne concerne que la boucle en question.

      Cordialement,
      Philippe

    Reply to this message

  • Moi je dis excellent !

    Ca doit faire 2 ans que je galère avec ces mots clefs, et j’avais beau trier avec doublons je me faisait avoir comme dans l’exemple ! :)

    Bravo et merci, c’est clair et précis !

    Reply to this message

Comment on this article

Who are you?
  • [Log in]

To show your avatar with your message, register it first on gravatar.com (free et painless) and don’t forget to indicate your Email addresse here.

Enter your comment here

This form accepts SPIP shortcuts {{bold}} {italic} -*list [text->url] <quote> <code> and HTML code <q> <del> <ins>. To create paragraphs, just leave empty lines.

Add a document

Follow the comments: RSS 2.0 | Atom