JavaScript - CustomHash

[unset]

Ahoy,

für ein kleines Projekt benötige ich derzeit die Möglichkeit, bestimmte Elemente im DOM im Nachhinein wieder identifizieren zu können. Das komplette Element abspeichern ist nicht möglich. Ebenfalls haben Elemente nicht immer IDs oder Namen. Auszugehen ist jedoch davon, dass Sie immer den selben Inhalt haben werden. Um die Elemente nun wieder zu finden, habe ich mir überlegt, ermittel ich einen Fingerprint oder Hashwert, anhand dessen Sie im DOM wieder zu finden sind. Ach ja, und MD5 ist schlicht zu lahmarschig (gefühl ca. 4 mal langsamer).

Ich hab hier mal eine rudimentäre Funktion geschrieben. Was haltet ihr davon? Anregungen? Kritik? Ach, und wer Sie braucht: Bitte, lizensiert unter der GPL

function hash(Source) {
    var HashBase = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
    var WorkingSource = Source;
    var Hash = '';
    
    var Counter = 0;
    while((WorkingSource.length % 32) != 0) {
        if(Counter > WorkingSource.length) {
            Counter = 0;
        }
        
        WorkingSource = WorkingSource + WorkingSource.substr(Counter, 1);
        
        Counter++;
    }
    
    while((WorkingSource.length % 32) != 0) {
        WorkingSource = WorkingSource.substr(0, WorkingSource.length - 1);
    }
    
    var CharsPerPart = WorkingSource.length / 32;
    for(var i = 0; i < 32; i++) {
        var SubPart = WorkingSource.substr(i*CharsPerPart, CharsPerPart);
        var PartCode = 0;
        for(var j = 0; j < SubPart.length; j++) {
            PartCode = PartCode + HashBase.indexOf(SubPart.substr(j, 1));
        }
        
        if(i != 0) {
            PartCode = PartCode*i;
        }
        
        PartCode = PartCode + HashBase.indexOf(Hash.length, 1) * Source.length;
        
        while(PartCode > HashBase.length) {
            PartCode = PartCode - HashBase.length;
        }
        
        while(PartCode < 0) {
            PartCode++;
        }
        
        if(HashBase.substr(PartCode, 1) == 'undefined') { 
            Hash = Hash + HashBase.substr(i, 1);
        } else {
            Hash = Hash + HashBase.substr(PartCode, 1);
        }
    }
    
    return Hash;
} 

[frodenius]

ok also erstmal: coole sache!
aber folgendes ist mir doch aufgefallen:
dieser codeabschnitt

    var Counter = 0;
    while((WorkingSource.length % 32) != 0) {
        if(Counter > WorkingSource.length) {
            Counter = 0;
        }
        
        WorkingSource = WorkingSource + WorkingSource.substr(Counter, 1);
        
        Counter++;
    }

verlängert den string bis seine länge durch 32 glatt teilbar ist.
sehr einfach und daher elegant.
aber erstmal:

         WorkingSource = WorkingSource + WorkingSource.substr(Counter, 1);

erstellt einen neuen string, kopiert den ganzen alten und fügt nur EIN zeichen hinten an.
also wäre schon folgendes besser:

         WorkingSource += WorkingSource.substr(Counter, 1);

denn javascript kopiert tatsächlich den ganzen string in einen neuen und löscht danach erst den alten.. sowas und anderes macht die langsamkeit der heutigen implementierungen aus.
dann hat mich auch diese schleife gestört, die immer nur 1 zeichen anhängt.. im schlimmsten fall also 31 mal eine string-operation.
ich hab mal ein bisschen loop unrolling gemacht und folgendes ist rausgekommen:

    var LMod32 = WorkingSource.length % 32;
    if(LMod32){
    	if(WorkingSource.length > 32){
    		WorkingSource += WorkingSource.substr(0, LMod32);
    	}else{
                // anzahl zeichen bis länge 32
    		var chars_needed = 32 - WorkingSource.length; 
    		// wie oft passt WorkingSource noch in die restlichen zeichen
    		var f = Math.floor(chars_needed/WorkingSource.length); 
                WorkingSource += new Array(f+1).join(WorkingSource) +
                                 WorkingSource.substr(0,chars_needed % WorkingSource.length);
    	}
    }

kommt komplett ohne schleife (zumindest in js) aus und ist etwa 7 mal schneller.
(hat aber auch doppelt so viel zeichen..)
nach dem angleichen der länge auf ein vielfaches von 32 ist folgender code doch obsolet !? :

    while((WorkingSource.length % 32) != 0) {
        WorkingSource = WorkingSource.substr(0, WorkingSource.length - 1);
    }

        while(PartCode > HashBase.length) {
            PartCode = PartCode - HashBase.length;
        }
        
        while(PartCode < 0) {
            PartCode++;
        }

das ist doch eigentlich nichts anderes als PartCode % HashBase.length bzw wenn PartCode neg. ist PartCode auf 0 setzen.

if(PartCode < 0)
    PartCode = 0;
else
    PartCode = PartCode % HashBase.length;

und dass HashBase.substr(PartCode,1) 'undefined' sein kann, ist für mich nicht nachvollziehbar.

ansonsten kann ich noch keine aussage über kollisionen oder so machen, hab auch nicht so ahnung von.

und wieso kannst du nicht einfach eine referenz auf das DOM-element speichern?

[frodenius]

oh mein gott was habe ich gestern nur für bullshit geschrieben..
x += y wird immer zu x = x +y erweitert.
und außerdem ist die optimierung vollkommen überflüssig, da marginal.