Aller au contenu principal
API PDF4meIntégrationsBase de connaissancesExtensionsTesteur d'APIBlog

Listes dans les modèles - Puces et numérotées

Les listes constituent des structures fondamentales pour organiser et présenter l'information dans les documents. PDF4meLe moteur de modèles de prend en charge la génération de listes à puces et numérotées, vous permettant de créer des documents bien structurés et lisibles avec un contenu dynamique provenant de vos sources de données.

Listes à puces​

Générez des listes à puces en plaçant des boucles foreach dans des paragraphes formatés avec des puces. Word modèle.

Syntaxe de base des listes à puces​

Créez un paragraphe à puces dans Word, puis ajoutez la boucle foreach :

<<foreach [bullet in EmployeeNames]>><<[bullet.listFirstName]>> <<[bullet.listLastName]>> 
<</foreach>>

Étapes clés :

  1. Dans Word, créez une puce (utilisez la mise en forme à puce)
  2. Ajoutez la boucle foreach et fusionnez les champs.
  3. La boucle répétera la puce pour chaque élément.

Exemple : Liste des noms des employés​

Conception du modèle :

Employee Directory:
• <<foreach [bullet in EmployeeNames]>><<[bullet.listFirstName]>> <<[bullet.listLastName]>> 
<</foreach>>

Source des données :

{
  "companyName": "PDF4me",  
  "EmployeeNames": [
    {
      "listFirstName": "Thomas",
      "listLastName": "Baskin"
    },
    {
      "listFirstName": "Jacob",
      "listLastName": "Gregory"
    },
    {
      "listFirstName": "John",
      "listLastName": "Doe"
    }
  ]
}

Résultat généré :

Employee Directory:
• Thomas Baskin
• Jacob Gregory
• John Doe

Listes numérotées​

Générez des listes numérotées en utilisant la même approche foreach, mais avec une mise en forme de paragraphe numéroté. Word.

Syntaxe des listes numérotées​

Numbered List - Instead of bullets, if you apply the syntax in a numbered paragraph format in Word, the list will be generated as a numbered list with automatic numbering.

Exemple : Liste des tâches​

Modèle:

Project Tasks:
1. <<foreach [task in tasks]>><<[task.name]>> - <<[task.status]>>
<</foreach>>

Données:

{
  "tasks": [
    { "name": "Design mockups", "status": "Complete" },
    { "name": "Develop features", "status": "In Progress" },
    { "name": "Testing phase", "status": "Pending" }
  ]
}

Sortir:

Project Tasks:
1. Design mockups - Complete
2. Develop features - In Progress
3. Testing phase - Pending

Listes à plusieurs niveaux​

Créez des structures de listes hiérarchiques avec des relations parent-enfant à l'aide de boucles foreach imbriquées.

Exemple de hiérarchie à deux niveaux​

Conception du modèle :

<<foreach [manager in employees]>>Manager: <<[manager.listFirstName]>> <<[manager.listLastName]>>
    <<foreach [associate in manager.associates]>>Associate: <<[associate.name]>>
<</foreach>><</foreach>>

Important: Les éléments de la liste de deuxième niveau doivent être indentés dans votre Word Modèle pour créer une mise en forme hiérarchique correcte.

Exemple : Structure organisationnelle​

Structure des données :

{
  "companyName": "PDF4me",
  "employees": [
    {
      "listFirstName": "Christopher",
      "listLastName": "Nolan",
      "associates": [
        { "name": "Will Smith" },
        { "name": "Barry Allen" },
        { "name": "Oliver Queen" }
      ]
    },
    {
      "listFirstName": "Sarah",
      "listLastName": "Parker",
      "associates": []
    },
    {
      "listFirstName": "Justin",
      "listLastName": "Langer",
      "associates": [
        { "name": "Brad Pitt" },
        { "name": "John Smith" }
      ]
    }
  ]
}

Résultat généré :

• Manager: Christopher Nolan
    ○ Associate: Will Smith
    ○ Associate: Barry Allen
    ○ Associate: Oliver Queen
• Manager: Sarah Parker
• Manager: Justin Langer
    ○ Associate: Brad Pitt
    ○ Associate: John Smith

Gestion des sous-listes vides​

Utilisez des vérifications conditionnelles pour gérer les cas où les sous-listes pourraient être vides.

Sous-liste conditionnelle​

Modèle:

<<foreach [manager in employees]>>Manager: <<[manager.listFirstName]>> <<[manager.listLastName]>>
    <<if [manager.associates.Any()]>>
    <<foreach [associate in manager.associates]>>Associate: <<[associate.name]>>
    <</foreach>>
    <<else>>
    No associates assigned
    <</if>>
<</foreach>>

Éléments de liste formatés​

Appliquez une mise en forme au contenu des éléments de la liste pour une meilleure présentation.

Exemple : Noms et dates formatés​

Modèle:

• <<foreach [employee in employees]>><<[employee.name]:caps>> - Joined: <<[employee.joinDate]:"MMMM yyyy"]>>
<</foreach>>

Données:

{
  "employees": [
    { "name": "john smith", "joinDate": "2020/03/15" },
    { "name": "jane doe", "joinDate": "2021/07/22" }
  ]
}

Sortir:

• John Smith - Joined: March 2020
• Jane Doe - Joined: July 2021

Listes triées​

Générez des listes dans des ordres spécifiques à l'aide de méthodes d'énumération.

