JavaScript - CustomHash

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • JavaScript - CustomHash

    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

    PHP-Code:
    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(Counter1);
            
            
    Counter++;
        }
        
        while((
    WorkingSource.length 32) != 0) {
            
    WorkingSource WorkingSource.substr(0WorkingSource.length 1);
        }
        
        var 
    CharsPerPart WorkingSource.length 32;
        for(var 
    032i++) {
            var 
    SubPart WorkingSource.substr(i*CharsPerPartCharsPerPart);
            var 
    PartCode 0;
            for(var 
    0SubPart.lengthj++) {
                
    PartCode PartCode HashBase.indexOf(SubPart.substr(j1));
            }
            
            if(
    != 0) {
                
    PartCode PartCode*i;
            }
            
            
    PartCode PartCode HashBase.indexOf(Hash.length1) * Source.length;
            
            while(
    PartCode HashBase.length) {
                
    PartCode PartCode HashBase.length;
            }
            
            while(
    PartCode 0) {
                
    PartCode++;
            }
            
            if(
    HashBase.substr(PartCode1) == 'undefined') { 
                
    Hash Hash HashBase.substr(i1);
            } else {
                
    Hash Hash HashBase.substr(PartCode1);
            }
        }
        
        return 
    Hash;

    [FONT="Helvetica"]twitter.com/unset[/FONT]

    Shitstorm Podcast – Wöchentliches Auskotzen

  • #2
    ok also erstmal: coole sache!
    aber folgendes ist mir doch aufgefallen:
    dieser codeabschnitt
    Code:
        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:
    Code:
             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:
    Code:
             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:
    Code:
        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 !? :
    Code:
        while((WorkingSource.length % 32) != 0) {
            WorkingSource = WorkingSource.substr(0, WorkingSource.length - 1);
        }
    Code:
            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.
    Code:
    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?
    Zuletzt geändert von frodenius; 12.03.2008, 21:30.
    blllubb

    Kommentar


    • #3
      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.
      blllubb

      Kommentar

      Lädt...
      X