Traitement Efficace des Données

Jusqu'à présent, tout a été traité cellule par cellule — suffisant pour cinq commandes, extrêmement lent pour cinquante mille. La solution consiste à ne plus manipuler la feuille cellule par cellule, mais à transférer tout le bloc dans un tableau en mémoire, à y effectuer les traitements, puis à le réécrire en une seule opération.

Lecture d'une plage dans un tableau

Dim dataArr As Variant
dataArr = ws.Range("A2:I6").Value    ' one read, not 45 individual reads

dataArr est désormais un tableau 2D en mémoire : dataArr(1,1) correspond à ORD1001, dataArr(1,4) à "Laptop Stand", etc. — les tableaux VBA lus depuis une plage sont indexés à partir de 1, et non de 0, ce qui est une source fréquente d'erreur.

Traitement du tableau

S'effectue avec des boucles classiques — mais cette fois, la boucle s'effectue en mémoire, ce qui est des milliers de fois plus rapide que de boucler sur la feuille de calcul :

Dim i As Long
Dim recalculated As Double
 
For i = 1 To UBound(dataArr, 1)
    recalculated = dataArr(i, 5) * dataArr(i, 6) * (1 - dataArr(i, 7))
    If Abs(recalculated - dataArr(i, 8)) > 0.01 Then
        Debug.Print "Mismatch on row " & i & ": sheet says " & dataArr(i, 8) & _
                    ", recalculated " & Format(recalculated, "0.00")
    End If
Next i

Réécriture du tableau

Là encore, une seule opération :

ws.Range("A2:I6").Value = dataArr

Éviter Select et Activate

Les macros enregistrées s'appuient fortement sur ces commandes (Range("A1").Select puis Selection.Font.Bold = True), mais elles sont inutiles et lentes — chaque .Select force Excel à redessiner l'écran. Référencez directement la plage ou l'objet à la place :

' Avoid:
ws.Range("A1").Select
Selection.Font.Bold = True
 
' Prefer:
ws.Range("A1").Font.Bold = True

Considérations de performance

Ces aspects deviennent importants dès que vos données dépassent quelques centaines de lignes :

Application.ScreenUpdating = False   ' stop redrawing while the macro runs
Application.Calculation = xlCalculationManual   ' pause recalculation
Application.EnableEvents = False     ' suppress other macros triggering mid-run
 
' ... your fast array-based code here ...
 
Application.ScreenUpdating = True
Application.Calculation = xlCalculationAutomatic
Application.EnableEvents = True

Toujours restaurer ces paramètres à la fin — et encapsuler la restauration dans une gestion d'erreur pour éviter qu'un plantage en cours d'exécution ne laisse Excel avec l'affichage désactivé.

Exemple pratique : le vérificateur d'intégrité des commandes

Ce chapitre aboutit à ceci :

Option Explicit
 
Sub VerifyOrderTotals()
    Dim ws As Worksheet
    Dim dataArr As Variant
    Dim lastRow As Long
    Dim i As Long
    Dim recalculated As Double
    Dim issues As String
 
    Set ws = ThisWorkbook.Worksheets("Orders")
    lastRow = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row
 
    Application.ScreenUpdating = False
 
    dataArr = ws.Range("A2:I" & lastRow).Value
    issues = ""
 
    For i = 1 To UBound(dataArr, 1)
        recalculated = dataArr(i, 5) * dataArr(i, 6) * (1 - dataArr(i, 7))
        If Abs(recalculated - dataArr(i, 8)) > 0.01 Then
            issues = issues & dataArr(i, 1) & ": sheet=" & dataArr(i, 8) & _
                      ", expected=" & Format(recalculated, "0.00") & vbNewLine
        End If
    Next i
 
    Application.ScreenUpdating = True
 
    If issues = "" Then
        MsgBox "All " & UBound(dataArr, 1) & " order totals check out."
    Else
        MsgBox "Discrepancies found:" & vbNewLine & issues
    End If
End Sub

Exécutez ce code sur la table d'exemple et il devrait indiquer que les cinq totaux sont corrects — essayez de modifier le Total de ORD1002 dans la feuille avec une valeur erronée puis relancez pour voir l'alerte s'afficher.

Tâche

1. Copier VerifyOrderTotals dans votre classeur et l'exécuter sur les cinq commandes d'exemple.
2. Modifier manuellement le Total d'une commande sur la feuille (saisir une valeur manifestement incorrecte) puis relancer — vérifier que l'écart est bien signalé avec le bon Order ID.
3. Ajouter dix lignes supplémentaires de commandes fictives sous la ligne 6, et vérifier que la macro fonctionne toujours sans modification du code — c'est l'intérêt de lastRow et du traitement par tableau.