Directives générales pour l’écriture de scripts

  • Rversion finale: Australia
  • Mis à jour 12 mars 2026
  • 4 minutes de lecture
  • Écrivez des scripts efficaces à l’aide d’un langage de type JavaScript. Suivez ces instructions générales pour la dénomination, les variables et l’accès aux tables.

    Ce guide vous guidera à travers les directives générales pour écrire des scripts efficaces et fiables dans CPQ un langage de type JavaScript. Suivre ces instructions vous aidera à créer un code facile à maintenir, lisible et performant.

    Résumé rapide

    • Placer les déclarations en haut
    • Commentez de manière réfléchie
    • Mettre en retrait les crochets
    • Utiliser des noms de variables descriptives
    • Nommer les variables de manière cohérente
    • Évitez le terme « nouveau »
    • Éviter l’égalité lâche (« == »)
    • Utiliser « const » avant « let » et « let » plutôt que « var »
    • Minimiser les recherches dans les tables

    Placer les déclarations en haut

    Le fait de placer les déclarations de variables et de fonctions en haut de votre script améliore la lisibilité et évite les problèmes inattendus de levage de variables.

    1 // Declare and initiate at the beginning
    2 let firstName = "";
    3 let lastName = "";
    4 let price = 0;
    5 let discount = 0;
    6 let fullPrice = 0,
    7 const myArray = [];
    8 const myMap= {};

    Commentez de manière réfléchie

    Utilisez des commentaires pour expliquer une logique complexe, des hypothèses ou tout comportement non évident dans votre code. Évitez les commentaires redondants qui ne font que répéter le code.

    Mettre en retrait les crochets

    L’indentation correcte de votre code améliore sa structure visuelle et le rend plus facile à comprendre, en particulier lorsqu’il s’agit de blocs imbriqués.
    1 // Good
    2 if (condition) {
    3 // ...
    4 if (nestedCondition) {
    5 // ...
    6 }
    7 }
    8
    9 // Bad
    10 if (condition) {
    11 // ...
    12 if (nestedCondition) {
    13 // ...
    14 }
    15 }

    Utiliser des noms de variables descriptives

    Choisissez des noms significatifs qui décrivent le but de la variable ou de la fonction. Cela rend votre code auto-documenté et plus facile à comprendre pour les autres.

    1 //Good
    2 let quoteId = cfgRequest.partner.quote.id.value;
    3 let lineID = cfgRequest.partner.quote.lineId.value;
    4 let currencyISO = cfgRequest.partner.quote.currencyIsoCode.value;
    5 let priceBookID = cfgRequest.partner.quote.pricebookId.value;
    6
    7 if (quoteId != null) {
    8 cfgRequest.quoteIDTest.set("value", quoteId);
    9 }
    10
    11 if (lineID != null) {
    12 cfgRequest.lineIDTest.set("value", lineID);
    13 }
    14
    15 if (currencyISO != null) {
    16 cfgRequest.currencyISOCodeTest.set("value", currencyISO);
    17 }
    18
    19 if (priceBookID != null) {
    20 cfgRequest.pricebookIDTest.set("value", priceBookID);
    21 }
    22
    23 //Bad
    24 let x1= cfgRequest.partner.quote.id.value;
    25 let x2= cfgRequest.partner.quote.lineId.value;
    26 let x3= cfgRequest.partner.quote.currencyIsoCode.value;
    27 let x4= cfgRequest.partner.quote.pricebookId.value;
    28
    29 if (x1 != null) {
    30 cfgRequest.quoteIDTest.set("value", x1);
    31 }
    32
    33 if (x2 != null) {
    34 cfgRequest.lineIDTest.set("value", x2);
    35 }
    36
    37 if (x3 != null) {
    38 cfgRequest.currencyISOCodeTest.set("value", x3);
    39 }
    40
    41 if (x4 != null) {
    42 cfgRequest.pricebookIDTest.set("value", x4);
    43 }

    Nommer les variables de manière cohérente

    Des conventions de dénomination cohérentes améliorent la lisibilité et la maintenabilité du code. Choisissez camelCase ou snake_case et respectez-le. Les noms de variables de champ Logik utilisent camelCase, de sorte que la plupart des organisations conservent cette convention pour plus de lisibilité.

    1 // camelCase
    2 let firstName = "JohnDoe";
    3
    4 // snake_case
    5 let last_name = "Smith";

    Évitez le mot-clé « nouveau »

    L’utilisation du nouveau mot clé peut utiliser plus de ressources, entraîner des fuites de mémoire et provoquer des comportements involontaires. Utilisez plutôt la notation littérale pour la création d’objets si possible.

    • Utiliser " " au lieu de new String( )
    • Utiliser ( ) au lieu du nouveau numéro ( )
    • Utiliser false au lieu de new Boolean( )
    • Utiliser { } au lieu de new Map( )
    • Utiliser [ ] au lieu de new Array( )

    Éviter l’égalité lâche (« == »)

    L’opérateur d’égalité lâche peut conduire à une coercition de type inattendue. Pour des comparaisons précises, utilisez l’opérateur d’égalité stricte (===).

    1 // Good
    2 if (count === 5) {
    3 // ...
    4 }
    5
    6 // Bad
    7 if (count == "5") {
    8 // ...
    9 }

    Utiliser « const » avant « let » et « let » plutôt que « var »

    Choisissez la déclaration de variable en fonction du périmètre et des exigences de mutabilité. Utilisez const pour les variables qui ne seront pas réaffectées et let pour les variables qui changeront. var est également acceptable mais est un vestige des versions précédentes de JavaScript.

    1 // Using const for unchanging values
    2 const TAX_RATE = 0.15;
    3
    4 // Using let for mutable values
    5 let itemCount = 5;

    Minimiser les recherches dans les tables

    Des requêtes de table excessives peuvent avoir un impact sur les performances. Minimisez les requêtes en récupérant les données nécessaires une seule fois et en les stockant dans des variables.

    Pour en savoir plus sur les directives générales d’utilisation de la fonction de recherche , reportez-vous à la section Réduction des requêtes de table.