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

  • Daten in JSON anlegen - Struktur korrekt?

    • AspirinJunkie
    • 19. September 2022 um 12:26

    Da sind noch ein paar syntaktische Probleme drin.

    1. "error list": hinter diesem Key steht ein Array mit nur einem einzigen Wert - nämlich ein Object (Dictionary). Ist das so beabsichtigt? Also kommen da noch mehr Objekte in das Array oder war eher gemeint, dass gleich das Object als Wert dem Key "error list" zugeordnet werden soll?

    2. Dieses Object mit den Error-Codes. Du hast hier ein Object deren Keys mehrmals verwendet werden (der Key "code"). Das ist streng genommen gar nicht mal verboten in JSON aber könnte spätestens dann bei den Implementierungen problematisch werden. Z.B. in AutoIt: Dort wird man ein Object naheliegenderweise als Dictionary oder Map abbilden. Dort wiederrum sind nur unique-Keys erlaubt und du bekommst ein Problem mit deiner JSON.

    3. Der Eintrag "code": 108 [ Das geht so nicht. Im Grunde sagt es erstmal aus, dass im Object unter dem Key "code" der Integerwert 108 steht. Direkt darauf folgt aber gleich eine Array-Definition. Was soll also eine Abfrage nach Code bringen? - den Wert 108 oder das Array? Nur eines von beiden geht.

    4. Die Datentypen der Einträge wechseln. Mal ist. z.B. reason und disposal ein Array, mal ein String. Das geht natürlich aber es führt zu einer nötigen Fallunterscheidung im Auswerteprogramm. Wenn man z.B. hierfür immer ein Array nimmt - egal ob nur 1 Eintrag oder 100, dann reicht trotzdem ein und der selbe Code hierfür.


    Ich rate daher einfach mal und schlage folgenden Aufbau vor:

    Code
    {
      "errorcode version": "0.0.1",
      "error-list": {
        "108": [
          {
            "device": [
              "Device_A",
              "Device_B",
              "Device_C"
            ],
            "name": "ClockTimeError",
            "description": "Fehler Echtzeituhr",
            "reason": [
              "Uhrzeit nicht gestellt",
              "Batterie auf Mainboard leer",
              "Mainboard defekt"
            ],
            "disposal": [
              "Uhrzeit stellen",
              "Batterie auf Mainboard ersetzen",
              "Mainboard ersetzen"
            ]
          },
          {
            "device": [
              "Device_D",
              "Device_E"
            ],
            "name": "TemperatureError",
            "description": "Fehler Temperatursensor",
            "reason": [
              "Sensor defekt oder nicht angeschlossen"
            ],
            "disposal": [
              "Sensor anschliessen oder ersetzen"
            ]
          }
        ],
        "333": [
          {
            "device": [
              "Device_A",
              "Device_B",
              "Device_C",
              "Device_D",
              "Device_E"
            ],
            "name": "LogBatteryError",
            "description": "Fehler Log-Speicherbatterie",
            "reason": [
              "Spannung auf kritischen Wert gefallen"
            ],
            "disposal": [
              "Batterie ersetzen"
            ]
          }
        ]
      }
    }
    Alles anzeigen
  • Suche Hilfe - unzulässige Zeichen bei Dateinamen ersetzen - mit "StringRegExp" für ANFÄNGER!

    • AspirinJunkie
    • 14. September 2022 um 13:31
    Zitat von Bitnugger

    mit dem Pattern ist es etwas komplizierter...

    muss es aber nicht. Man kann auch direkt in RegEx escapen:

    AutoIt
    $sPattern = '[\Q' & $sIllegalCharacters & '\E]'

    Andy

    Jo du hast schon Recht - die Funktion ist irgendwie Tinnef.

  • htmlfile Objekt und <META> Tags

    • AspirinJunkie
    • 12. September 2022 um 15:41
    Zitat von Moombas

    AspirinJunkie

    Und zur Doku geht es hierlang: https://www.w3.org/TR/selectors-api/#queryselector

    Und was sagt uns, dass dieses "htmlfile"-Objekt der dort dokumentierten API entspricht?
    Ich habe bisher keine Schnittstellenbeschreibung zum Objekt selbst gefunden.

    Wenn man ein Error-Event mit implementiert bekommt man als Fehlermeldung 0x80020006-"Unbekannter Name" - deutet für mich darauf hin, dass das Objekt gar keine Methode querySelector enthält.

    Zitat von Velted

    Ja, das funktioniert ja mit AHK.

    Dann zeig doch mal den funktionerenden AHK-Code

  • htmlfile Objekt und <META> Tags

    • AspirinJunkie
    • 12. September 2022 um 11:22

    Gibt es denn überhaupt die Methode querySelector in diesem Objekt?
    Wo findet sich die Doku zu diesem htmlfile-Objekt?

  • Suche Hilfe - unzulässige Zeichen bei Dateinamen ersetzen - mit "StringRegExp" für ANFÄNGER!

    • AspirinJunkie
    • 11. September 2022 um 20:17

    Doku lesen hilft anscheinend - muss ich mir mal beherzigen.

    Dann wäre wieder ein Rätsel gelöst.

    Einen kleinen Klugschiss kann ich mir zum Sonntagabend aber nicht verkneifen: statt SetError(0, ...) könnte man eher ein SetExtended() nehmen... 8o

  • Suche Hilfe - unzulässige Zeichen bei Dateinamen ersetzen - mit "StringRegExp" für ANFÄNGER!

    • AspirinJunkie
    • 11. September 2022 um 17:19
    Zitat von Andy

    Was aber zu Leerzeichen innerhalb des Dateinamens führt

    So war die Aufgabenstellung

    Zitat von Andy

    habe gerade gesehen, dass ein / durch ein - ersetzt statt gelöscht wird?!

    Hm - interessant. Du meinst die PathCleanupSpec() oder?

    Scheint eine Eigenart dieser Funktion zu sein.
    Ich kenne mich mit der aber nicht wirklich aus um zu entscheiden ob das gewollt oder ein Bug ist.

  • Suche Hilfe - unzulässige Zeichen bei Dateinamen ersetzen - mit "StringRegExp" für ANFÄNGER!

    • AspirinJunkie
    • 11. September 2022 um 13:12

    Deine konkrete Liste würde man so übersetzen: $sNewName = StringRegExpReplace($sFilename, '[~"#%&:;<>?!\/\\{|}^°²³[\]'']', ' ')

    Mit den Windows-Dateinamenkonventionen hat dies aber nicht unbedingt etwas zu tun, da z.B. die Raute in Dateinamen erlaubt ist.

    Wenn es stattdessen darum geht, alle nicht-erlaubten Zeichen zu entfernen, dann kann man auch folgende Windows-API-Funktion verwenden:

    AutoIt
    $sName = "Teste \mich"
    
    $sNameClean = _cleanFileNameChars($sName)
    MsgBox(0, "", $sNameClean)
    
    
    Func _cleanFileNameChars($sFileName)
        Local $aCall = DllCall("Shell32.dll", "int", "PathCleanupSpec", "WSTR", "", "WSTR", $sFileName)
        If @error Then Return SetError(@error, StringLen($sFileName), Null)
        Return $aCall[2]
    EndFunc
    Alles anzeigen
  • Warten auf Ende von CMD Prozessen

    • AspirinJunkie
    • 2. September 2022 um 05:40
    Zitat von casi4712

    ich möchte dass die Messagebox erst kommt wenn beide Prozeße beendet sind, die in der Schleife gestartet sind, auf die Funktion kann ich ja wohl kein RunWAIT anwenden, oder?

    Run gibt die Prozess-ID des gestarteten Prozesses als Rückgabewert.
    Wenn man sich also diese Prozess-IDs wegspeichert (am naheliegendsten in ein Array), dann kann man anschließend dieses Array durchgehen und solange checken ob die zugehörigen Prozesse noch laufen.

    Ungetestet z.B. so:

    AutoIt
    Func _Format()
        Local $aPIDs[$aArray[0][0]]
    
        For $i = 1 To $aArray[0][0]
            $aPIDs[$i - 1] = Run(@ComSpec & " /c " & "FORMAT " & $aArray[$i][0] & " /FS:" & $Formattyp & " /Y /V:" & $sStickname & " " & $Formatartset, "", @SW_SHOW) ; /Q für Quickformat
            ConsoleWrite($aArray[$i][0] & @CRLF) ; *** nur zur Testanzeige
        Next
    
        ; Warten bis alle Prozesse beendet wurden:
        Local $bBeendet
        Do
            $bBeendet = True
            Sleep(100)
    
            For $iPID In $aPIDs
                If ProcessExists($iPID) Then
                    $bBeendet = False
                    ExitLoop
                EndIf
            Next
        Until $bBeendet
    
        MsgBox(262144, "Info", "Alle Formatierungen beendet", $WS_EX_TOPMOST)
    EndFunc   ;==>_Format
    Alles anzeigen

    Wo kommen eigentlich die ganzen Variablen wie $aArray, $Formattyp usw. her?
    Das müssten ja globale Variablen sein, da die Funktion keine Parameter hat.
    Wenn du das ganze schon in Funktionen verpackst, solltest du diese am besten als Parameter der Funktion übergeben, das würde die Wiederverwendbarkeit der Funktion enorm steigern, da sie ja aktuell komplett von den Rahmenbedingungen des Skriptes drumherum abhängig ist.

  • Ini2Array() : Ini-Datei in Array einlesen + IniGetAllKeys() : Array mit allen vorkommenden Keys einer Ini-Datei erzeugen

    • AspirinJunkie
    • 28. August 2022 um 12:59
    Zitat von HansJ54

    _ArrayMinMax() hat keinen Range, den man für die Untersuchung angeben kann (z.B. Zeile 2-9 + Spalte 2-4)?

    Dafür gibt es ja _ArraySlice (siehe unten).
    Wenn man die Spalten eingrenzt wird man aber dann Schwierigkeiten haben das Ergebnis zu interpretieren, da die Spalten an jeweils anderen Stellen stehen.

    Zitat von HansJ54

    Kann man einem neuen Array direkt einen Range aus einem bestehenden Array zuweisen? Also $aB = (Zeile 2-9 und Spalte 2-4) aus Array $aA?

    AutoIt
    _ArraySlice($aArray, "[1:8][1:3]")
  • Ini2Array() : Ini-Datei in Array einlesen + IniGetAllKeys() : Array mit allen vorkommenden Keys einer Ini-Datei erzeugen

    • AspirinJunkie
    • 25. August 2022 um 14:32
    Zitat von HansJ54

    Ich sollte mal schneller hier reinschauen, bei mir sind es bisher mehr als 30 Zeilen Code und AspirinJunkie macht das mit 5 8)

    Es funktioniert einwandfrei für meine Fälle, allerdings vom Verstehen bin ich ganz weit entfernt. :Face:

    Die meisten Sortierfunktionen (gibt Ausnahmen wie Radix oder tlw. Bucketsort) basieren auf einem Größer/Kleiner-Vergleich von jeweils 2 Elementen. Also irgendwo im Sortieralgorithmus wird geschaut ob von den beiden gerade betrachteten Elemente das erste größer oder kleiner ist als das andere und dementsprechend werden die dann neu eingereiht.
    Das normale Arraysort nimmt ganz einfach den AutoIt-internen Vergleich von 2 Variablen ($A > $B bzw. $A < $B).

    Das klappt bei Zahlen und auch den meisten Strings ganz gut - bei speziellen Sachen - wie eben bei dir - bringt der jeweilige Größenvergleich nicht das gewünschte Ergebnis.
    Daher wäre es ganz gut, wenn man für diese Fälle eine Sortierfunktion hätte, wo man selbst angeben kann wie der Größer/Kleiner-Vergleich gemacht werden soll. Exakt das macht meine Funktion _ArraySortFlexible.
    Nun zum konkreten "NaturalSort". Die Größer/Kleiner-Vergleichsfunktion hierzu welche auch bei Versionsnummern und Zahlen innerhalb des Strings ordentlich größer/kleiner für die Sortierung zurückgibt kann man natürlich in reinem AutoIt schreiben.
    Das ist etwas aufwendig aber machbar (haben wir irgendwo schonmal im Forum hier gemacht).

    Einfacher ist es jedoch sich einfach die Vergleichsfunktion zu nehmen, welche der Windows Explorer für seine Sortierung verwendet.
    Die macht nämlich genau das was wir wollen.

    Diese heißt StrCmpLogicalW und die Funktion _MyCompare aus meinem Beispiel macht nichts weiter, als diese Funktion mit den AutoIt-Variablen aufzurufen und das Ergebnis zurückzugeben - sprich: ein Wrapper für diese Funktion.

    Zitat von HansJ54

    AspirinJunkie Im Beispiel unten gibt es ein Problem mit der Sortierung der "Release #nn" - da klappt die Sortierung (#29 vor #2) nicht - für mich nicht wichtig, kommt bei mir nicht vor.

    Nach der zweiten Spalte wird überhaupt nicht sortiert - nur nach der ersten.

    Möchte man, wenn die 1. Spalte gleich groß ist, anschließend nach der 2. Spalte sortieren, dann muss man die Vergleichsfunktion noch entsprechend anpassen:

    AutoIt
    #include "ArrayPlus.au3"
    
    Local $aVersionsAndReleases[][] = [["999.2.8.9", "Release #1"],["1000.2.9.10", "Release #3"],["0.2.8.10", "Release #9"],["0.2.8.9999", _
        "Release #10"],["0.2.8.19999", "Release #10"], ["0.2.8.10", "Release #2"],["0.3", "Release #5"],["0.39999.101", "Release #5"], _
        ["0.3.9999", "Release #5"],["0.2.8.10", "Release #29"]]
    
    _ArraySortFlexible($aVersionsAndReleases, _MyCompare)
    _ArrayDisplay($aVersionsAndReleases)
    
    ; benutzerdefinierte Vergleichsfunktion um das Array "natürlich" erst absteigend nach der 1., und dann aufsteigend nach der 2. Spalte zu sortieren
    Func _MyCompare(ByRef $A, ByRef $B)
        Local Static $h_DLL_Shlwapi = DllOpen("Shlwapi.dll")
        Local $iRet = -DllCall($h_DLL_Shlwapi, "int", "StrCmpLogicalW", "wstr", $A[0], "wstr", $B[0])[0]
        Return $iRet <> 0 ? $iRet : DllCall($h_DLL_Shlwapi, "int", "StrCmpLogicalW", "wstr", $A[1], "wstr", $B[1])[0]
    EndFunc   ;==>_MyCompare
    Alles anzeigen
    Zitat von HansJ54

    aber z.B. für das Beispiel unten nur das Maximum oder die Zeile des Maximums zu ermitteln dazu reicht es bei mir nicht.

    Wenn es ebenfalls mit dem Natural-Sort das Min/Max bestimmt werden soll dann so:

    AutoIt
    #include "ArrayPlus.au3"
    
    Local $aVersionsAndReleases[][] = [["999.2.8.9", "Release #1"],["1000.2.9.10", "Release #3"],["0.2.8.10", "Release #9"],["0.2.8.9999", _
        "Release #10"],["0.2.8.19999", "Release #10"], ["0.2.8.10", "Release #2"],["0.3", "Release #5"],["0.39999.101", "Release #5"], _
        ["0.3.9999", "Release #5"],["0.2.8.10", "Release #29"]]
    
    $aMinMax = _ArrayMinMax($aVersionsAndReleases, Default, _MyCompare)
    ; 1. Zeile: Minimum
    ; 2. Zeile: Maximum
    ; 3. Zeile: Zeilen-Index von Minimum
    ; 4. Zeile: Zeilen-Index von Maximum
    _ArrayDisplay($aMinMax, "Min/Max-Werte")
    
    
    Func _MyCompare(ByRef $A, ByRef $B)
        Local Static $h_DLL_Shlwapi = DllOpen("Shlwapi.dll")
        Return DllCall($h_DLL_Shlwapi, "int", "StrCmpLogicalW", "wstr", $A, "wstr", $B)[0]
    EndFunc   ;==>_MyCompare
    Alles anzeigen

    Ohne spezielle Anforderungen an die Datentypen ist es entsprechend einfacher:

    AutoIt
    #include "ArrayPlus.au3"
    
    Local $aVersionsAndReleases[][] = [["999.2.8.9", "Release #1"],["1000.2.9.10", "Release #3"],["0.2.8.10", "Release #9"],["0.2.8.9999", _
        "Release #10"],["0.2.8.19999", "Release #10"], ["0.2.8.10", "Release #2"],["0.3", "Release #5"],["0.39999.101", "Release #5"], _
        ["0.3.9999", "Release #5"],["0.2.8.10", "Release #29"]]
    
    $aMinMax = _ArrayMinMax($aVersionsAndReleases)
    ; 1. Zeile: Minimum
    ; 2. Zeile: Maximum
    ; 3. Zeile: Zeilen-Index von Minimum
    ; 4. Zeile: Zeilen-Index von Maximum
    _ArrayDisplay($aMinMax, "Min/Max-Werte")
    Alles anzeigen


    Zitat von HansJ54

    Und ist "Array-Plus-UDF" der Nachfolger von "DynArray"?

    Teils. Die Hauptaufgabe der Dynarray ist es dynamische Arrays in AutoIt zu haben.
    Mit der Einführung von Maps und insbesondere dessen Funktion MapAppend ist diese Aufgabe ein Stück obsolet geworden.
    Daneben diente die UDF aber auch als Container für weitere Array-Funktionen von mir, welche da streng genommen eigentlich thematisch nicht reingehören. Diese liegen nun redundant auch in der ArrayPlus.au3.
    Ich müsste daher die DynArray mal aufräumen und auf deren eigentlichen Zweck hin wieder entschlacken.

    Die nicht-dynamischen Arrayfunktionen sind jetzt in der ArrayPlus-UDF zu finden.


    So und nun zurück in den Urlaubsmodus und mit den Kindern an die Strandbar... 8)

  • paralleler CMD start mit schleife

    • AspirinJunkie
    • 13. August 2022 um 10:15

    1. Run() wartet nicht. Wie bereits gesagt, machst du also irgendetwas anderes wenn dein Skript erst weiterläuft, wenn der Befehl beendet wurde.

    Man kann es also doch mit dem Aufruf von notepad vergleichen.

    2. Du kannst auch mehrere Prozesse mit Run starten, und deren jeweiligen Output per StdOutRead auswerten.

    Geht alles - da würde man das Skript aber wohl bisschen umstricken und die ProzessIDs eher in einem Array halten oder sowas.

    War aber bei dir ja bisher nicht zu sehen.

    3. Willst du tatsächlich AutoIt-Code parallel ausführen, geht dies lediglich über Multi-Processing.
    Also in der Regel ein Master-Skript, welches für die jeweiligen Unterjobs entsprechende Slave-Skripte aufruft.
    Das läuft dann tatsächlich parallel.

    Ein Ansatz hierfür findest du >>hier<<.

  • Informationen aus API richtig verwenden

    • AspirinJunkie
    • 7. August 2022 um 09:13
    Zitat von Michi91

    Spucken solche APIs immer Strings im JSON Format aus?

    Oft - da JSON halt entsprechende Vorteile hierfür bietet.
    Aber ein Gesetz ist das nicht - jeder kann seine APIs so bauen wie er möchte und auch die Daten so formatieren wie er es für richtig hält.
    Daher kurze Antwort: Nein

  • Informationen aus API richtig verwenden

    • AspirinJunkie
    • 7. August 2022 um 08:18

    Diese Strings sind formatierte Datenstrukturen im Format JSON.
    Sie werden öfter in Web-APIs eingesetzt, da sie zum einen relativ kompakt, gut maschinenlesbar und gleichzeitig auch für Menschen gut lesbar sind.

    Wenn man so einen String auswerten möchte, sollte man den String also entsprechend behandeln.

    Für AutoIt gibt es diverse UDFs hierfür.

    Mit >>dieser<< würde man dein Beispiel folgendermaßen umsetzen:

    AutoIt
    #include <JSON.au3>
    
    $sSource = '{"coord":{"lon":139,"lat":35},"weather":[{"id":804,"main":"Clouds","description":"Bedeckt","icon":"04d"}],"base":"stations","main":{"temp":27.4,"feels_like":31.13,"temp_min":26.65,"temp_max":27.4,"pressure":1010,"humidity":84},"visibility":10000,"wind":{"speed":0.54,"deg":131,"gust":1.2},"clouds":{"all":92},"dt":1659846407,"sys":{"type":2,"id":2019346,"country":"JP","sunrise":1659815850,"sunset":1659865332},"timezone":32400,"id":1851632,"name":"Shuzenji","cod":200}'
    
    ; JSON-String in verschachteltes AutoIt-Objekt parsen
    $oData = _JSON_Parse($sSource)
    
    ; die einzelnen, benötigten Werte auslesen
    $sDescription = _JSON_Get($oData, "weather[0].description")
    $fTemp        = _JSON_Get($oData, "main.temp")
    $fHumidity    = _JSON_Get($oData, "main.humidity")
    $fWind        = _JSON_Get($oData, "wind.speed")
    $sCity        = _JSON_Get($oData, "name")
    
    ; Werte ausgeben
    ConsoleWrite($sDescription & @CRLF & _
                 $fTemp & @CRLF & _
                 $fHumidity & @CRLF & _
                 $fWind & @CRLF & _
                 $sCity & @CRLF)
    Alles anzeigen

    Der String den du gepostet hast, ist primär platzsparend formatiert - also ohne Zeilenumbrüche und Leerzeichen. Um sich die Struktur der Daten jedoch klarer zu machen, bietet es sich an den JSON-String noch entsprechend formatiert darzustellen (sprich: Zeilenumbrüche und Leerzeichen einzufügen um die Hierarchie erkennbar zu machen). Dafür gibt es etliche Online-Tools wie z.B. >>hier<< oder die Funktion _JSON_Generate() aus der hier verwendeten UDF.

    Zitat von Michi91

    Meine Methode funktioniert zwar prima, scheint mir aber recht umständlich.

    Die funktioniert halt nur solange, wie der Aufbau des Strings konstant bleibt.
    Wenn mal die Reihenfolge der Werte ändert, ein Wert zwischen drin hinzukommt oder entfernt wird, scheitert der Ansatz, da dieser ja auf Zählen bestimmter Zeichen basiert.

  • Daten aus #cs / #ce einlesen / nutzen

    • AspirinJunkie
    • 28. Juli 2022 um 06:03
    Zitat von Alina

    Beide Resultate sind im Script in Zeile 8 und 9 zu finden und das ist zwischen #cs u. #ce.

    Das ist bei dem Pattern schlicht Zufall, da dieses überhaupt nicht zwischen Kommentarbereich und sonstigem unterscheidet.

    Um zu verstehen, was dieses Pattern genau macht, habe ich es mal bisschen aufbereitet und kommentiert hingeschrieben:

    Code
    (?mx)
    ^\s*;.*(*SKIP)(?!)              # ignoriere reine Kommentarzeilen
    |^\s*\#.*\s*<.*(*SKIP)(?!)      # ignoriere #include-Zeilen deren Pfad in <> stehen (die mitgelieferten UDFs normalerweise)
    |^.*DllCall.*(*SKIP)(?!)        # ignoriere alle Zeilen, welche das Wort "DLLCall enthalten"
    |([\w\.\(\:\)*\\]+\w+.\.\w{3})  # matche eine Art Pfadangaben (nicht genau, da ":" und "*" irgendwo enthalten sein können), welche auf 3 Zeichen Dateiendung enden (könnten auch mehr sein - wird dann aber nicht mit gematcht) 

    Um also den Inhalt aus dem Comment-Block zu erhalten ist Exit's Ansatz wohl der pragmatischste und vor allem später am einfachsten wieder nachzuvollziehende.

    Soll es dennoch auf Teufel-komm-raus per RegEx geschehen, dann könnte man das Pattern gleich so gestalten, dass es auch mit verschachtelten Kommentarblöcken klar kommt:

    AutoIt
    #cs ----------------------------------------------------------------------------
    
     AutoIt Version:  3.3.14.5
     Author:          myName
    
     Script Function: Template AutoIt script.
    
    #include "MsgBoxConstants.au3"
    #include "StringConstants.au3"
    
    
    #ce ----------------------------------------------------------------------------
    
    #include <Array.au3>
    
    ; Script Start - Ab hier Script schreiben !
    #comments-start
    Test
    #cs
    Ich bin verschachtelt
    #ce
    Test 2
    #comments-end
    
    For $sCommentBlock In  StringRegExp(FileRead(@ScriptFullPath), '(?mi)^\h*\#(?>cs|comments-start)\b\N*\R((?sU:(?>(?R)|.)*))^\h*\#(?>ce|comments-end)\b.*\R', 3)
        msgbox(0, "Kommentarblock", $sCommentBlock)
    Next
    Alles anzeigen
  • SAX XML-Parser - anderer Parsing-Ansatz für die Behandlung von XML-Daten

    • AspirinJunkie
    • 27. Juli 2022 um 20:27

    kannst du gerne ergänzen. Die stehen in der Map $mAttributes. Jeder kann sich ja genau nur die Infos ziehen die der braucht.

  • SAX XML-Parser - anderer Parsing-Ansatz für die Behandlung von XML-Daten

    • AspirinJunkie
    • 27. Juli 2022 um 13:25

    Für das Parsing von XML-Dateien ist die wohl bekannteste die DOM-Methode (In AutoIt z.B. über das Microsoft.XMLDOM-Objekt).
    Hierbei wird die XML-Datei einmal durchgearbeitet und ein verschachtelter Elementbaum erstellt, welchen man anschließend programmiertechnisch weiterbehandeln kann.

    Diese Methode ist allerdings ziemlich aufwendig für den Rechner.

    Er muss die ganze Datei durchgehen und dabei für jedes Element eine Struktur im DOM anlegen - egal ob man das Element am Ende überhaupt benötigt.

    Speichertechnisch ist der Ansatz ebenso ziemlich unglücklich.

    Ein etwas weniger bekannter Ansatz, welcher in der angehangenen UDF implementiert wurde, bietet sich hierbei als Alternative an: Die >>Simple API for XML (SAX)<<

    Bei diesem Ansatz wird die Datei einmal sequentiell durchgegangen und an verschiedenen Haltepunkten, werden bei Bedarf Events geschmissen.
    Im konkreten AutoIt-Fall bedeutet dies z.B.: Eine nutzerdefinierte Funktion wird aufgerufen, wenn ein neues XML-Element anfängt oder endet.
    Oder es wird eine benutzerdefinierte Funktion aufgerufen, wenn gerade der Inhalt eines Elementes verarbeitet wird.

    Das klingt erstmal verwirrend und man muss durchaus erstmal ein wenig umdenken.
    Am Hilfreichsten hierzu ist sicherlich das kleine Beispiel, welches ich hinzugefügt habe.

    Wenn man das Prinzip jedoch erst einmal verstanden hat, wird man mit einem fixen, ressourcenschonenden, komplett in reinem AutoIt geschriebenen XML-Parser belohnt.

    Außerdem sind SAX-Parser robuster gegenüber Fehlern im XML-Dokument.

    Changelog:

    28.07.2022 Heftigst an der Performance-Schraube gedreht
    Umstellung der Parameterreihenfolge
    01.08.2022 Weitere Performanceverbesserungen

    Dateien

    SAX XML-Parser.zip 4,31 kB – 355 Downloads
  • ArrayPlus-UDF - weitere Helferlein für den täglichen Umgang mit Arrays

    • AspirinJunkie
    • 12. Juli 2022 um 10:48

    Ich habe nun beide Ergänzungen von dir in der _ArrayCreate() implementiert.

    Einmal die exklusiven Grenzen: indem man runde öffnende oder schließende Klammern verwendet.

    Zum anderen die Anzahl der Schritte: Hierzu einfach den 3. Wert anstatt mit ":" (=Schrittgröße) mit einer Pipe "|" abtrennen, dann wird die Schrittgröße selbstständig berechnet.

    Ansonsten gab's auch für andere Dinge ein Update und ein paar neue Funktionen.

  • Inputwert eingrenzen neg. & pos. Werte

    • AspirinJunkie
    • 12. Juli 2022 um 06:16

    Bin nicht so fit mit GUIs, könnte deswegen sein, dass es elegantere Methoden gibt um Wertebereiche vorzugeben.
    Aber spontan hätte ich es einfach mit einer Prüfung gemacht, sobald der Wert im Input sich ändert.
    Und hierbei nehme ich persönlich lieber den OnEventMode anstatt der Message-Loop:

    AutoIt
    #include <GUIConstantsEx.au3>
    Opt("GUIOnEventMode", 1)
    
    GUICreate("", 121, 61)
    GUISetOnEvent($GUI_EVENT_CLOSE, "_raus")
    
    $idInput = GUICtrlCreateInput("500", 72, 8, 41, 28)
    GUICtrlSetOnEvent(-1, "_InputPruefen") ; ruft bei Änderungen die angegebene Funktion auf
    
    GUICtrlCreateLabel("Input: ", 8, 8, 61, 32)
    
    GUISetState(@SW_SHOW)
    
    
    ; Endlosschleife um GUI am Leben zu erhalten
    While Sleep(100)
    WEnd
    
    
    Func _InputPruefen()
        Local Static $iVorher = 500    ; der vorherige Wert auf den zurückgesetzt werden kann
        Local $iVal = Int(GUICtrlRead(@GUI_CtrlId))    ; der aktuelle Wert des Input-Feldes
    
        If Abs($iVal) > 750 OR Abs($iVal) < 250 Then
            MsgBox(48, "Falsche Eingabe", "Wert außerhalb des Wertebereiches")
            GUICtrlSetData(@GUI_CtrlId, $iVorher)
        Else
            $iVorher = $iVal
        EndIf
    EndFunc
    
    
    Func _raus()
        Exit
    EndFunc
    Alles anzeigen
  • ArrayPlus-UDF - weitere Helferlein für den täglichen Umgang mit Arrays

    • AspirinJunkie
    • 10. Juli 2022 um 09:45
    Zitat von Mars

    Das wäre ein Vorschlag für etwas das man hier ergänzen könnte (ich weiß aber nicht wie man das hier geschickt einbaut ohne unnötig viele Parameter zu haben, vielleicht wirklich via String parsing (also "(0, 1)" steht für das beidseitig offene Intervall, "[0, 1]" steht für das beidseitig abgeschlossene Intervall).

    Der Vorschlag ist klasse. Ich denke ich werde die Syntax mit der runden Klammer genauso in die _ArrayCreate mit einbauen.

  • Email empfang

    • AspirinJunkie
    • 6. Juli 2022 um 05:40

    Möglichkeit 1 ist, du implementierst die Mail-Netzwerkprotokolle in AutoIt.
    Zum Abrufen von E-Mails wären dies POP3 oder IMAP.
    POP3 wird heute eher nicht mehr groß eingesetzt, da die Mails nach dem Abruf vom Server verschwunden sind.
    IMAP ist eher der aktuellere Standard.
    Das würde man wohl auch irgendwie implementiert bekommen (für AutoIt gibt es auch glaube eine hornsalte UDF).
    Problem hierbei wäre dann aber, dass das heutzutage nur transportverschlüsselt eingesetzt wird. Sprich: Du musst noch TLS/SSL implementieren.
    Und spätestens hier wäre dann mit AutoIt Schluss. Stattdessen müsstest du eher OpenSSL/LibreSSL mit einbinden oder per Kommandozeile steuern.

    Kurz: Alles in AutoIt wäre selbst mit High-End-Skills ein Mammutprojekt

    Möglichkeit 2: Einen kommandozeilenbasierten E-Mail-Client nehmen.
    Meines Wissens bringt OpenSSL hierzu alles mit.
    Du müsstest hierbei die Steuerung kommandozeilenbasiert in AutoIt implementieren.
    Klingt erstmal recht entspannt, kann sich aber im Detail ziemlich ausweiten, insbesondere wenn man das ganze fehlertolerant implementieren will.

    Möglichkeit 3: Outlook per COM steuern.
    Wenn es sowieso installiert ist, kann man es auch nutzen.
    Ähnlich wie Excel/Word usw. lässt sich auch dies unsichtbar im Hintergrund verwenden.
    Water ist da natürlich der richtige Ansprechpartner.

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™