Liste triée par ordre alphabétique​

Modèle:

• <<foreach [person in people.OrderBy(p => p.lastName)]>><<[person.lastName]>>, <<[person.firstName]>>
<</foreach>>

Trié selon plusieurs propriétés​

Modèle:

• <<foreach [emp in employees.OrderBy(e => e.department).ThenBy(e => e.name)]>><<[emp.name]>> - <<[emp.department]>>
<</foreach>>

Listes filtrées​

Afficher uniquement les éléments qui répondent à des critères spécifiques.

Filtrage conditionnel​

Modèle:

Active Employees:
• <<foreach [emp in employees.Where(e => e.status == "Active")]>><<[emp.name]>>
<</foreach>>

Filtrage basé sur l'âge​

Modèle:

Senior Team Members:
• <<foreach [person in team.Where(p => p.age > 50)]>><<[person.name]>> (Age: <<[person.age]>>)
<</foreach>>

Types de listes mixtes​

Combinez différents styles de listes au sein d'un même document.

Exemple : Aperçu du projet​

Modèle:

Project Phases (Numbered):
1. <<foreach [phase in phases]>><<[phase.name]>>
<</foreach>>

Team Members (Bulleted):
• <<foreach [member in team]>><<[member.name]>> - <<[member.role]>>
<</foreach>>

Exemples complexes à plusieurs niveaux​

Hiérarchie à trois niveaux​

Modèle:

<<foreach [dept in departments]>>Department: <<[dept.name]>>
    <<foreach [team in dept.teams]>>Team: <<[team.name]>>
        <<foreach [member in team.members]>><<[member.name]>> - <<[member.position]>>
        <</foreach>>
    <</foreach>>
<</foreach>>

Cela crée :

  • Niveau 1 : Département (style à puces 1)
    • Niveau 2 : Équipe (style bullet 2)
      • Niveau 3 : Membre (style de puce 3)

Conception de listes dans Word Modèle​

Configuration de la mise en forme de la liste​

  1. Créer une structure de liste - Utiliser Wordoutils de mise en forme de liste intégrés
  2. Choisissez le style de puce - Sélectionnez le style de puces ou de numérotation approprié
  3. Définir l'indentation - Configurer les niveaux d'indentation pour les listes à plusieurs niveaux
  4. Ajouter des champs de fusion - Insérer des boucles foreach et la syntaxe des champs de fusion
  5. Conserver la mise en forme - Assurez-vous que la mise en forme de la liste est appliquée au texte du modèle

Niveaux d'indentation​

Pour les listes à plusieurs niveaux :

  • Niveau 1 : Aucune indentation ni indentation de premier niveau
  • Niveau 2 : Une tabulation ou un retrait augmenter
  • Niveau 3 : Deux tabulations ou un retrait de second niveau

Word Gère automatiquement le style des puces/numéros en fonction du niveau d'indentation.

Applications pratiques​

Cas d'utilisation 1 : Ordre du jour de la réunion​

Modèle:

Meeting Agenda - <<[meetingDate]:"MMMM dd, yyyy">>

1. <<foreach [item in agendaItems]>><<[item.title]>> (<<[item.duration]>> min)
<</foreach>>

Attendees:
• <<foreach [attendee in attendees]>><<[attendee.name]>> - <<[attendee.department]>>
<</foreach>>

Cas d'utilisation 2 : Fonctionnalités du produit​

Modèle:

<<[productName]>> Features:

• <<foreach [feature in features]>><<[feature.name]>> - <<[feature.description]>>
<</foreach>>

Technical Specifications:
1. <<foreach [spec in specifications]>><<[spec.parameter]>>: <<[spec.value]>>
<</foreach>>

Cas d'utilisation 3 : Articles de facture​

Modèle:

Order Items:
<<foreach [item in orderItems]>>
<<[$index + 1]>>. <<[item.name]>> - Quantity: <<[item.qty]>> - Price: $<<[item.price]>>
<</foreach>>

Total Items: <<[orderItems.Count()]>>
Total Amount: $<<[orderItems.Sum(i => i.qty * i.price)]>>

Meilleures pratiques​

Conception de liste​

  1. Mise en forme cohérente - Utilisez le même style de liste pour les types de contenu similaires.
  2. Profondeur appropriée - Limitez l'imbrication à 3 ou 4 niveaux pour une meilleure lisibilité.
  3. Groupement logique - Regrouper les éléments similaires
  4. Hiérarchie claire - Utilisez différents styles de puces pour les différents niveaux.

Structure des données​

  1. Collections propres - S'assurer que les collections contiennent des données valides et complètes
  2. Propriétés cohérentes - Utilisez des noms de propriétés cohérents pour tous les éléments.
  3. Gérer les valeurs nulles - Vérifier les collections vides avec Any()
  4. Trier de manière appropriée - Triez les données au préalable ou utilisez OrderBy dans les modèles

Performance​

  1. Limiter la taille de la liste - Envisagez la pagination pour les listes très longues.
  2. Filtrer efficacement - Appliquer les filtres à la source de données lorsque cela est possible
  3. Évitez les imbrications complexes - Une imbrication profonde peut impacter la vitesse de traitement
Mise en forme des listes

Appliquez une mise en forme (puces, numéros, retrait) directement dans votre liste. Word modèle avant d'ajouter des boucles foreach. Le moteur de modèles préserve la mise en forme que vous avez définie dans Word.