Éviter les Opérations Redondantes dans les Rappels Système à Haute Fréquence

L'tuilisation efficace des interfaces de rappel système à haute fréquence est cruciale. Il faut supprimer les traces et impressions de journaux non essentiels afin de réduire la surcharge système.

Ne pas effectuer d'opérations coûteuses dans les rappels fréquents

Des rappels tels que onScroll ou onAreaChange sont exécutés à chaque frame. Y exécuter des tâches lourdes ou inutiles consomme excessivement les ressources et dégrade les performances.

Éviter les traces dans les rappels fréquents

L'émission de traces (comme avec hitrace) dans ces contextes ajoute une charge supplémentaire. L'exemple ci-dessous montre une pratique à éviter et une alternative recommandée :

// À éviter : trace dans onScroll
@Entry
@Component
struct ScrollExempleIncorrect {
  private donnees: number[] = [1, 2, 3, 4, 5];

  build() {
    List() {
      ForEach(this.donnees, (element: number) => {
        ListItem() {
          Text(`Élément ${element}`)
        }
      }, (element: number) => element.toString())
    }
    .onScroll(() => {
      hitrace.startTrace("TraceDefilement", 77);
      // Logique métier...
      hitrace.finishTrace("TraceDefilement", 77);
    })
  }
}

// Recommandé : logique métier sans trace
@Entry
@Component
struct ScrollExempleOptimise {
  private elements: number[] = [1, 2, 3, 4, 5];

  build() {
    List() {
      ForEach(this.elements, (val: number) => {
        ListItem() {
          Text(`Élément ${val}`)
        }
      }, (val: number) => val.toString())
    }
    .onScroll(() => {
      // Logique métier uniquement
    })
  }
}

Éviter les journaux dans les rappels fréquents

L'écriture de journaux (hilog) et l'accès à l'état dans ces rappels génèrent une surcharge. Il faut les retirer des fonctions appelées très fréquemment.

// À éviter : journalisation dans onScroll
@Entry
@Component
struct JournalScrollIncorrect {
  private donnees: number[] = [1, 2, 3];

  build() {
    List() {
      ForEach(this.donnees, (item: number) => {
        ListItem() { Text(`Ligne ${item}`) }
      }, (item: number) => item.toString())
    }
    .onScroll(() => {
      hilog.info(77, 'Scroll', `Événement de défilement`);
      // Logique métier...
    })
  }
}

// Recommandé : sans journal inutile
@Entry
@Component
struct JournalScrollOptimise {
  private items: number[] = [1, 2, 3];

  build() {
    List() {
      ForEach(this.items, (i: number) => {
        ListItem() { Text(`Ligne ${i}`) }
      }, (i: number) => i.toString())
    }
    .onScroll(() => {
      // Logique métier sans journal superflu
    })
  }
}

Suppression des Traces et Journaux Redondants

Les traces et journaux consomment des ressources. Il faut supprimer les traces dans les versions de production (Release) et éviter les journaux de débogage, même si leur niveau est désactivé, car la concaténation des paramètres est touojurs évaluée.

Retirer les traces en production

Les appels à hitrace doivent être retirés des builds de release pour éviter toute surcharge inutile.

// À éviter : trace dans la version de production
@Component
struct TraceProductionInutile {
  aboutToAppear(): void {
    hitrace.startTrace("TAG_APP", 88);
    // Code métier...
    hitrace.finishTrace("TAG_APP", 88);
  }
  build() { /*...*/ }
}

// Recommandé : trace retirée
@Component
struct TraceProductionOptimise {
  aboutToAppear(): void {
    // Code métier sans trace
  }
  build() { /*...*/ }
}

Retirer les journaux de débogage en production

Bien que les journaux de niveau debug ne soient pas imprimés en release, la construction des chaînes de caractères dans leurs paramètres entraîne un coût. Il faut donc les supprimer.

// À éviter : concaténation dans un journal debug
@Component
struct JournalDebugInutile {
  @State premierTexte: string = 'Bonjour';
  @State secondTexte: string = 'Monde';

  aboutToAppear(): void {
    hilog.debug(88, 'Debug', this.premierTexte + this.secondTexte);
    // Code métier...
  }
  build() { /*...*/ }
}

// Recommandé : journal supprimé
@Component
struct JournalDebugOptimise {
  aboutToAppear(): void {
    // Code métier sans journal debug
  }
  build() { /*...*/ }
}

Éviter les Écouteurs de Rappel Système Superflus

Enregistrer des écouteurs inutiles, comme onAreaChange, oblige le système à calculer et communiquer des changements même si l'écouteur ne fait rien, ce qui génère une surcharge inutile.

// À éviter : onAreaChange inutile
@Component
struct EcouteurInutile {
  build() {
    Button('Action', { type: ButtonType.Capsule })
      .onClick(() => {
        // Logique métier
      })
      .onAreaChange((ancien: Area, nouveau: Area) => {
        // Aucune opération, mais le calcul est fait par le système
      })
  }
}

// Recommandé : écouteur retiré
@Component
struct EcouteurOptimise {
  build() {
    Button('Action', { type: ButtonType.Capsule })
      .onClick(() => {
        // Logique métier
      })
  }
}

Utilisation d'Outils de Profilage

Pour identifier et localiser précisément les goulots d'étarnglement, l'utilisation d'outils de profilage dédiés est essentielle.