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

  • Datensätze als Array of struct speichern

    • AspirinJunkie
    • 13. Februar 2023 um 13:23
    Zitat von Moombas

    Ich wollte die '3' bei deiner Zeile 24 eben nicht, da ich diese "nicht weiß", sondern über die ID ermitteln und dann den zugehörigen tag .name ausgeben.

    Ich weiß. Deshalb habe ich bei der Erstellung der Map die ID als Key verwendet.
    Sprich: Wenn du auf das Element mit dem Key "3" zugreifst - erhälst du die Struktur mit der ID=3.

  • Datensätze als Array of struct speichern

    • AspirinJunkie
    • 13. Februar 2023 um 12:27

    Naja du machst ja eine Bedingungsabfrage.
    Willst also die Objekte haben, welche eine bestimmte Eigenschaft besitzen.
    Das geht in einem einzelnen AutoIt-Aufruf nicht.

    Du könntest eine Funktion schreiben in die deine Schleife verpackt wird und du so die Filterung erreichst.

    Oder du nimmst statt einem Array eine Map und verwendest dort als Schlüssel die ID.
    Auf die Art kannst du schnell per ID auf die einzelnen structs zugreifen:

    AutoIt
    Global Const $tagVariables = 'struct;char id[36];char Name[999];endstruct'
    Global $Count = 5
    
    Global $mNetworks[] ; leere Map
    
    For $i = 0 To $Count
        Global $tVariable = DllStructCreate($tagVariables)
        With $tVariable
            .id = $i + 1
            .Name = $i +  1 & "_name"
        EndWith
        $mNetworks[$i + 1] = $tVariable
    Next
    
    For $Row = 1 to $Count
        With $mNetworks[$Row]
            .id = $Row
            .name = $Row & '_name'
            ConsoleWrite(.id & ': ')
            ConsoleWrite(.name & @CRLF)
        EndWith
    Next
    
    Global $A = DllStructGetData($mNetworks[3], "Name")
    If @error Then ConsoleWrite("@error: " & @error & @CRLF)
    Consolewrite($A & @CRLF)
    Alles anzeigen
  • CBOR-UDF - (de-)Serialisieren von AutoIt-Variablen von und in ein standardisiertes Binärformat

    • AspirinJunkie
    • 7. Februar 2023 um 17:10

    CBOR ist ein Binärformat, welches beliebig verschachtelte Daten abbilden kann.
    Das Prinzip ist im Grunde das gleiche wie bei JSON.
    Auch dort kann man direkt seine Variablen aus dem Programm nehmen und in dieses Format konvertieren.
    Auf die Art kann man seine Daten außerhalb des Programmes speichern oder mit anderen Programmen austauschen, was umso einfacher ist, da so gut wie alle Programmiersprachen den JSON-Standard verstehen.

    Auch bei CBOR ist das ähnlich, nur mit dem Unterschied, dass CBOR eben kein textbasiertes Format ist, sondern ein Binärformat.
    Das macht es natürlich unmöglich für einen Menschen es direkt zu lesen aber andererseits sind die Ergebnisse in der Regel kleiner als in JSON.

    Nun wie arbeitet man damit? - hier ein Beispiel:

    AutoIt
    #include "CBOR.au3"
    
    ; verschachtelte AutoIt-Struktur erzeugen
    Global $aArray = [1, 2.0, 3.3]
    Global $vValue[] ; leere Map
        $vValue["Test"] = $aArray
        $vValue[123] = "String"
    
    ; AutoIt-Variablen in CBOR-Format binär serialisieren:
    $bCBOR = _cbor_encode($vValue)
    ConsoleWrite(StringFormat("% 20s: % 8d bytes\n", "serialisierte Größe", BinaryLen($bCBOR)))
    
    ; Rückkonvertierung in AutoIt-Variable aus CBOR-Binary:
    $vAutoIt = _cbor_decode($bCBOR)
    
    ; Testen ob Struktur noch passt:
    ConsoleWrite($vAutoIt.Test[2] & @CRLF)
    Alles anzeigen

    In diesem Fall belegt unsere AutoIt-Datenstruktur am Ende noch 29 Bytes an Platz.

    Da der Vergleich zu JSON naheliegt - hier noch ein Beispiel (die JSON-UDF wird noch benötigt) um zu schauen wie beide interagieren:

    Spoiler anzeigen
    AutoIt
    #include "CBOR.au3"
    #include "JSON.au3"
    
    ; Daten im JSON-format
    Global $sString = '[{"id":"4434156","url":"https://legacy.sky.com/v2/schedules/4434156","title":"468_CORE_1_R.4 Schedule","time_zone":"London","start_at":"2017/08/10 19:00:00 +0100","end_at":null,"notify_user":false,"delete_at_end":false,"executions":[],"recurring_days":[],"actions":[{"type":"run","offset":0}],"next_action_name":"run","next_action_time":"2017/08/10 14:00:00 -0400","user":{"id":"9604","url":"https://legacy.sky.com/v2/users/9604","login_name":"robin@ltree.com","first_name":"Robin","last_name":"John","email":"robin@ltree.com","role":"admin","deleted":false},"region":"EMEA","can_edit":true,"vm_ids":null,"configuration_id":"19019196","configuration_url":"https://legacy.sky.com/v2/configurations/19019196","configuration_name":"468_CORE_1_R.4"},{"id":"4444568","url":"https://legacy.sky.com/v2/schedules/4444568","title":"468_CORE_1_R.4 Schedule","time_zone":"London","start_at":"2017/08/11 12:00:00 +0100","end_at":null,"notify_user":false,"delete_at_end":false,"executions":[],"recurring_days":[],"actions":[{"type":"suspend","offset":0}],"next_action_name":"suspend","next_action_time":"2017/08/11 07:00:00 -0400","user":{"id":"9604","url":"https://legacy.sky.com/v2/users/9604","login_name":"robin@ltree.com","first_name":"Robin","last_name":"John","email":"robin@ltree.com","role":"admin","deleted":false},"region":"EMEA","can_edit":true,"vm_ids":null,"configuration_id":"19019196","configuration_url":"https://legacy.sky.com/v2/configurations/19019196","configuration_name":"468_CORE_1_R.4"}]'
    ConsoleWrite(StringFormat("% 20s: % 8d bytes\n", "Größe JSON-String", BinaryLen(StringToBinary($sString, 4))))
    
    ; konvertiere in CBOR-Binärdatenformat:
    Global $bCBOR = _JsonToCbor($sString)
    ConsoleWrite(StringFormat("% 20s: % 8d bytes\n", "Größe CBOR-binary", BinaryLen($bCBOR)))
    
    ; wandele in JSON-String zurück um zu schauen ob Hin-und-her Konvertierung korrekt war:
    Global $sRecovered = _CborToJson($bCBOR)
    ConsoleWrite($sRecovered & @CRLF)
    
    Func _JsonToCbor($sJSONString)
        Local $vData = _JSON_Parse($sString)
        Return _cbor_encode($vData)
    EndFunc
    
    Func _CborToJson($bCBOR)
        Local $vDecoded = _cbor_decode($bCBOR)
        Return _JSON_Generate($vDecoded)
    EndFunc
    Alles anzeigen

    >>Download und Quellcode auf GitHub<<


    Changelog:

    2023/02/08
    • Problem bei der Kodierung großer Integerzahlen behoben
  • _ArrayDisplay() kann keine Null-Keywords verarbeiten

    • AspirinJunkie
    • 5. Februar 2023 um 07:41

    Thanks pixelsearch for the clarification!

    fee Du verwendest offensichtlich nicht die aktuelle v.3.3.16.1. Der Bug ist bereits bekannt und wurde in Version 3.3.16.1 behoben.

  • _ArrayDisplay() kann keine Null-Keywords verarbeiten

    • AspirinJunkie
    • 4. Februar 2023 um 18:11

    Ist es auch nicht.

    Das braucht man nicht künstlich klein zu reden. Wenn Arraydisplay bei einem AutoIt-Keyword abschmiert, dann gehört das gefixt und nicht mit Workarounds umgangen.

    Ich selbst kann es gerade nicht testen, aber wenn es sich tatsächlich so wie beschrieben darstellt ist es ein Fall für den >>Issue-Tracker<< (vorher aber mal schauen ob es nicht schon Ticket hierfür gibt)

  • CMD Aurfuf haut nicht hin

    • AspirinJunkie
    • 2. Februar 2023 um 15:00

    Hinter $file ist dann ein Anführungszeichen zu viel.

    Ausgeben kannst du es so:

    AutoIt
    $file = "C:\Users\user1\Desktop\59116_zert_asa-ssl_b.pfx"
    $pass = 'pass'
    
    $sCommand = "certutil -f -p " & $pass & " -user -importpfx " & $file & " & Pause"
    
    ConsoleWrite($sCommand & @CRLF)
    
    Run($sCommand, "", "", @SW_SHOW)

    Certutil ist auch kein Befehl der cmd.exe sondern ein ausführbares Programm.
    Daher brauchst du dafür auch kein @comspec

  • CMD Aurfuf haut nicht hin

    • AspirinJunkie
    • 2. Februar 2023 um 14:37

    nach importfx hast du ein doppeltes Anführungszeichen.

    Zum debuggen kannst du dir den kommandostring auch mal auf der console ausgeben.

  • Neue, aktualisierte UDF für den Windows Task Scheduler!

    • AspirinJunkie
    • 30. Januar 2023 um 21:06
    Zitat von water

    Die Funktion importiert aus einem Array ODER einer Datei. Damit die Funktion weiss, woher sie die Daten nehmen soll, musst Du das in Parameter 2 angeben.

    Vorschlag: Evtl. wäre eine Alternative ganz auf den $iInputType-Parameter zu verzichten und über den Datentyp ( IsString/IsArray) zu unterscheiden und im Falle von IsString() nochmal ein FileExists hinterherzuschieben?

    Ansonsten: Die UDF ist echt krass - >2000 Zeilen Code und alle komplett sauber durchgecodet und dokumentiert.
    Wahnsinnige Fleißaufgabe :thumbup:

  • WMI Abfrage

    • AspirinJunkie
    • 25. Januar 2023 um 12:34
    Zitat von casi4712

    Nur ich hätte die ganz gerne alle in einer MessageBox, das geht bestimmt nicht so mit dieser Methode.

    Doch geht schon. Du musst dir halt deinen Ausgabestring über die Schleife schrittweise aufbauen:

    AutoIt
    Global $oWMI = ObjGet("winmgmts:\\localhost\root\CIMV2")
    
    ; (noch) leerer String der schrittweise befüllt werden soll
    $sOutput = ""
    
    For $oEntity in $oWMI.ExecQuery('SELECT Name, Status FROM Win32_PnPEntity WHERE Status="Error"', "WQL", 48)
        ; Infos der aktuellen Entität als neue Zeile dem Ausgabestring hinzufügen:
        $sOutput &= $oEntity.Name & @TAB & $oEntity.Status & @CRLF
    Next
    
    ; Infos ausgeben
    MsgBox(0,"Tada", $sOutput)
    Alles anzeigen
  • WMI Abfrage

    • AspirinJunkie
    • 24. Januar 2023 um 22:10

    hast du schon - $oEntity.Name enthält z.b. den Namen.

    Ansonsten musst du halt den Wert an eine extra variable zuweisen.

  • WMI Abfrage

    • AspirinJunkie
    • 24. Januar 2023 um 22:02

    Du brauchst nicht mit wmic rumopern - das geht einfacher in AutoIt:

    AutoIt
    Global $oWMI = ObjGet("winmgmts:\\localhost\root\CIMV2")
    
    For $oEntity in $oWMI.ExecQuery('SELECT Name, Status FROM Win32_PnPEntity WHERE Status="Error"', "WQL", 48)
        ConsoleWrite($oEntity.Name & @TAB & $oEntity.Status & @CRLF)
    Next
  • Variable used without being declared - nach dem compilieren

    • AspirinJunkie
    • 20. Januar 2023 um 10:52

    Ist das so?
    Wir haben bisher nur ein paar Codeschnipsel gesehen und keiner von uns kann das beschriebene daher reproduzieren.
    Es ist eher wahrscheinlich, dass der Fehler ganz anders gelagert war. Evtl hatte er nen Schreibfehler alla $testt drin oder so, den er dann mit ausgebügelt hat ohne es zu merken etc.

    Kurz: Ich sehe noch nicht, dass dies wirklich zusammenhängt. Dafür bräuchte man ein reproduzierbares Minimalskript.

  • Variable used without being declared - nach dem compilieren

    • AspirinJunkie
    • 20. Januar 2023 um 09:56

    Was ist denn "Windows False"?
    In der Windows-API wird der Typ bool in der Datei windef.h folgendermaßen definiert: typedef int BOOL;.
    Windows false ist also ein integer mit dem Wert 0.

    Was ist ein "AutoIt False"?
    Im alten Quelltext von AutoIt wird ebenso bool verwendet.
    Die Definition dort wird (für den Fall dass kein msvc-compiler verwendet wird) aus der windef.h gezogen - und dort ist der Typ, wie wir bereits wissen, als typedef int BOOL; definiert.

    Ich sehe daher nicht wo sich diese beiden unterscheiden würden.

  • Variable used without being declared - nach dem compilieren

    • AspirinJunkie
    • 20. Januar 2023 um 09:28

    Naja es ist eigentlich überhaupt kein Problem per If $test = True Then zu verzweigen.
    Es wird damit nur implizit eine weitere Verarbeitungsstufe eingezogen.
    Was meine ich damit?:
    Eine If-Verzweigung in AutoIt ist prinzipiell so aufgebaut: If [Bool-Ausdruck] Then.
    Würde man für den Ausdruck eine Variable einsetzen dann hätte man direkt ein  If True/False Then.

    Wenn man stattdessen If $test = True Then schreibt, dann hat man einen Zwischenausdruck, der erst ausgewertet werden muss, dessen Ergebnis in eine Zwischenvariable gespeichert werden muss und diese dann in der If-Verzweigung eingetragen wird.

    Also der Ausdruck $test = true wird erst ausgewertet und ergibt z.B. als Ergebnis den boolschen Wert true. Dieses Ergebnis wird nun im Speicher zwischengesichert und für die If-Bedingung verwendet.

    Man hat also einen Zwischenschritt eingefügt der prinzipiell entbehrlich ist.


    Das ist aber im Grunde überhaupt nicht schädlich. Der Einfluss auf die Performance ist gleich 0 (Compiler würden es i.d.R. auch wegoptimieren) und das Ergebnis ist genau das gleiche.
    Hingegen hat die lange Variante einen entscheidenden Vorteil:
    Es ist so klarer was eigentlich gewollt ist. Jeder sieht sofort, dass die Variable true sein muss damit es weitergeht. Bei der kurzen Variante ist das, gerade für Neulinge, nicht sofort ersichtlich.

    Daher würde ich eher dazu plädieren die längere Variante zu nehmen.

    Zitat von Moombas

    Unterschiede zwischen Windows true/false und AutoIt true/false

    Das wäre bemerkenswert - ein Bit kann nur exakt 2 verschiedene Werte annehmen.
    Ich überlege mir gerade wie da überhaupt Unterschiede implementiert werden könnten.

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 18. Januar 2023 um 13:46

    Nun wir reden im Grunde über 2 verschiedene Ebenen von Performance.
    Einmal um die Grenzen die die Hardware setzt und zum anderen wie weit die Software optimiert ist um diese Grenzen auszureizen.
    Das Problem mit den Array-Indizes ist ein klares Beispiel für den Fall, dass die Software weit entfernt ist von einer möglichst optimalen Ausnutzung der vorhandenen Hardwareleistung.

    Deine Methode mit der Ramdisk hingegen ist eine Methode die Leistung der Hardware höher zu setzen - genauer die vom Speichermedium, welches einfach durch ein schnelleres ersetzt wird.
    Natürlich könnte man die Leistung mit derartigen Dingen je nach Anwendung (für die Problematik der Array-Indizes nützt die Ramdisk konkret nichts) absolut steigern. Relativ bleibt sie aber weiterhin bescheiden.
    Wenn die Software vorher nur 5% der möglichen Performance, welche die Hardware hergibt ausgereizt hat, dann ist sie mit potenterer Hardware (z.B. RAM statt einer HDD) womöglich absolut 10x so schnell wie vorher, aber reizt immer noch nur 5% des eigentlichen Potentials aus.


    Kurz: Wir interessieren uns für Lösungen des eigentlichen Problems - nicht für Workarounds.

    Zitat von BugFix

    Sorry an AspirinJunkie , wenn wir hier etwas OT gehen.

    Das ist nicht OT - genau solche Performancediskussionen waren doch das Thema des Threads.

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 18. Januar 2023 um 08:03
    Zitat von Andy

    genau wie das kopieren von (Text-) Variableninhalten bei sämtlichen "internen" Funktionen. Leg mal einen mehrere hundert MB großen Text an und lass auf diesen dann die durchaus schnellen Text/Stringfunktionen los und beobachte die Speicherauslastung

    Das hatte ich mal bei StringRegExp beobachtet und dabei festgestellt, dass das bei den normalen Stringfunktionen wie z.B. StringMid etc. eben dort nicht auftritt.

    Ich hatte dann ein >>Ticket<< dazu eröffnet und das war ratz fatz behoben und (ich glaube) nur ein paar Wochen später in der nächsten AutoIt-Version übernommen worden.
    Seitdem habe ich so ein Verhalten nicht mehr feststellen können.
    Hast du da evtl. ein konkretes Beispiel dazu?

    Mars

    Du bist da etwas auf der Spur.
    Die doppelte Ausführung könnte wirklich mit dem Phänomen zusammenhängen. Zumindestens sagt dies uns, dass die Array-Implementierung ziemlicher Bullshit in AutoIt ist.

    Übrigens: Für das doppelte Ausführen bei Arrays hat jpm seit 2 Jahren einen Fix fertig, welcher aber bislang von Jon noch nicht eingespielt wurde.

  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 17. Januar 2023 um 07:49
    Zitat von Mars

    Kann das jemand reproduzieren

    Kann ich - meine Ergebnisse deines Skriptes:

    Code
    Time needed to normalize 1000 vectors of length 30 in milliseconds
    Array:  28.07 (100%)
    Map:    26.90 (96%)
    Zitat von Mars

    bzw. mit anderen Tests ergänzen

    Ich habe mal die Vektorlänge ein bisschen erweitert und mal selbst das Testskript aufgebaut um nicht etwas zu übernehmen, was wir bisher vielleicht nicht sehen (Normalisierung.au3).
    Meine Ergebnisse:

    Code
             N       Norm(Map)     Norm(Array)
    ------------------------------------------
            10       0.012  ms       0.023  ms
           100       0.080  ms       0.080  ms
          1000       0.723  ms       0.781  ms
         10000      10.740  ms       8.033  ms

    Die Grundaussage Map ist schneller als Array lässt sich also erst einmal nur für kleine Vektorlängen halten.
    Aber auch da entspricht das ganze nicht den Erwartungen.
    Also sollten wir mal tiefer bohren und schauen an was das liegen könnte.

    Grundsätzlich unterscheiden sich die beiden Vektornormalisierungen ja nur durch den Elementzugriff und den Elementzuweisungen.
    Der Rest ist gleich, so dass wir diese Zeitenunterschiede dort wiederfinden müssten.

    Ich habe diese mal separat gemessen (Elementzugriff.au3 & Elementzuweisung.au3) und folgende Ergebnisse ermittelt:

    Code
    Zugriffszeit auf einzelne Elemente einer Map oder Array:
    
             N      $x = $mMap[$i]    $x = $aArray[$i]
    ------------------------------------------------
            10        0.000400  ms        0.000250  ms
           100        0.000226  ms        0.000374  ms
          1000        0.000251  ms        0.000229  ms
         10000        0.000379  ms        0.000227  ms
        100000        0.004698  ms        0.000233  ms
    
    
    Zuweisungszeit für ein einzelnes Element einer Map oder Array:
    
             N       $mMap[$i] = 5     $aArray[$i] = 5
    ------------------------------------------------
            10        0.000750  ms        0.000500  ms
           100        0.000521  ms        0.000505  ms
          1000        0.000585  ms        0.000558  ms
         10000        0.000746  ms        0.000550  ms
        100000        0.006454  ms        0.000506  ms
    Alles anzeigen

    Wir sehen also, dass eine Map insbesondere bei den Zugriffszeiten bei geringer Größe mit dem Array mithalten kann und teilweise darunter liegt.
    Ab einer gewissen Größe jedoch wird es bösartig und die Zugriffszeiten für die Maps rauschen nach oben.
    Das war bisher auch schon bekannt und liegt - das ist meine Theorie hierzu - daran, dass die AutoIt-Map als statische Hashtabelle mit (ich glaube) 256 Einträgen implementiert wurde.
    D. h. darüber haben wir zwangsläufig Hash-Kollisionen die dazu führen, dass Elemente in den Sublisten linear durchlaufen werden müssen um auf Elemente zuzugreifen - das kostet unheimlich Zeit und spiegelt sich entsprechend in den Ergebnissen wieder.
    Eine dynamische Implementierung mit entsprechenden Resizes würde hier Abhilfe schaffen (Das Scripting.Dictionary hatte das Problem glaube ich nicht).

    Nun dennoch: Selbst die Ergebnisse bei kleinen Vektorgrößen sind mir nicht erklärbar.
    Ein Zugriff auf ein Array-Elemente sollte IMMER schneller sein.
    Intern ist das nur der (fast) direkte Zugriff auf eine Speicherstelle wo im Falle von AutoIt der Pointer zur dahinterliegenden Variable liegt - mehr nicht.
    Die Map hingegen berechnet erst aus dem Index einen Hash und mappt diesen auf den Indexraum der Hash-Tabelle.
    An diesem berechneten Index muss dann noch die Subliste für die Unterelemente linear durchlaufen werden und jeder einzelne Wert mit dem Key verglichen bevor man das gewünschte Element erhält.
    Kurz: Das kann NIE schneller sein.

    Da muss irgendein Schnitzer im AutoIt-Quellcode sein. Und der Fehler liegt nicht daran, dass die ihre Map so grandios schnell implementiert haben - nein die Array-Implementierung hat ein massives Problem.

    Zitat von Mars

    Ein kleiner Bonus bei verschachtelten Maps ist, dass man darauf via $m[$i][$j] zugreifen kann (während man bei Arrays aufgeschmissen ist).

    sicher? :/ : ($a[$i])[$j]

  • Bug oder nicht Bug oder wenigstens ungereimt?

    • AspirinJunkie
    • 16. Januar 2023 um 16:51

    Ätsch - das Ticket was ich verlinkt habe ist älter als deines .. :P

  • Bug oder nicht Bug oder wenigstens ungereimt?

    • AspirinJunkie
    • 16. Januar 2023 um 15:45
    Zitat von Peter S. Taler

    wenn wir das bemängeln wollen, wessen Englisch ist gut genug das passend zu formulieren?

    DeepL ist dein Freund.
    Dessen Ergebnisse sind in den meisten Fällen auch ohne weitere Anpassungen ausreichend.

    Schau aber erstmal ob das Thema nicht bereits behandelt wurde.
    Wenn du dort suchst, wirst du z.B. auf >>folgendes<< stoßen...

  • Bug oder nicht Bug oder wenigstens ungereimt?

    • AspirinJunkie
    • 16. Januar 2023 um 15:34

    Also ein Bug ist es nicht, da das Verhalten exakt so ist wie in der Doku beschrieben:

    Zitat

    Directory containing the running script. Only includes a trailing backslash when the script is located in the root of a drive.

    Wäre also ein Change-Request.
    Ich persönlich fände es einheitlich auch schöner aber ich vermute ganz stark, dass das Thema schon mehrfach zur Sprache kam und trotzdem alles so blieb wie bisher.

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™