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

  • JSON-UDF

    • AspirinJunkie
    • 21. August 2017 um 22:26
    Zitat von autoiter

    Wäre es Quatsch auch direkt eine Umwandung von xDArray zu JSON und umgekehrt einzubauen?

    Wenn du damit mehrdimensionale Arrays meinst: 2D Arrays sollte die UDF bereits konvertieren (wird dann im Grunde ein Array in Array):

    AutoIt
    #include <Array.au3>
    #include "JSON.au3"
    
    
    Global $a_Test[][3] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    _ArrayDisplay($a_Test)
    $s_JSON = _JSON_Generate($a_Test)
    MsgBox(0, "2D Array", $s_JSON)
    
    
    ; Rückwandlung aus JSON in 2D-Array
    $o_JSON = _JSON_Parse($s_JSON)
    $a_Test2 = __ArrayAinATo2d($o_JSON)
    _ArrayDisplay($a_Test2, "2D Array nach Rückkonvertierung")
    Alles anzeigen

    Umgekehrt (Also JSON in ein 2D-Array) würde so direkt nicht gehen, da man in JSON-Syntax nicht sehen kann ob es sich um ein 2D-Array handelt oder um ein Array-In-Array.
    Es ist daher dem User überlassen die Struktur entsprechend zu interpretieren. Im Beispiel hier findest du einen Ansatz wie man dies bewerkstelligen kann.
    3D und mehr halte ich persönlich für ziemlich exotisch und würde es daher dem User überlassen diese vorher in Array-In-Array Strukturen aufzubrechen.

    Edit: Aber danke für deinen Hinweis - hab es gleich mal getestet und gleich den ersten Bug hierzu gefunden.
    Hab es oben aktualisiert - nun sollten auch 2D-Arrays gehen.

  • JSON-UDF

    • AspirinJunkie
    • 21. August 2017 um 18:19

    Aufgrund einer Shoutbox-Diskussion und meiner Unzufriedenheit mit bisherigen JSON-UDFs habe ich mich mal rangesetzt und meine Vorstellungen wie eine solche auszusehen hat umgesetzt.
    Die bisherigen UDFs sind meiner Meinung nach entweder unnötig umständlich, haben externe Abhängigkeiten oder kommen nicht mit Dictionaries klar.
    Daher folgt die UDF folgenden Prämissen:

    • Ein JSON-String wird mit einer einzigen Funktion komplett in eine native AutoIt-Datenstruktur zur Weiterverarbeitung konvertiert. (Funktion _JSON_Parse)
    • Andersherum kann aus beliebigen AutoIt-Datenstrukturen ein JSON-String erzeugt werden. (Funktion _JSON_Generate)
    • Abfragen können entweder direkt in den AutoIt-Variablen stattfinden oder etwas sicherer in einer sehr simplen Abfragesprache (Funktion _JSON_Get)

    Wer also ähnlich tickt wie ich findet eventuell hiermit eher seine Vorstellungen umgesetzt.

    Wie verwendet man es nun? - na dann siehe hier:

    AutoIt
    #include <JSON.au3>
    Global $s_String = '[{"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"}]'
    
    ; ================= JSON-String in AutoIt-Datenstrukturen parsen ==============
    $o_Object = _JSON_Parse($s_String)
    
    ; ================= Abfragen direkt per AutoIt ================================
    $s_Type = ((($o_Object[1])["actions"])[0])["type"]
    ConsoleWrite("type: " & $s_Type & @CRLF)
    
    ; ================= Abfragen per JSON_Get (sicherer) ================================
    $s_Type = _JSON_Get($o_Object, "[1].actions[0].type")
    ConsoleWrite("type: " & $s_Type & @CRLF)
    
    ; ================= AutoIt-Datenstrukturen in JSON-String konvertieren ==============
    ConsoleWrite(_JSON_Generate($o_Object) & @CRLF & @CRLF)
    ; kompaktes JSON:
    ConsoleWrite(_JSON_GenerateCompact($o_Object) & @CRLF & @CRLF)
    Alles anzeigen

    Man kann mit der UDF auch verschachtelte AutoIt-Strukturen (welche z.B. von _JSON_Parse() erzeugt wurden) erzeugen und verändern:

    AutoIt
    #include <JSON.au3>
    
    Global $mMap ; Zielvariable für die zu schaffende Datenstruktur
    
    ; Erzeuge eine Datenstruktur um die Angestellten von verschiedenen Firmen an ihren spezifischen Firmenstandorten zu verwalten:
    _JSON_addChangeDelete($mMap, "Meine Firma.Standorte[1].Mitarbeiter[0]", "Hagen Rether")
    _JSON_addChangeDelete($mMap, "Meine Firma.Standorte[1].Mitarbeiter[1]", "Dieter Nuhr")
    _JSON_addChangeDelete($mMap, "Meine Firma.Standorte[3].Mitarbeiter[0]", "Lisa Eckhardt")
    
    ; Ändere einen Wert - hier z.B. den Mitarbeiter "Hagen Rether" durch einen anderen ersetzen:
    _JSON_addChangeDelete($mMap, "Meine Firma.Standorte[1].Mitarbeiter[0]", "Volker Pispers")
    
    ; Lösche den 2. Mitarbeiter am 2. Firmenstandort ("Dieter Nuhr")
    _JSON_addChangeDelete($mMap, "Meine Firma.Standorte[1].Mitarbeiter[1]")
    
    ; Die Datenstruktur als JSON-String ausgeben:
    ConsoleWrite(_JSON_Generate($mMap) & @CRLF & @CRLF)
    Alles anzeigen

    >>Download und Quellcode auf GitHub<<


    Changelog:

    2017/08/21
    • _JSON_Generate: Bug bei 2D-Arrays behoben
    2017/08/22
    • Ausgabe von _JSON_Generate individualisierbar
    2017/08/27
    • stabilere Stringdefinition
    • _JSON_Generate: Static string wird aufgeräumt
    • offizielle Whitespace-Definition statt \s
    2017/09/04
    • _JSON_Generate: Zahlenausgabe nun so kompakt wie möglich
    2017/10/10
    • Große Arrays werden nun schneller geparst (selbes Prinzip wie in der DynArray-UDF verwendet)
    2017/10/11
    • Bug in _JSON_Generate behoben (Escapen von Backslashes fügte ein " hinzu)
    • deutlich stabilerer Umgang mit Escape-Zeichen in Strings
    • Performance-Verbesserungen (ohne Umweg über Hilfsfunktion direkter Zugriff per StringRegExp)
    2017/10/16
    • _JSON_Generate: Rundungsfehler bei großen Zahlen behoben
    2017/10/31
    • _JSON_Parse: Unicode-Escapes werden nun konvertiert.
    2018/01/11
    • _JSON_Parse: Performanceverbesserung durch optimierte RegEx-Pattern.
    • _JSON_ParseString: bessere Performance
    2019/03/03
    • _JSON_Get: Keys mit "+" am Ende werden nun auch geparst
    2020/05/21
    • Unicode-Escapes (\uxxxx) wurden nicht korrekt übersetzt
    2020/10/21
    • Fix: Stack-Overflow (Error 1073741571) beim String-Parsing
    • i.V.m. Fix: Performanceverbesserung beim Parsen großer Strings
    • Fix: Hex-Unicode-Escapes wurden nicht übersetzt.
    2020/12/29
    • _JSON_Get(): Unterstützung von Map-Datentyp (derzeit nur AutoIt-Beta-Versionen)
    • _JSON_Generate(): Unterstützung von Map-Datentyp (derzeit nur AutoIt-Beta-Versionen)
    • _JSON_Parse: Neuer Parameter $bUseMaps - falls "true" dann werden aus Objekten AutoIt-Maps anstatt Scripting.Dictionary-Objekte erstellt (derzeit nur AutoIt-Beta-Versionen)
    2021/01/07
    • _JSON_Parse(): Objekt-Keys können nun auch Leerstrings sein
    • _JSON_Parse(): Workaround für einen Bug in Number()
    2021/02/09
    • _JSON_Generate():
      • Die Funktion verändert die Ursprungsstruktur nicht mehr
      • 2D-Arrays deren Zeilen leere Elemente am Ende enthalten, werden kompakter abgebildet (siehe __Array2dToAinA())
    2021/10/25
    • Kompatibilität mit Opt("MustDeclareVars", True) hergestellt (thx mko)
    2022/10/19
    • Script-Breaking!: _JSON_Parse generiert für JSON-Objekte nun AutoIt-Maps anstatt Scripting.Dictionary-Objekte. Die letzte Version mit Dictionary liegt im Anhang als JSON_Dictionary.au3.
    • __JSON_FormatString(): @Tab wird nun durch \t escaped. (thx mko)
    2023/01/03
    • Leichte Performanceverbesserung durch Neuimplementierung der Funktion __JSON_ParseString()
    2023/01/16
    • _JSON_addChangeDelete(): Neue Funktion mit der verschachtelte AutoIt-Datenstrukturen leicht erzeugt und verändert werden können
    • _JSON_Get(): Punkte in Schlüsselnamen sind nun auch möglich indem man sie durch "\" escaped. Um "\" darzustellen muss man sie nun doppeln: "\\"
    2023/05/23
    • _JSON_GenerateCompact() hinzugefügt: Abkürzung um möglichst kompakten JSON-Code zu erstellen anstatt die Parameter mit _JSON_Generate() händisch einzutragen.
    2025/08/14
    • _JSON_Parse(): Massive Performancesteigerung mit ~ 40%–55% Verbesserung
    • _JSON_Generate(): Performancesteigerung um ~ 15%–35%
    • Verzicht auf ByRef in allen Parametern um direkte Wertübergabe zu ermöglichen
    • Ergänzung der Readme.md um Hinweise zur Behandlung von .json-Dateien
  • Ca. 3 % CPU-Auslastung durch Endlos-Skript normal?

    • AspirinJunkie
    • 21. August 2017 um 07:55

    War doch nur ein Beispiel mit dem ESC.
    Sollst dir doch noch anpassen wie du lustig bist.

  • Ca. 3 % CPU-Auslastung durch Endlos-Skript normal?

    • AspirinJunkie
    • 21. August 2017 um 07:27

    Darf ich bloß mal kurz fragen wo du die Definition von $EVENT_SYSTEM_FOREGROUND her hast, da ich ja vergessen habe diese zu erwähnen?
    Im Grunde meinte ich es so:

    AutoIt
    Global Const $EVENT_SYSTEM_FOREGROUND = 0x3
    Global Const $EVENT_OBJECT_CREATE = 0x8000
    HotKeySet("{ESC}", "_raus")
    
    
    Global $hWinEventProc = DllCallbackRegister(_reactOnNewWindow, "none", "hwnd;int;hwnd;long;long;int;int")
    DllCall("User32.dll", "hwnd", "SetWinEventHook", "uint", $EVENT_SYSTEM_FOREGROUND, "uint", $EVENT_SYSTEM_FOREGROUND, "hwnd", 0, "ptr", DllCallbackGetPtr($hWinEventProc), "int", 0, "int", 0, "uint", 0x2)
    
    
    ; sparsame Endlosschleife
    While Sleep(10000)
    WEnd
    
    
    ; Funktion welche ausgeführt wird, sobald ein neues Fenster erstellt wird
    Func _reactOnNewWindow($hHook, $iEvent, $hWnd, $idObject, $idChild, $iEventThread, $iEventTime)
        If StringInStr(WinGetTitle($hWnd), "App im Store suchen?") Then
    		MsgBox(0, "Fenster da", WinGetTitle($hWnd))
    	EndIf
    EndFunc   ;==>_reactOnFocusChange
    
    
    ; Wenn ESC gedrückt wird - beenden
    Func _raus()
    	Exit
    EndFunc
    Alles anzeigen

    Und dies führt nicht zum gewünschten Ergebnis bei dir?

  • Ca. 3 % CPU-Auslastung durch Endlos-Skript normal?

    • AspirinJunkie
    • 21. August 2017 um 07:02

    Ja war nur noch ein weiterer Gedankenanstoß zu dem Thema und auch nicht 100% ausgearbeitet. Muss mich bei sowas immer durch die ganzen Listen wühlen welches Event nun das korrekte hierfür ist.
    Wenn es momentan nicht klappt dann kannst du ja nochmal versuchen oben 2x EVENT_OBJECT_CREATE durch $EVENT_SYSTEM_FOREGROUND auszutauschen.

  • Ca. 3 % CPU-Auslastung durch Endlos-Skript normal?

    • AspirinJunkie
    • 20. August 2017 um 22:34

    Eventuell kannst du die Auslastung noch weiter minimieren indem du das Skript permant in den Schlaf schickst und Windows anweist das Skript aufzuwecken sobald ein neues Fenster erstellt wurde.
    Also die Windows-Events abfangen.

    So könnte ich mir das Grundkonzept vorstellen:

    AutoIt
    Global Const $EVENT_OBJECT_CREATE = 0x8000
    HotKeySet("{ESC}", "_raus")
    
    
    ; Funktion _reactOnFocusChange mit EVENT_SYSTEM_FOREGROUND "verbinden"
    $hWinEventProc = DllCallbackRegister(_reactOnNewWindow, "none", "hwnd;int;hwnd;long;long;int;int")
    DllCall("User32.dll", "hwnd", "SetWinEventHook", "uint", $EVENT_OBJECT_CREATE, "uint", $EVENT_OBJECT_CREATE, "hwnd", 0, "ptr", DllCallbackGetPtr($hWinEventProc), "int", 0, "int", 0, "uint", 0x2)
    
    
    ; sparsame Endlosschleife
    While Sleep(1000)
    WEnd
    
    
    
    
    ; Funktion welche ausgeführt wird, sobald ein neues Fenster erstellt wird
    Func _reactOnNewWindow($hHook, $iEvent, $hWnd, $idObject, $idChild, $iEventThread, $iEventTime)
        If StringInStr(WinGetTitle($hWnd), "App im Store suchen?") Then
    		MsgBox(0, "Fenster da", WinGetTitle($hWnd))
    	EndIf
    EndFunc   ;==>_reactOnFocusChange
    
    
    ; Wenn ESC gedrückt wird - beenden
    Func _raus()
    	Exit
    EndFunc
    Alles anzeigen

    Kommt das angesprochene Fenster in den Vordergrund?
    Dann wäre $EVENT_SYSTEM_FOREGROUND als Event sicherlich besser.

  • DllStructGetData durch Punkt-Notation ersetzen ein Risiko?

    • AspirinJunkie
    • 18. August 2017 um 07:05

    BugFix hat schon Recht. Er meinte aber wohl eher Ausdrücke die selbst indizierbar sind.
    Diese sind anders nicht in einem Ausdruck auswertbar. Also z.B. ein Array in Array:

    AutoIt
    Global $A[3]
    Global $B[] = [1,2,3]
    $A[1] = $B
    ConsoleWrite(($A[1])[1] & @CRLF)

    Bei den DLLStruct-Arrays sieht das bisschen anders aus, da dort keine indizierbare Struktur zurück kommt sondern lediglich der Zeiger auf den Anfang der internen Liste.
    Daher braucht man hierfür eine andere Syntax für den Direktzugriff weswegen man dann anscheinend diese Doppelklammern eingeführt hat (wenn auch anscheinend undokumentiert):

    AutoIt
    $t_Test = DllStructCreate("Int Test[20]")
    
    
    DllStructSetData($t_Test, 1, 100, 1)
    ConsoleWrite( ($t_Test.Test) & @CRLF)
    
    
    DllStructSetData($t_Test, 1, 5, 10)
    ConsoleWrite( $t_Test.Test((10)) & @CRLF)

    Das Verhalten ist ziemlich sicher kein Bug - ein Parser der diese Eigenschaft aus Versehen erzeugt ist nicht wirklich wahrscheinlich.

  • String auf spezielles Format untersuchen

    • AspirinJunkie
    • 17. August 2017 um 07:04

    Mensch Andy - lange nicht mehr gesehen - kommst du jetzt wieder öfter? :)
    Hier noch ein Beispiel für dein Pattern wo noch Anpassung nötig ist: 01.1
    (und das große E noch)
    Übrigens: {1} ist implizit schon alles - kann also weggelassen werden.

  • String auf spezielles Format untersuchen

    • AspirinJunkie
    • 16. August 2017 um 21:41

    Noch lauter konntest du gar nicht schreien: "REGULAR EXPRESSION!!!!!"

    Für nen Einsteiger hiefür gibt es aber einfachere Sachverhalte.
    Daher hier mein Vorschlag dafür:

    AutoIt
    $s_PatternNumbers = "(?xi)^-?   # Stringanfang + optionales minus" & @CRLF & _
    		"(?>0|[1-9]\d*)        # beginnt mit NUll oder jeder anderen Zahl" & @CRLF & _
    		"(?>\.\d+)?            # optionaler Dezimalpunkt mit Nachkommazahlen" & @CRLF & _
    		"(?:e[-+]?\d+)?        # Exponentialschreibweise" & @CRLF & _
    		"$                     # Stringende"
    
    
    $s_String = "-22.123912E+3"
    
    
    MsgBox(0,"", StringRegExp($s_String, $s_PatternNumbers) ? "Passt" : "Passt nicht")
    Alles anzeigen
  • Pid an Hand des Pfades ermitteln

    • AspirinJunkie
    • 3. August 2017 um 11:56

    Per WMI könnte man es sogar über einen Einzeiler machen:

    AutoIt
    $s_Path = StringReplace("c:\windows\system32\svchost.exe", "\", "\\")
    $h_PID = ObjGet("winmgmts:").ExecQuery('SELECT ProcessID FROM Win32_Process WHERE ExecutablePath="' & $s_Path & '"', "WQL", 16).ItemIndex(0).ProcessID
    MsgBox(0, "PID", $h_PID)


    Will man vernünftiges Errorhandling dann müsste man das noch entsprechend aufbrechen.

    Ansonsten gibt es in AutoIt die Funktion _WinAPI_GetProcessFileName(). Diese in Verbindung mit ProcessList sollte alles sein was du benötigst.

  • Alternativen zum Array

    • AspirinJunkie
    • 3. August 2017 um 08:08
    Zitat von autoiter

    Könntest du mir (oder ein anderer) erklären, wann man warum die Methode add einsetzen/bevorzugen sollte?

    Es stimmt schon - viel spricht nicht dafür .Add statt .Item (das ist die implizite Funktion des Dictionaries hinter der Zuweisung) zu verwenden.
    .Item ist schneller, .Item sieht übersichtlicher aus .Item wirft keine Fehler -> und das hier wäre der einzige Punkt der unter Umständen zu .Add raten könnte.

    .Item hat eigentlich die primäre Aufgabe den Wert zu einem Key zurückzugeben bzw. zu ändern. Hierbei hat es allerdings eine etwas obskure Eigenschaft. Wenn ein Item nicht existiert erstellt diese Funktion einfach ein neues - und zwar ohne ein Wort zu sagen.
    Das macht man sich zwar zu nutze wenn man hiermit die .Add-Funktion ersetzen möchte aber es kann auch zu unvorgesehenen Effekten führen.
    Wenn ein Programmierer an einer Stelle ein Item hinzufügen will bei dem er davon ausgeht dass es nicht bereits existiert, dieses aber aus irgendwelchen Gründen aber doch tut, dann führt .Item zu keinem Fehler obwohl vorher irgendetwas schief gelaufen sein muss. Der Programmierer bekommt hierbei jedoch nichts davon mit - das alte Item wird einfach still und heimlich überschrieben.
    Um das zu vermeiden müsste er sich zwingen jedes mal vorher ein .Exists davor zu schreiben - sieht blöd aus.
    Wenn er aber konsequent .Add verwendet weiß er jedoch dass dieses Szenario damit nicht auftreten kann weil .Add im Gegensatz zu .Item einen Fehler wirft.
    Es hat auch was mit Lesbarkeit des Codes zu tun. Jemand der den Code mit .Item sieht kann erst einmal nicht sofort erkennen ob damit bereits existierende Items geändert werden sollen oder neue hinzugefügt werden sollen.

    Aber in der Summe sehe ich nicht wirklich viel was dann noch für .Add spricht. Und den Performance-Unterschied kann ich mir erst recht nicht plausibel erklären - denn eigentlich müsste im Hintergrund bei beiden das Selbe ablaufen.

  • Text Datei auslesen ohne Dateinamen zu kennen

    • AspirinJunkie
    • 1. August 2017 um 13:38
    Zitat von Musashi

    In der dt. Onlinehilfe steht im Header zu 'FileFindFirstFile' allerdings auch etwas missverständlich : 'Gibt einen den angegebenen Suchkriterien entsprechenden Dateinamen zurück.'

    Da bin ich ganz bei dir. Ich finde es sogar nicht nur missverständlich sondern schlicht und ergreifend falsch.

  • Text Datei auslesen ohne Dateinamen zu kennen

    • AspirinJunkie
    • 1. August 2017 um 12:47

    Fast - FileFindFirstFile gibt lediglich ein Suchhandle zurück welches dann in FileFindNextFile zum durchgehen der Dateien verwendet wird.
    Also erst FileFindFirstFile - dann noch noch ein FileFindNextFile und dann hat man die erste Datei.

    Einen 3-Zeiler habe ich mal nicht gemacht - aber einen Vierzeiler:

    AutoIt
    $h_FFFF = FileFindFirstFile(@ScriptDir & "\*")
    $s_Dateiname = FileFindNextFile($h_FFFF)
    FileClose($h_FFFF)
    MsgBox(0,"", $s_Dateiname)


    Vorausgesetzt mit "es gibt nur eine Datei" in dem Ordner ist gemeint dass es auch keine Unterordner gibt - denn die würden mit FileFindNextFile ebenfalls zurück gegeben.

  • Prozessliste mit Namen erstellen

    • AspirinJunkie
    • 26. Juli 2017 um 21:56
    Zitat von Zeitriss

    Sollte die maximale Menge unbekannt oder unrealistisch groß sein kann man das Array einfach in 100, 1000, 10000... Schritten vergrößern und wenn man fertig ist ggf. wieder zurechschneiden.

    Das übliche Vorgehen hierfür ist statt einer festen Anzahl zur Vergrößerung mit einem Faktor zu arbeiten. Üblich hierfür sind 1,5 oder 2.
    Die .Net-Arraylist (die man in Autoit verwenden kann) oder die Java-Arraylist arbeiten nach diesem Prinzip.
    Bei .Net ist der Faktor glaube ich 2, auch bei der C++-Arraylist beim gcc-Compiler während er bei der Java-Arraylist 1.5 beträgt.
    Ist halt eine Frage des Ausgleich zwischen Performance und verschwendeten Platz.

    Für AutoIt habe ich das Prinzip (Faktor=2) auch schon mal umgesetzt: DynArray-UDF

  • Prozessliste mit Namen erstellen

    • AspirinJunkie
    • 26. Juli 2017 um 20:19
    Zitat von alpines

    Ich würde lieber die Relation zwischen den beiden betrachten und wie sich das auf größere Aufgaben skaliert.

    Hier kann man das Skalierungsverhalten der beiden einschätzen:
    ReDimVsArrayAdd.png
    Wenig überraschend skalieren beide gleich da ArrayAdd ja nix anderes als ein verpacktes ReDim ist.
    Da das umkopieren mit steigender Arraygröße immer aufwendiger wird ist die Skalierung exponentiell.

    Folgendes Messskript wurde verwendet:

    AutoIt
    #include <Array.au3>
    
    
    #Region Steps für Skalierung
    Global $i_Temp = 10
    Global $a_Result[$i_Temp + 1][1] = [["Faktor"]]
    For $i = 1 To $i_Temp
    	$a_Result[$i][0] = 2 ^ $i
    Next
    #EndRegion Steps für Skalierung
    
    
    #Region Globale Einstellungen
    Global Const $N = 1e2
    Global $iT, $f_Overhead, $i_F, $s_MessName
    #EndRegion Globale Einstellungen
    
    
    
    
    #Region Overhead
    ; determine the overhead of loop [and optional other stuff]
    Global $a_Overhead[UBound($a_Result) - 1]
    For $i_Fac = 0 To UBound($a_Overhead) - 1
    	$i_FEnd = $a_Result[$i_Fac][0]
    	$iT = TimerInit()
    	For $i = 1 To $N
    		Global $a_A[0]
    		For $j = 1 To $i_F
    		Next
    	Next
    	$a_Overhead[$i_Fac] = TimerDiff($iT)
    Next
    #EndRegion Overhead
    
    
    #Region Erste Messung
    ReDim $a_Result[UBound($a_Result)][UBound($a_Result, 2) + 1]
    $a_Result[0][UBound($a_Result, 2) - 1] = "ReDim"
    ConsoleWrite(StringFormat('\nStarte Messung für "%s":\n', $a_Result[0][UBound($a_Result, 2) - 1]))
    For $i_Fac = 1 To UBound($a_Result) - 1
    	$i_F = $a_Result[$i_Fac][0]
    	ConsoleWrite(StringFormat('\t\t%d\n', $i_F))
    	$iT = TimerInit()
    	For $i = 1 To $N
    		Global $a_A[0]
    		For $j = 1 To $i_F
    			ReDim $a_A[UBound($a_A) + 1]
    			$a_A[UBound($a_A) - 1] = $i
    		Next
    	Next
    	$iT = TimerDiff($iT)
    	$a_Result[$i_Fac][UBound($a_Result, 2) - 1] = ($iT - $a_Overhead[$i_Fac - 1]) / $N
    Next
    #EndRegion Erste Messung
    
    
    #Region Zweite Messung
    ReDim $a_Result[UBound($a_Result)][UBound($a_Result, 2) + 1]
    $a_Result[0][UBound($a_Result, 2) - 1] = "ArrayAdd"
    ConsoleWrite(StringFormat('\nStarte Messung für "%s":\n', $a_Result[0][UBound($a_Result, 2) - 1]))
    For $i_Fac = 1 To UBound($a_Result) - 1
    	$i_F = $a_Result[$i_Fac][0]
    	ConsoleWrite(StringFormat('\t\t%d\n', $i_F))
    	$iT = TimerInit()
    	For $i = 1 To $N
    		Global $a_A[0]
    		For $j = 1 To $i_F
    			_ArrayAdd($a_A, $j)
    		Next
    	Next
    	$iT = TimerDiff($iT)
    	$a_Result[$i_Fac][UBound($a_Result, 2) - 1] = ($iT - $a_Overhead[$i_Fac - 1]) / $N
    Next
    #EndRegion Zweite Messung
    
    
    ; Ergebnisse in Zwischenablage für Excel sowie als ArrayDisplay
    ClipPut(StringReplace(_ArrayToString($a_Result, @TAB), ".", ","))
    _ArrayDisplay($a_Result)
    Alles anzeigen
  • Daten aus einem DOS Fenster in ein Array übertragen und bearbeiten

    • AspirinJunkie
    • 25. Juli 2017 um 15:30

    Wie gesagt - das ganze lässt sich durchaus auch in einer Zeile per Stringfunktionen abhandeln.
    Aber du hast dich ja darauf versteift erst den Input in ein Array zu konvertieren und dann entsprechend zu beackern mit allem was da noch dran hängt.

    Alles was du brauchst wäre die _RunCmd-Funktion von oben + der bereits gepostete Aufruf von StringRegExp.

  • Daten aus einem DOS Fenster in ein Array übertragen und bearbeiten

    • AspirinJunkie
    • 25. Juli 2017 um 11:14

    Ah - Aufgabe falsch verstanden

  • Daten aus einem DOS Fenster in ein Array übertragen und bearbeiten

    • AspirinJunkie
    • 25. Juli 2017 um 11:08

    Ja wie gesagt - wenn es schon als Array vorliegt durchgehen und per StringLeft extrahieren:

    AutoIt
    #include <Array.au3>
    
    
    Global $a_Test[] =[802, "Usage data is 8 minutes old. Next update in 8 minutes.", "", "e1234567 XDT_PLT_UD 2018.1231", "e1231224 XDT_PLT_UD 2018.1231"]
    _ArrayDisplay($a_Test, "Array vorher")
    
    
    For $i = 2 To UBound($a_Test) -1
    	$a_Test[$i] = StringLeft($a_Test[$i], 8)
    Next
    _ArrayDisplay($a_Test, "Array nachher")
    Alles anzeigen


    Den Umweg über das Array muss man wahrscheinlich aber gar nicht machen.
    Die Rückgabe von _RunCmd() gibt die Ausgabe als String zurück.
    Diesen kann man direkt mit Stringfunktionen bearbeiten:

    AutoIt
    #include <Array.au3>
    Global $s_String = "Usage data is 8 minutes old. Next update in 8 minutes." & @CRLF & "" & @CRLF &"e1234567 XDT_PLT_UD 2018.1231" & @CRLF &"e1231224 XDT_PLT_UD 2018.1231"
    
    
    MsgBox(0,"Eingabestring", $s_String)
    
    
    $a_Ret = StringRegExp($s_String, '(?m)^(e\d{7})\b', 3)
    _ArrayDisplay($a_Ret, "Extrahierte Elemente")
  • Daten aus einem DOS Fenster in ein Array übertragen und bearbeiten

    • AspirinJunkie
    • 25. Juli 2017 um 10:39

    Du kannst direkt den StdOut-Stream auswerten statt den Umweg über eine Datei zu gehen:

    AutoIt
    Local $a_Parameter[] = ["/A", "/W"]
    $s_Out = RunCmd("dir", $a_Parameter, True)
    If @error Then ConsoleWrite("!!!! Error !!!!:" & @CRLF & @error & @CRLF & @extended & @CRLF & @CRLF)
    
    
    MsgBox(0,"", $s_Out & @CRLF)
    
    
    
    
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: RunCmd()
    ; Description ...: runs commandline programs or cmd-command and return their output
    ; Syntax ........: RunCmd($s_Cmd, [$sParameter = '', [$b_CmdSpec = False, [$WorkDir = @WorkingDir]]])
    ; Parameters ....: $s_Cmd        - the command which should be executed (can be full command or without parameters)
    ;                  $sParameter   - additional parameters for the command (also array of parameters)
    ;                  $b_CmdSpec    - If true the command is interpreted as a command for cmd.exe
    ;                  $WorkDir      - the working directory
    ; Return values .: Success: returns a string with the output
    ;                  Failure: set @error and returns a debug-string
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func RunCmd($s_Cmd, $sParameter = '', $b_CmdSpec = False, $WorkDir = @WorkingDir)
        Local Static $h_User32DLL = DllOpen('user32.dll')
        If @error Then Return SetError(1, @error, "")
    
    
    	If $b_CmdSpec Then $s_Cmd = @ComSpec & " /c " & $s_Cmd
    
    
    	Local $s_Ret, $s_Line, $s_Err
    
    
    	If $sParameter <> '' Then
    		If IsArray($sParameter) Then
    			Local $s_Par = ""
    			For $j In $sParameter
    				$s_Par &= " " & $j
    			Next
    			$sParameter = $s_Par
    		Else
    			$sParameter = ' ' & $sParameter
    		EndIf
    	EndIf
    
    
    	Local $iPID = Run($s_Cmd & $sParameter, $WorkDir, @SW_HIDE, 0x2 + 0x4)
    	If @error Then Return SetError(2, @error, "")
    
    
    	Do
    		Sleep(10)
    		$s_Line = StdoutRead($iPID)
    		If @extended > 0 Then $s_Ret &= $s_Line
    	Until @error
    
    
    	Do
    		Sleep(10)
    		$s_Line = StderrRead($iPID)
    		If @extended > 0 Then $s_Err &= $s_Line
    	Until @error
    
    
    	$s_Ret = DllCall($h_User32DLL, 'BOOL', 'OemToChar', 'str', $s_Ret, 'str', '')[2]
    
    
    	If $s_Err <> "" Then
    		If $s_Ret <> "" Then Return SetError(3, 0, "------- StdOut -----------" & @CRLF & $s_Ret & @CRLF & @CRLF & "------- StdErr -----------" & @CRLF & $s_Err)
    		Return SetError(3, 0, $s_Err)
    	EndIf
    	Return $s_Ret
    EndFunc   ;==>RunCmd
    Alles anzeigen
    Zitat von daMeier

    Nun im nächsten Schritt sind im Array 100te von Zeilen mit folgendem Inhalt:

    a04545454 DLX_DDDFLCX 16555
    a04547544 DLX_DDDFLCX 16555
    usw.

    Aus diesem Inhalt benötige ich nur den ersten Teil z.B. a04547544 kann ich im Array mit Strings arbeiten, wenn ja was wäre der richtige weg?

    Wenn die Länge des ersten Teiles konstant ist dann zeilenweise durchgehen und per StringLeft das rausschneiden was du benötigst.
    Ist es etwas komplexer dann wäre StringRegEx eine andere Methode.
    Da bräuchte man aber etwas mehr Infos zum Aufbau.

  • Dateinen in "C:\Program Files" kopieren

    • AspirinJunkie
    • 25. Juli 2017 um 10:25

    Ja das wäre der Ordner für 32-Bit-Programme.
    Dein Admin-Rechte-Problem bleibt weiterhin bestehen.

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™