Kognitive Komplexität

Titel Kurzform

Kognitive Komplexität

Kategorien

Wartbarkeit

Definition

Summe der Teilkomplexitäten, die sich beispielsweise durch Verzweigungen im Kontrollfluss der POU und durch komplexe boolesche Ausdrücke ergeben

Weitere Informationen

Die kognitive Komplexität ist ein Maß für die Lesbarkeit und Verständlichkeit von Quellcode, das von Sonarsource™ im Jahr 2016 eingeführt wurde. Sie bestraft eine starke Verschachtelung des Kontrollflusses und komplexe boolesche Ausdrücke. Die kognitive Komplexität wird nur für strukturierte Textimplementierungen berechnet.

Standardobergrenze für die zugehörige Regel SA0178: Kognitive Komplexität

20

Kognitive Komplexität 1:

Tipp

Mit dem Befehl 'Kognitive Komplexität für aktuellen Editor anzeigen' können Sie die Inkremente für strukturierten Text zusätzlich direkt im Editor anzeigen.

Die folgenden Beispiele zeigen, wie die kognitive Komplexität berechnet wird.

Beispiel: Kontrollfluss

Anweisungen, die den Kontrollfluss manipulieren, erhöhen die kognitive Komplexität um 1.

IF TRUE THEN              //+1 cognitive complexity
    ;
END_IF
 
WHILE TRUE DO             //+1 cognitive complexity
    ;
END_WHILE
 
FOR i := 0 TO 10 BY 1 DO  //+1 cognitive complexity
    ;
END_FOR
 
REPEAT                    //+1 cognitive complexity
    ;
UNTIL TRUE
END_REPEAT

Der Codeschnipsel hat eine kognitive Komplexität von 4.

 

Beispiel: Verschachtelung des Kontrollflusses

Bei der Verschachtelung des Kontrollflusses wird für jede Stufe der Verschachtelung ein Inkrement von 1 hinzugefügt.

IF TRUE THEN                      //+1 cognitive complexity
    WHILE TRUE DO                 //+2 (+1 for the loop itself, +1 for the nesting inside the IF)
        FOR i := 0 TO 10 BY 1 DO  //+3 (+1 for the FOR loop itself, +2 for the nesting inside the WHILE and the IF)
            ;
        END_FOR
    END_WHILE

    REPEAT                        //+2 (+1 for the loop itself, +1 for the nesting inside the IF)
        ;
    UNTIL TRUE
    END_REPEAT
END_IF

Der Codeschnipsel hat eine kognitive Komplexität von 8.

 

Beispiel: Boolescher Ausdruck

Da boolesche Ausdrücke eine große Rolle beim Verständnis von Quellcode spielen, werden sie auch bei der Berechnung der kognitiven Komplexität berücksichtigt.

Das Verständnis von booleschen Ausdrücken, die mit demselben booleschen Operator verbunden sind, ist nicht so schwierig wie das Verständnis eines booleschen Ausdrucks, der alternierende boolesche Operatoren enthält. Daher erhöht jede Kette von gleichen booleschen Operatoren in einem Ausdruck die kognitive Komplexität.


b := b1;                             //+0: a simple expression, containing no operators, has no increment

Der einfache Ausdruck ohne Operator hat ein Inkrement von 0.

 

b := b1 AND b2;                      //+1: one chain of AND operators

Der Ausdruck mit einer AND-Verknüpfung hat ein Inkrement von 1.

 


b := b1 AND b2 AND b3;               //+1: one more AND, but the number of chains of operators does not change

Der Ausdruck hat ein AND mehr. Aber da es der gleiche Operator ist, ändert sich die Anzahl der mit identischen Operatoren gebildeten Kette nicht.

 

b := b1 AND b2 OR b3;                //+2: one chain of AND operators and one chain of OR operators

Der Ausdruck hat eine Kette von AND-Operatoren und eine Kette von OR-Operatoren. Das ergibt ein Inkrement von 2.

 


b := b1 AND b2 OR b3 AND b4 AND b5;  //+3: one chain of AND operators, one chain of OR operators and another chain of AND operators

Der Codeschnipsel hat ein Inkrement von 3.

 


b := b1 AND NOT b2 AND b3;           //+1: the unary NOT operator is not considered in the cognitive complexity

Der unäre Operator NOT wird bei der kognitiven Komplexität nicht berücksichtigt.

 

Beispiel: Weitere Anweisungen mit Inkrement

Strukturierter Text hat zusätzliche Anweisungen und Ausdrücke, die den Kontrollfluss verändern.

Die folgenden Anweisungen werden mit einem Inkrement der kognitiven Komplexität bestraft:

aNewLabel:
    x := MUX(i, a,b,c);  //+1 for MUX operator
    y := SEL(b, i,j);    //+1 for SEL operator
JMP aNewLabel;           //+1 for JMP to label

EXIT- und RETURN-Anweisungen erhöhen nicht die kognitive Komplexität.