JavaScript unique array

Von in javascript

In Java­Script sucht man ver­geb­lich nach einer Metho­de, die Dupli­ka­te aus einem Array ent­fernt, ähn­lich wie zum Bei­spiel in PHP die Funk­ti­on array_​unique(). Ich möch­te hier zei­gen, wie man rela­tiv ein­fach dop­pel­te Wer­te eli­mi­nie­ren kann und wel­che Rol­le die Anwei­sung “con­ti­nue” in Kom­bi­na­ti­on mit “Labels” dabei hat.

Fol­gen­des Array steht zur Diskussion:

var notUniqueArray = new Array('a','b','c','a','d');

In einer Funk­ti­on sol­len nun Ein­trä­ge ent­fernt wer­den, die mehr­mals im Array vor­kom­men, im Bei­spiel also “a”.
Für unser Vor­ha­ben sind zwei Ver­fah­ren nötig: Wir müs­sen ein neu­es Array bau­en und müs­sen über bei­de Arrays ver­schach­telt ite­rie­ren. Das könn­te fol­gen­der­ma­ßen aussehen:

function jsUniqueArray (notUniqueArray) {

    // neues Array deklarieren
    var uniqueArray = new Array();

    // erste Schleife
    for (var s = 0; s < notUniqueArray.length; s++ ){

        // zweite Schleife
        for(var t = 0; t < uniqueArray.length; t++ ){

        }

    }

    // Rückgabe
    return uniqueArray;

}

Nun feh­len nur noch eine Bedin­gung und eine Zuwei­sung: Wer­den beim Ite­rie­ren Wer­te gefun­den, die in einem vor­he­ri­gen Durch­gang bereits auf­ge­tre­ten sind, wird die Zuwei­sung des Wer­tes in das neue Array ver­hin­dert, ansons­ten wird der neue Wert ein­ge­tra­gen (die Zuwei­sung steht bewusst außer­halb der zwei­ten Schlei­fe und nicht in der Bedin­gung. Erklä­rung sie­he wei­ter unten):

function jsUniqueArray (notUniqueArray) {

    // neues Array deklarieren
    var uniqueArray = new Array();

    // erste Schleife
    for (var s = 0; s < notUniqueArray.length; s++ ){

        // zweite Schleife
        for(var t = 0; t < uniqueArray.length; t++ ){

            // Bedingung
            if (uniqueArray[t] == notUniqueArray[s]) {

            }

        }

        // Zuweisung
        uniqueArray[uniqueArray.length] = notUniqueArray[s];

    }

    // Rückgabe
    return uniqueArray;

}

Hier stellt sich nun die Fra­ge der Schlei­fen­steue­rung bei mehr­fach auf­tre­ten­den Wer­ten. Eine Mög­lich­keit wäre, in einer Bedin­gung ent­we­der den Wert an das neue Array zu über­ge­ben, oder den Schlei­fen­zäh­ler “s” um einen Wert zu erhö­hen und den Schlei­fen­zäh­ler “t” auf die Key-​Anzahl des Arrays uni­queAr­ray zu set­zen. Damit bricht die zwei­te Schlei­fe ab und die ers­te Schlei­fe behan­delt den nächs­ten Wert. Das klingt genau so kom­pli­ziert, wie es ist. Und lässt sich viel ein­fa­cher lösen: Schlei­fen las­sen sich mit “break” und “con­ti­nue” steu­ern (SELFHTML) und was noch viel wich­ti­ger ist: Das funk­tio­niert auch über ver­schie­de­ne Schleifen-​Levels hin­weg! Für unse­re Funk­ti­on bedeu­tet das:

function jsUniqueArray (notUniqueArray) {

    // neues Array deklarieren
    var uniqueArray = new Array();

    // erste Schleife
    first_loop:
    for (var s = 0; s < notUniqueArray.length; s++ ){

        // zweite Schleife
        second_loop:
        for(var t = 0; t < uniqueArray.length; t++ ){

            // Bedingung
            if (uniqueArray[t] == notUniqueArray[s]) {
                continue first_loop;
            }

        }

        // Zuweisung
        uniqueArray[uniqueArray.length] = notUniqueArray[s];

    }

    // Rückgabe
    return uniqueArray;

}

Erklä­rung:
Mit “con­ti­nue first_​loop;” wird die zwei­te Schlei­fe unter­bro­chen und die ers­te Schlei­fe sofort wie­der vom Beginn an gestar­tet, was auto­ma­tisch eine Erhö­hung des Schlei­fen­zäh­lers der ers­ten Schlei­fe zur Fol­ge hat. Jeg­li­cher Code nach der Anwei­sung “con­ti­nue first_​loop;” wird also NICHT mehr aus­ge­führt! Die genaue Funk­ti­ons­wei­se von “con­ti­nue” wird ver­ständ­li­cher, wenn man statt­des­sen “break;” ver­wen­det: Zwar wird bei einem Dupli­kat die zwei­te Schlei­fe unter­bro­chen, jedoch der Code danach noch immer aus­ge­führt: Es kommt zur Zuwei­sung in das neue Array und das Resul­tat der Funk­ti­on gleicht damit dem Aus­gangs­wert. Auch ein “break second_​loop;” oder “break first_​loop;” führt nicht zum gewünsch­ten Ergeb­nis: Ers­te­res ändert nichts am über­ge­be­nen Array und ein “break first_​loop;” bricht die Funk­ti­on kom­plett ab, sobald ein Dupli­kat gefun­den wurde.

Seit Java­Script 1.2 kön­nen Schlei­fen mit einem “Label” ver­se­hen (in unse­rem Bei­spiel also “first_​loop” und “second_​loop”) und mit “con­ti­nue” oder “break” ange­spro­chen wer­den, was eine sehr kon­trol­lier­te Fluss-​Steuerung ver­schach­tel­ter Schlei­fen ermög­licht. tutorialspoint.com erklärt das sehr schön in einem Artikel.

Share on LinkedInShare on Redditshare on TumblrShare on StumbleUponDigg thisShare on FacebookGoogle+Tweet about this on TwitterEmail to someone