1. Dashboard
  2. Mitglieder
    1. Letzte Aktivitäten
    2. Benutzer online
    3. Team
    4. Mitgliedersuche
  3. Forenregeln
  4. Forum
    1. Unerledigte Themen
  • Anmelden
  • Registrieren
  • Suche
Alles
  • Alles
  • Artikel
  • Seiten
  • Forum
  • Erweiterte Suche
  1. AutoIt.de - Das deutschsprachige Forum.
  2. Mitglieder
  3. AspirinJunkie

Beiträge von AspirinJunkie

  • Strings nach Länge sortieren (_ArraySortStringLen)

    • AspirinJunkie
    • 16. März 2022 um 16:29
    Zitat von Oscar

    Allerdings treten ein paar Merkwürdigkeiten auf:

    Das StringCompare musst du auf die Strings machen - nicht auf die Längen ;)

  • Strings nach Länge sortieren (_ArraySortStringLen)

    • AspirinJunkie
    • 16. März 2022 um 15:33

    Genau für solche Fälle wo ich mir nicht immer extra spezielle Sortierfunktion schreiben will, habe ich mir eine flexible Sortierfunktion geschrieben, bei der man einfach die Vergleichsfunktion durch eine selbstdefinierte austauschen kann.
    Die eigentliche Sortierung ist dann noch entsprechend optimiert, so dass man am Ende zu einer schnellen Lösung kommt ohne jedesmal das Rad neu erfinden zu müssen.

    Die Funktion findest du in der >>DynArray-UDF<<.

    Mit dieser würde dein Beispiel dann z.B. so gelöst werden:

    AutoIt
    #include <GUIConstantsEx.au3>
    #include <GuiListView.au3>
    #include <WindowsConstants.au3>
    #include "DynArray.au3"
    
    
    Global $sFile = @ScriptDir & '\autocomplete.txt'
    Global $aWords = StringSplit(FileRead($sFile), @CRLF, 3)
    
    Global $iTimer = TimerInit()
    _ArraySortFlexible($aWords, cbByLength)
    Global $iDiff = TimerDiff($iTimer) / 1000
    
    ConsoleWrite(StringFormat('Wörter: %i\r\nZeit: %.03f s\r\n', UBound($aWords), $iDiff))
    _ArrayShow($aWords)
    
    
    ; eigene Vergleichsfunktion für _ArraySortFlexible
    Func cbByLength(ByRef $A, ByRef $B)
        Local $nA = StringLen($A), $nB = StringLen($B)
        Return $nA = $nB ? 0 : $nA > $nB ? -1 : 1
    EndFunc
    
    
    
    ; Funktion zum Anzeigen des Arrays
    Func _ArrayShow(ByRef $aData, $sTitle = 'ArrayShow')
        Local $hGui = GUICreate($sTitle, 540, @DesktopHeight - 140, -1, 10, BitOR($GUI_SS_DEFAULT_GUI, $WS_SIZEBOX))
        Local $idLV = GUICtrlCreateListView('Row|Data', 5, 5, 530, @DesktopHeight - 150)
        GUICtrlSetFont(-1, 12, 400, 0, 'Courier New')
        GUICtrlSetResizing(-1, $GUI_DOCKBORDERS)
        _GUICtrlListView_JustifyColumn($idLV, 0, 1)
        _GUICtrlListView_BeginUpdate($idLV)
        For $i = 0 To UBound($aData) - 1
            GUICtrlCreateListViewItem($i & '|"' & $aData[$i] & '"', $idLV)
        Next
        _GUICtrlListView_SetColumnWidth($idLV, 0, $LVSCW_AUTOSIZE)
        _GUICtrlListView_SetColumnWidth($idLV, 1, $LVSCW_AUTOSIZE)
        _GUICtrlListView_EndUpdate($idLV)
        GUISetState()
        Do
        Until GUIGetMsg() = -3
        GUIDelete($hGui)
    EndFunc   ;==>_ArrayShow
    Alles anzeigen

    Und die Performance dabei ist bei mir um ca. Faktor 4 schneller.

  • AutoIt 3.3.16.0 ist zur Welt gekommen ...

    • AspirinJunkie
    • 10. März 2022 um 14:18

    Naja so wie ich Jon verstanden habe, sind Maps zwar im Release mit drin, aber immer noch mit dem Status "experimentell".
    Sprich: Kein Support und es kann jederzeit mit der nächsten Version wieder raus fliegen.

    Aus dem Grund schweigen sich die Release-Notes zum Thema Maps auch aus.
    Maps sind also nur inoffiziell drin.

  • [Wettbewerb] String komprimieren

    • AspirinJunkie
    • 10. März 2022 um 08:28
    Zitat von Oscar

    Die Länge beträgt nun 6033 Bytes und befindet sich in der Datei "original.txt" im ZIP-Archiv.

    Eigentlich sind es nicht 6033 Bytes sondern 6033 Zeichen.

    Da die Kodierung der Datei UTF-8 ist und einige Zeichen außerhalb des ASCII-Bereiches enthalten sind, wird für einige Zeichen mehr als 1 Byte benötigt.

    Der String hat daher eine tatsächliche Größe von 6105 Bytes.

    Man könnte daher schon alleine durch die Umkodierung in ISO 8859-2 1,2% Dateigröße einsparen.

    In der Bewertung hier würde dies jedoch nicht honoriert werden, da diese ausschließlich auf die Zeichenanzahl abstellt.

    Noch wilder würde es, wenn man diesen Umstand ausnutzt und den großen Wertebereich von UTF-32 nimmt um jeweils 4 Ausgangszeichen in nur ein einziges UTF-32-Zeichen zusammenzufassen (analog geht auch UTF-16).
    Auf diese Weise würde man hier als wahrscheinlicher Sieger vom Platz gehen, da wir nur noch 25% soviele Zeichen haben, obwohl die Dateigröße nahezu gleich bleibt.

    Daher plädiere ich dafür, die Bewertung komplett von der Zeichenlänge zu entkoppeln und nur die resultierende Dateigröße als Bewertungsmaßstab zu verwenden.

    Mal zur Verdeutlichung - Folgende 2 Funktionen:

    AutoIt
    Func _StringCompress($sString)
        Return BinaryToString(StringToBinary($sString & (Mod(StringLen($sString), 2) ? Chr(0) : ""), 4), 2)
    EndFunc
    
    Func _StringDecompress($vCompress)
        Return BinaryToString(StringToBinary($vCompress, 2), 4)
    EndFunc

    würden zu einer Bewertungskompressionsrate von 49.395 % führen obwohl eine hieraus resultierende Datei genauso groß ist wie die Ausgangsdatei. (hier speziell sogar noch 3 Byte mehr, da die ungerade Anzahl an Bytes hier einfach nicht behandelt wurde)

  • Filter für FileListToArray

    • AspirinJunkie
    • 9. März 2022 um 11:25
    Zitat von Musashi

    Selbst ein zusätzliches ConsoleWrite setzt das @error-Makro zurück, obwohl in der Hilfe dazu kein ReturnValue angegeben wird.

    Kleine Einschränkung hierzu: Seit Version 3.3.16.0 >>wurde dieses Verhalten abgestellt<<.

  • Lesbar machen von "eb 04 af c2 bf a3"

    • AspirinJunkie
    • 8. März 2022 um 20:42

    Oh Klasse - du kannst Google benutzen :klatschen:

    Ich denke das war weniger die Intention von Alina...

  • Lesbar machen von "eb 04 af c2 bf a3"

    • AspirinJunkie
    • 8. März 2022 um 19:39
    Zitat von Alina

    ef be ad de

    Könnte Zufall sein - aber witzigerweise sollte dies deadbeef in little endian order entsprechen.
    Wenn das kein Zufall ist, dann ist das was wir hier sehen als little endian zu betrachten.
    Aber ab hier bin ich dann raus - das übersteigt meinen Horizont - das ist eher was für Andy und Konsorten.

  • [Wettbewerb] String komprimieren

    • AspirinJunkie
    • 4. März 2022 um 07:43

    Wie willst du Wörterbuch-komprimierte Daten austauschen wenn du das Wörterbuch nicht vorliegen hast?
    Das ist ja schlicht logisch, dass das Wörterbuch ein Bestandteil der Daten selbst ist.

    Würde man deiner Logik folgen, dann würde ich ein Wörterbuch nehmen mit einem einzigen Eintrag: Dem gesamten String.
    Dann bekomme ich jeden String auf 1 Byte runter komprimiert, da das Wörterbuch selbst ja nicht mit reingezählt wird.

  • Formel noch nicht gefunden : Ich liebe Menschen die nicht einmal für eine Krone mit denken (mitdenken ?) !

    • AspirinJunkie
    • 23. Februar 2022 um 23:26
    Zitat von Alina

    Wie setze ich das ganze mit AutoIt um ?

    Nun was genau haben wir hier genau?
    Es handelt sich bei der Aufgabe um ein lineares (nur Addition und Subtraktion), bestimmtes (genauso viel Gleichungen wie Unbekannte) Gleichungssystem.

    Um soetwas effizient und dynamisch mit einem Computer zu berechnen bietet es sich an das Problem aus Sicht der linearen Algebra (Vektor- und Matrizenrechnung) zu betrachten.

    Schauen wir uns die Sache mal genauer an. Wir haben folgendes Gleichungssystem:

    Code
    A - B         = 2
            C + D = 8
    A     + C     = 10
        B     + D = 6

    In Matrizenform geschrieben sieht dieses System folgendermaßen aus (optischer Vergleich zu oben beachten - dann wird das System klarer):

    Code
    ┌            ┐   ┌   ┐   ┌    ┐
    │ 1 -1  0  0 │   │ A │   │ 2  │
    │ 0  0  1  1 │ · │ B │ = │ 8  │
    │ 1  0  1  0 │   │ C │   │ 10 │
    │ 0  1  0  1 │   │ D │   │ 6  │
    └            ┘   └   ┘   └    ┘

    Oder um es allgemeiner und kürzer zu schreiben: A · x = b

    Im Grunde geht es jetzt so weiter wie man es aus der Schule kennt; Man muss die Gleichung nach x umstellen.

    Das sieht in der Grundform im Grunde exakt so aus wie in der skalaren Algebra - nämlich: x = A-1·b

    Im Grunde also einfach - nur was ist A-1?

    Das ist die sogenannte Inverse der Matrix A. Diese zu berechnen ist etwas eklig aber blöderweise genau das was wir noch zur Lösung brauchen.

    Ich habe mal geschaut und gestaunt, dass ich selbst noch keine Funktion hierfür vorliegen hatte.

    Im Englischen Forum habe ich dann zwei Funktionen gefunden die entweder falsche Ergebnisse liefern oder mit Fehler abstürzen.

    Die völlig übertriebene Eigen4AutoIt-Geschichte habe ich gar nicht erst angesehen.

    Stattdessen habe ich daher nun schnell eine Inversionsfunktion dahingerotzt. Warum betone ich das so? - die Funktion ist wirklich nur dahingeschludert und nicht auf alle Fälle hin getestet. Für diesen Fall hier bringt es erst einmal die richtigen Ergebnisse und zu Anschauungszwecken reicht es erst einmal - aber sauber ist sie eventuell noch nicht.

    Kurz - in AutoIt würde man dies z.B. folgendermaßen umsetzen:

    AutoIt
    #include <Array.au3>
    ; Grundgleichung A·x = b
    ; Gesucht: Parametervektor x
    ; Gleichung nach x umgestellt: x = A^-1 · b
    ; "A^-1" = "Inverse" der Matrix A
    
    ; Lösungsvektor b
    Global $b[] = [2, 8, 10, 6]
    
    ; A-Matrix:        A   B  C  D
    Global $A[][] = [ [1, -1, 0, 0], _
                      [0,  0, 1, 1], _
                      [1,  0, 1, 0], _
                      [0,  1, 0, 1]]
    
    ; Inverse A^-1 von A
    $A_Inv = _MatrixInverse($A)
    
    ; Parametervektor x = A · b
    $x = _MatrixVectorProduct($A_Inv, $b)
    _ArrayDisplay($x, "Ergebnis")
    
    
    
    Func _MatrixVectorProduct($A, $b)
        Local $nRows = UBound($A, 1), $nCols = UBound($A, 2)
    
        If UBound($A, 0) <> 2 Or UBound($b, 0) <> 1 Then Return SetError(1,0, Null)
        If $nCols <> UBound($b) Then Return SetError(2, 0, Null)
    
        Local $aP[$nRows]
    
        For $i = 0 To $nRows -1
            For $j = 0 To $nCols -1
                $aP[$i] += $A[$i][$j] * $b[$j]
            Next
        Next
    
        Return $aP
    EndFunc
    
    
    Func _MatrixInverse(ByRef $M)
        Local $N = UBound($M, 1)
        Local $A = $M
        Local $B[$N][$N]
        For $i = 0 To $N -1
            $B[$i][$i] = 1
        Next
    
        Local $p, $t, $f
        For $j = 0 To $N - 1
            $p = $j
            While $p <= $N And $A[$p][$j] = 0
                $p += 1
            WEnd
            If $p = $n +1 Then Return SetError(1,0,Null)
            If $p <> $j Then
                For $i = 0 To $N -1
                    $t = $A[$j][$i]
                    $A[$j][$i] = $A[$p][$i]
                    $A[$p][$i] = $t
    
                    $t = $B[$j][$i]
                    $B[$j][$i] = $B[$p][$i]
                    $B[$p][$i] = $t
                Next
            EndIf
    
            $f = $A[$j][$j]
            For $i = 0 To $N -1
                    $A[$j][$i] /= $f
                    $B[$j][$i] /= $f
            Next
    
            For $i = 0 To $N - 1
                If $i <> $j Then
                    $f = $A[$i][$j]
                    For $x = 0 To $N -1
                        $A[$i][$x] -= $f * $A[$j][$x]
                        $B[$i][$x] -= $f * $B[$j][$x]
                    Next
                EndIf
            Next
        Next
    
        Return $B
    EndFunc
    Alles anzeigen
  • Globale Variablen mit den gleichen daten werden anscheinend von Autoit zusammengefasst

    • AspirinJunkie
    • 17. Februar 2022 um 22:00
    Zitat von chesstiger

    Es gibt scheinbar Implementierungen von std::string, die über Referenzzähler eine Art Copy-on-Write realisieren.

    Je nach Version von libc++ kann das also automatisch passieren (Vgl Google-Suche nach "std string copy on write").

    Ja das wäre ja eine entsprechende Änderung die Jon vollzogen hätte.
    In den alten Quellcodes hat er für Strings noch C-Strings anstatt std:string verwendet.

    Da das aber auch meine erste Vermutung war habe ich kurz recherchiert und bin auf folgende Aussage gestoßen, nach der cow bei std:string wohl dem C++11-Standard wiedersprechen würde: https://stackoverflow.com/a/12199969

    Also entweder hat Jon das direkt in AutoIt implementiert oder den Varianttyp auf Grundlage einer Lib aufgebaut die das mitbringt.
    Ich bin mir jedoch relativ sicher, dass das Verhalten nicht von Windows kommt.

  • Globale Variablen mit den gleichen daten werden anscheinend von Autoit zusammengefasst

    • AspirinJunkie
    • 17. Februar 2022 um 21:06

    Naja die alten AutoIt-Versionen benutzen hierfür strcpy was auch nur ein Wrapper für memcpy ist.

    Vorher wird erst die Größe des Zuweisungsstrings bestimmt und mit der Info neuer Speicher für den Zielstring alloziert.
    Der Speicher wird also erstmal auf jeden Fall alloziert.

    Dann werden (per memcpy) die Inhalte vom einen Speicherbereich auf den anderen übertragen.

    Meines Wissens nach ist mit memcpy alleine kein cow machbar und ich wüsste auch nicht wie Windows da reingrätschen könnte um drumherum ein cow zu basteln.

  • Globale Variablen mit den gleichen daten werden anscheinend von Autoit zusammengefasst

    • AspirinJunkie
    • 17. Februar 2022 um 20:27

    Wenn du dich weiter einlesen möchtest: man nennt dieses Vorgehen "Copy-On-Write (COW)"

    Das bedeutet, dass für Daten beim Kopieren erst dann eine physische Kopie angefertigt wird, wenn die Daten verändert werden.

    Bei AutoIt hätte ich es spontan nicht erwartet, da man dies extra implementieren müsste (C-Strings und std:string bringen das nicht von Haus aus mit).
    Im alten AutoIt-Quellcode wird auch einfach nur strcpy() verwendet. Das Feature muss also später hinzugefügt worden sein.

    Bei Strings ist mir das auch bisher nicht geläufig gewesen. Wirklich spannend wird es aber wenn man das Prinzip bei Dateisystemen anwendet.
    Dann kann man ratz fatz Snapshots vom gesamten Dateisystem erstellen die nur ganz wenig overhead haben und kann so zwischen verschiedenen Zuständen der Daten hin und her springen. Die bekanntesten Vertreter dieser Dateisysteme sind BTRFS und ZFS.

    Edit: Chesstiger war schneller

  • Mehrfachbedingung vernünftig gestalten

    • AspirinJunkie
    • 11. Februar 2022 um 06:43

    Ich denke schon, dass er wusste, was die "&"-Methode bei ihm genau macht.
    Man sollte aber schon dazuschreiben, dass dies ein Hack für diesen absoluten Spezialfall hier - prüfe mehrere Variablen auf Leerstring - ist und keine allgemeine Lösung um eine verkettete logische And-Verknüpfung zu ersetzen.

    Nicht das JBO oder andere dass einfach damit ersetzen und das 100x gut geht (da eben der Spezialfall greift) und beim 101. mal alles auf einmal Probleme macht.

    Zitat von Lambdax

    if Not ($sA & $sB & $sC & $sD) Then

    ginge auch. Lief bei mir am schnellsten

    Da wir gerade bei Spezialfällen sind: Im konkreten Beispiel zieht keine short-curcuit-evaluation, da ja alle Teilbedingungen wahr sind.
    Kannst ja mal $sA = "1" setzen und nochmal testen.

    Und anschließend nochmal alle Variablen mit längeren Strings vorbelegen.

    Dann sollte das verkettete And die schnellste Variante sein.

    Es hängt also enorm vom konkreten Anwendungsfall ab (worüber wir keine Info haben) bevor man wirklich richtig optimieren kann.

  • Mehrfachbedingung vernünftig gestalten

    • AspirinJunkie
    • 9. Februar 2022 um 13:47

    Das ganze nennt sich short-curcuit evaluation und ist eine wichtige Form um die Performance zu beschleunigung.
    Der Ansatz ist simpel: Wenn schon die erste Seite eines Or-Operators wahr ist, dann braucht man nicht mehr die rechte Seite ausführen. Im Endeffekt wird der Gesamtausdruck nämlich immer wahr.

    Genauso bei "And": Wenn schon die linke Seite falsch ist, kann die Gesamtbedingung nicht mehr wahr werden - also braucht man die rechte Seite auch nicht mehr zu prüfen.

    Da wird auch schnell klar, dass deine Aussage:

    Zitat von JBO

    Laut der AutoIt-Hilfe werden die restlichen Bedingungen nicht mehr beachtet, wenn die erste Bedingung erfüllt ist.

    so nicht stimmt. Bei And werden die restlichen Bedingungen nicht mehr beachtet, wenn die erste Bedingung nicht erfüllt ist.

    Will man dies umgehen kann man halt kein And oder Or verwenden.

    Ein Hack wäre BitAnd oder BitOr zu verwenden. Die machen streng genommen etwas anderes, da aber alle diese Bedingungen nur 0 oder 1 zurückgeben kommt man damit dennoch zum selben Ergebnis:

    AutoIt
    If BitAND($sExcelFile == "", $sLevel1String == "", $sLevel2String == "") Then
  • CMD steuern

    • AspirinJunkie
    • 5. Februar 2022 um 11:35

    Wenn ein Befehl fertig ist bekommst du das im Grunde ja nur durch das Feedback im StdOut mit.
    Also z.B. dass die Eingabeaufforderung wieder erscheint oder (je nach Befehl) ein Rückmeldung erscheint.
    Du musst also StdOut auswerten nach dem du einen Befehl ausgefüht hast und daraus das Beenden des Befehles ableiten.

  • Funktion Assign

    • AspirinJunkie
    • 1. Februar 2022 um 18:46
    Zitat von Lambdax

    Ich habe zig tests gemacht mit Assign und Eval, man muss eben sorgfältig mit ihnen umgehen, aber im gegenzug bekommt man dafür sehr kurze schreib und zugriffszeiten.

    Assign/Eval wären tatsächlich bei der Zuweisung als auch dem Zugriff etwas schneller als das Scripting.Dictionary.
    Dies aber nur beim reinen Assign/Eval.
    Durch deine Verwaltungsfunktionen drumherum kehrt sich dies massiv um.

    Folgendes Testskript hierzu:

    AutoIt
    Global Const $N = 1e4
    
    Global $iT, $iDuration, $iDurationOffset, $iTmp
    
    $iT = TimerInit()
    For $i = 1 To $N
    Next
    $iDurationOffset = TimerDiff($iT)
    
    $iT = TimerInit()
    For $i = 1 To $N
        Assign("Var " & $i, $i)
    Next
    $iDuration = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s: %7.5f ms\n", "Assign", ($iDuration - $iDurationOffset) / $N))
    
    $iT = TimerInit()
    Global $oDic = ObjCreate("Scripting.Dictionary")
    For $i = 1 To $N
        $oDic("Var " & $i) = $i
    Next
    $iDuration = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s: %7.5f ms\n", "Dictionary Add", ($iDuration - $iDurationOffset) / $N))
    
    $iT = TimerInit()
    For $i = 1 To $N
        _storageS_Overwrite(123, "Var " & $i, $i)
    Next
    $iDuration = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s: %7.5f ms\n\n", "_storageS_Overwrite", ($iDuration - $iDurationOffset) / $N))
    
    
    
    $iT = TimerInit()
    For $i = 1 To $N
        $iTmp = Eval("Var " & $i)
    Next
    $iDuration = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s: %7.5f ms\n", "Eval", ($iDuration - $iDurationOffset) / $N))
    
    $iT = TimerInit()
    For $i = 1 To $N
        $iTmp = $oDic("Var " & $i)
    Next
    $iDuration = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s: %7.5f ms\n", "Dictionary Get", ($iDuration - $iDurationOffset) / $N))
    
    $iT = TimerInit()
    For $i = 1 To $N
        $iTmp = _storageS_Read(123, "Var " & $i)
    Next
    $iDuration = TimerDiff($iT)
    ConsoleWrite(StringFormat("% 20s: %7.5f ms\n\n", "_storageS_Read", ($iDuration - $iDurationOffset) / $N))
    
    
    Func _storageS_Overwrite($ElementGroup, $Element0, $Element1)
        Local $sVarName = "__storageS_" & $ElementGroup & $Element0
    
        ; we wont declare vars if $Element1 is False because _storageS_Read() always returns False and @error 1 on undeclared vars
        If $Element1 == False And Not IsDeclared($sVarName) Then Return 1
        If Not IsDeclared($sVarName) Then __storageS_AddGroupVar($ElementGroup, $Element0)
    
        Return Assign($sVarName, $Element1, 2)
    EndFunc   ;==>_storageS_Overwrite
    
    Func _storageS_Append($ElementGroup, $Element0, $Element1)
        Local $sVarName = "__storageS_" & $ElementGroup & $Element0
    
        If Not IsDeclared($sVarName) Then Return _storageS_Overwrite($ElementGroup, $Element0, $Element1)
    
        Return Assign($sVarName, Eval($sVarName) & $Element1, 2)
    EndFunc   ;==>_storageS_Append
    
    Func _storageS_Read($ElementGroup, $Element0)
        Local $sVarName = "__storageS_" & $ElementGroup & $Element0
    
        If Not IsDeclared($sVarName) Then Return SetError(1, 0, False)
        Return Eval($sVarName)
    EndFunc   ;==>_storageS_Read
    
    Func __storageS_AddGroupVar($ElementGroup, $Element0)
        If $ElementGroup = "StorageS" Then Return
    
        Local $arGroupVars = _storageS_Read("StorageS", $ElementGroup)
        If Not IsArray($arGroupVars) Then
            Local $arGroupVars[0]
        EndIf
    
        Local $nArSize = UBound($arGroupVars)
    
        ReDim $arGroupVars[$nArSize + 1]
        $arGroupVars[$nArSize] = $Element0
        _storageS_Overwrite("StorageS", $ElementGroup, $arGroupVars)
    EndFunc   ;==>__storageS_AddGroupVar
    
    Func _storageS_TidyGroupVars($ElementGroup)
        Local $arGroupVars = _storageS_Read("StorageS", $ElementGroup)
        If Not IsArray($arGroupVars) Then Return
    
        For $i = 0 To UBound($arGroupVars) - 1
            _storageS_Overwrite($ElementGroup, $arGroupVars[$i], Null)
        Next
    
        _storageS_Overwrite("StorageS", $ElementGroup, Null)
    EndFunc   ;==>_storageS_TidyGroupVars
    
    Func _storageS_DisplayGroupVars($ElementGroup)
        Local $arGroupVars = _storageS_Read("StorageS", $ElementGroup)
        If Not IsArray($arGroupVars) Then Return
    
        Local $nArSize = UBound($arGroupVars)
        Local $arGroupVars2D[$nArSize][3]
        Local $vData
    
        For $i = 0 To $nArSize - 1
            $arGroupVars2D[$i][0] = "__storageS_" & $ElementGroup & $arGroupVars[$i]
    
            $vData = _storageS_Read($ElementGroup, $arGroupVars[$i])
            $arGroupVars2D[$i][1] = VarGetType($vData)
            $arGroupVars2D[$i][2] = $vData
        Next
    
        Return $arGroupVars2D
    EndFunc   ;==>_storageS_DisplayGroupVars
    Alles anzeigen

    erbrachte bei mir folgende Ergebnisse:

    Code
                  Assign: 0.00415 ms
          Dictionary Add: 0.00902 ms
     _storageS_Overwrite: 2.96033 ms
    
                    Eval: 0.00193 ms
          Dictionary Get: 0.00443 ms
          _storageS_Read: 0.00971 ms

    Hauptgrund bei _storageS_Overwrite hierfür ist, dass die Elemente einzeln per ReDim hinzugefügt wird.
    Der Effekt steigt dort also exponentiell (oder quadratisch? - bin gerade nicht sicher) mit der Anzahl der Variablen.

    Man könnte zwar noch einiges rausholen, wenn man ein dynamisches Array verwendet aber ans Dictionary wird es auch dann nicht rankommen.

    Zitat von Lambdax

    ; sind sie jetzt wirklich gelöscht?

    ; nö, mir ist kein weg bekannt globale variablen zu löschen, aber mann kann sie mit Null überschreiben

    Exakt so wie du vermutest. Ein Überschreiben mit NULL löscht die Variable nicht.
    Das würde man nur erreichen, wenn es eine lokale Variable ist und der Scope (also die Funktion) beendet wird.
    Sprich: Mit jeder weiteren Variable steigt der Speicherverbrauch weiter bei dir, ohne dass du viel dagegen tun kannst, da die Variablen bei dir ja implizit global sind.

    Beispiel zur Verdeutlichung, dass NULL bei Assign den Speicherbereich nicht freiräumt:

    AutoIt
    #include <WinAPIConv.au3>
    
    Global Const $N = 1e5
    
    ; Variablen mit Assign schreiben
    For $i = 1 To $N
        Assign("Var " & $i, $i)
    Next
    $iWorkSetBefore = ProcessGetStats(@AutoItPID)[0]
    
    ; Variablen "löschen"
    For $i = 1 To $N
        Assign("Var " & $i, Null)
    Next
    $iWorkSetAfter = ProcessGetStats(@AutoItPID)[0]
    
    ConsoleWrite(" Vorher: " & _WinAPI_StrFormatByteSize($iWorkSetBefore) & @CRLF)
    ConsoleWrite("Nachher: " & _WinAPI_StrFormatByteSize($iWorkSetAfter) & @CRLF)
    Alles anzeigen

    Anders sieht es auch hier beim Dictionary-Objekt aus.
    Dort kann man tatsächlich die Speicherbereiche der Elemente freigeben:

    AutoIt
    #include <WinAPIConv.au3>
    
    Global Const $N = 1e5
    
    ; Dictionary befüllen
    Global $oDic = ObjCreate("Scripting.Dictionary")
    For $i = 1 To $N
        $oDic("Var " & $i) = $i
    Next
    $iWorkSetBefore = ProcessGetStats(@AutoItPID)[0]
    
    ; Dictionary einzeln leeren
    For $i = 1 To $N
        $oDic.Remove("Var " & $i)
    Next
    $iWorkSetAfter = ProcessGetStats(@AutoItPID)[0]
    
    ConsoleWrite(" Vorher: " & _WinAPI_StrFormatByteSize($iWorkSetBefore) & @CRLF)
    ConsoleWrite("Nachher: " & _WinAPI_StrFormatByteSize($iWorkSetAfter) & @CRLF)
    Alles anzeigen
  • Funktion Assign

    • AspirinJunkie
    • 1. Februar 2022 um 06:35
    Zitat von Lambdax

    Ich werde ausführlich testen müssen ob sich aus entweder dem dictobj oder den assosiativen arrays tatsächlich ein performance gewinn ergibt. Denn wenn ja dann lohnt sie die nutzung bestimmt.

    Performance ist hier gar nicht die Frage.
    Wenn ich dich richtig verstehe kreierst du zig globale Variablen dynamisch mit Assign?
    Über diese kannst du jedoch nicht iterieren. Sprich: Du weißt im Grunde nie genau, welche Variablen nun tatsächlich alle definiert sind.
    Das führt sicher irgendwann dazu, dass diese im Speicher verbleiben auch wenn sie nicht mehr gebraucht werden oder mal von einer anderen Funktion überschrieben werden die zufällig den selben Variablennamen verwendet usw.

    Bei kleinen Projekten vielleicht noch überschaubar - bei größeren Sachen auf jeden Fall Finger weg.

  • Funktion Assign

    • AspirinJunkie
    • 1. Februar 2022 um 05:51

    Da du globale Variablen ansprachst:

    Was bei einem Dictionary auch viele nicht wissen:
    Die AutoIt-Variable enthält lediglich eine Referenz (Pointer/Verweis) auf das Dictionary-Objekt und nicht das Objekt selbst.

    Daher kann man das gleiche Dictionary in verschiedenen Funktionen verwenden, ohne eine globale Variable zu verwenden:

    AutoIt
    B(A())
    A()
    
    Func A()
        Local Static $oDic = ObjCreate("Scripting.Dictionary")
    
        ; Zufallskey füllen:
        $oDic( Random(1,100,1) ) = "hat A() gefüllt"
    
        ; aktuellen Dictionary-Inhalt ausgeben:
        Local $sOut = ""
        For $sKey in $oDic.Keys
            $sOut &= $sKey & ": " & $oDic($sKey) & @CRLF
        Next
        MsgBox(0,"", $sOut)
    
        ; Pointer(!) auf Dictionary zurückgeben:
        Return $oDic
    EndFunc
    
    
    Func B($oTmp)
        ; B fügt ein weiteres Element dem Dictionary in Funktion A() hinzu
        $oTmp("B") = "Hat B() gefüllt"
    EndFunc
    Alles anzeigen

    Umgekehrt muss man dies natürlich auch beachten, wenn man mal tatsächlich eine Kopie und keinen Verweis eines bestehenden Dictionaries benötigt. In dem Fall muss man Helferlein wie diese Funktion bemühen:

    Code
    Func _cloneDictionary($oDic)
        Local $oRet = ObjCreate("Scripting.Dictionary")
    
        $oRet.CompareMode = $oDic.CompareMode
        For $sKey in $oDic.Keys
            $oRet($sKey) = $oDic($sKey)
        Next
    
        Return $oRet
    EndFunc
  • Funktion Assign

    • AspirinJunkie
    • 1. Februar 2022 um 05:13
    Zitat von Lambdax

    Vielleicht gibt es auch bessere und schnelle wege

    Ja: Assoziative Arrays wie das Scripting.Dictionary-Objekt oder der Datentyp Maps in den AutoIt-Betas.

  • Include UDFs versus Snippets einfügen (VSCode-AutoItSnippets)

    • AspirinJunkie
    • 26. Januar 2022 um 16:07

    Es gibt Tools, welche den Code nach verwendeten Funktionen durchforsten und die nichtverwendeten rausschmeißen.

    Das erste war damals Cleanscript von Pee.

    In wie weit das heute noch funktioniert müsste man testen.
    Eventuell Pee nach dem Quellcode fragen und entsprechend anpassen.

    Hab auch gehört, dass irgendwelche Obfuscator das auch können.
    Welche genau und wie weiß ich allerdings nicht, da ich diese nicht verwende.

    Diese Ansätze sollten deutlich besser sein, als sich bestimmte Funktionen daraus als Snippets reinzubauen.
    Zum einen bläht man sich eine Datei auf anstatt bestimmte Funktionalitäten in Module ausgelagert zu haben und zum anderen gibt es in UDFs auch oft zig Seitenabhängigkeiten wie z.B. zu bestimmten Konstanten oder anderen Funktionen.

    DIe Snippets so wie ich sie gerne in VSC nutze sind wirklich eher für wiederkehrende Programmkonstrukte wie schnell eine Zeitmessschleife oder ein Debug-Out oder sowas gedacht.

Spenden

Jeder Euro hilft uns, Euch zu helfen.

Download

AutoIt Tutorial
AutoIt Buch
Onlinehilfe
AutoIt Entwickler
  1. Datenschutzerklärung
  2. Impressum
  3. Shoutbox-Archiv
Community-Software: WoltLab Suite™