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

  • Flags auswerten mit Bitmasken - Verständnisfrage

    • AspirinJunkie
    • 10. Februar 2021 um 07:53
    Zitat von Professor Bernd

    Oder ist am Ende alles gleich?

    Kommt darauf an, welche Unterschiede du meinst.
    Bei der Programmlogik unterscheiden sie sich schon massiv, denn beim zweiten Beispiel wird unsinnigerweise ne Schleife verwendet und damit jedes einzelne BitAnd dort 7x aufgerufen anstatt nur einmal wie es ausreichend wäre. Ich vermute einfach die Schleife kam nur deshalb mit rein weil der Autor auf Biegen und Brechen Switch-Case verwendne wollte und noch nie was von ContinueCase gehört hat. Die zweite Variante ist also massiv ineffizient. Und obendrauf wird auch noch ein Switch-Case ohne Auswertung der Expression verwendet anstatt einem Select-Case.

    Wie die Abfrage der Bits dann exakt mit BitAnd geschieht sieht dann erst einmal anders aus ist von der Rechnung her aber auch exakt das gleiche

    Beim ersten Beispiel passiert folgendes wenn das Flag (also hier das 4. Bit) gesetzt ist:

    If BitAND(0xFFFF, 8) Then wird aufgelöst zu If 8 Then und durch die implizite Konvertierung in Bool wird daraus (da 8 zu true gecastet wird) If True Then


    Wenn das Flag nicht gesetzt ist passiert folgendes:

    If BitAND(0x0, 8) Then --> If 0 Then --> If False Then

    Im Zweiten Beispiel wird es folgendermaßen schrittweise ausgewertet:

    Case BitAND(0xFFFF, 2 ^ 3) --> Case BitAND(0xFFFF, 8) --> Case 8 --> Case True

    Und für den Fall, dass das 4. Bit nicht gesetzt ist:

    Case BitAND(0x0, 2 ^ 3) --> Case BitAND(0x0, 8) --> Case 0 --> Case False

  • StringRegExp

    • AspirinJunkie
    • 21. Januar 2021 um 16:01

    Möchtest du nur die Zahlen als Rückgabe?

    Dann z.B. so: &atype=(\d+)

    Deine .+ Konstrukte sind gierig und sorgen dafür, dass diese alles bis zum Ende matchen.
    Daher wird zwischendurch nichts anderes mehr erfasst.

    Zum Erstellen bieten sich spezielle RegEx-Tools an: https://regex101.com/r/zKFK1L/1

  • Script zu langsam

    • AspirinJunkie
    • 1. Januar 2021 um 22:36

    Ohne konkrete Anwendungsfall kann man eigentlich gar nicht Aussagen dazu treffen welche Methode, welche andere schlägt oder nicht. Die benötigten Kriterien sind schlicht noch nicht klar.

    Zur besseren Einordnung was der eigentliche Vorteil von FileReadLine ist, zitiere mich mal von oben selbst:

    Zitat von AspirinJunkie

    Unabhängig davon ob du alle Zeilen in einem Array benötigst oder die Zeilen gleich in der Schleife behandeln kannst

    Zitat von Andy

    Die im 2. Post vorgeschlagene Methode per Stringsplit (oder auch ggf. noch schneller Regex) schlägt die FileReadLine()-Funktion trotzdem noch um Längen. :rtfm:

    Erstens hinkt der Speedvergleich etwas - denn StringSplit haut die Zeilen nur in ein Array - die einzelnen Elemente werden jedoch kein einziges mal angefasst.
    Ein jedoch unwahrscheinliches Szenario ist es hierbei aber dass die Werte nur in ein Array landen sollen ohne jemals weiterverarbeitet zu werden.

    Die wirklich wichtige - jedoch fehlende - Information ist aber: Müssen die einzelnen Zeilen unbedingt in ein Array oder würde es nicht eventuell auch reichen sie einmal durchzuiterieren und einzeln zu behandeln?

    Wissen wir jedoch nicht.

    Wäre dies aber hypothetisch der Fall, dann ist die Array-Variante bei mir ca. 17s (wenn man die Einzelelementbehandlung fairerweise auch mit in die Messung einbezieht) gegen 26s klar schneller. Also ca. ein Faktor von 1:1,5. Aber dies ist ja nur ein Kriterium von vielen möglichen.

    Ein anderes wäre z.B. der RAM-Verbrauch. Da ergibt die FileReadLine-Loop bei mir 6,2mb. Die StringSplit-Variante dagegen stolze 2,3GB. Das wäre dann ein Faktor von 380:1...

    Das Grundproblem ist weiterhin das folgende und vorher macht eine Diskussion über die "bessere" Methode nur bedingt Sinn:

    Zitat von Andy

    Zeig mal die Anwendung, für die man diese Konstruktion überhaupt benötigt.

    Btw: Warum eigentlich Fileread + StringSplit? Was spricht denn gegen ein simples FileReadToArray? (Edit: das ist ja noch langsamer - da läuft doch irgendwas schief :/)

  • Script zu langsam

    • AspirinJunkie
    • 31. Dezember 2020 um 13:00

    Unabhängig davon ob du alle Zeilen in einem Array benötigst oder die Zeilen gleich in der Schleife behandeln kannst ist der Grund für das langsame Skript dass du bei filereadline den Zeilenparameter verwendest. Dabei wird bei jedem einzelnen Aufruf die Datei von Anfang an durchlaufen und die Anzahl der Zeilen gezählt bis die gewünschte Zeile erreicht ist. Jedes Mal...

    Daher Hilfe zu filereadline lesen. Dort steht wie man es richtig macht: Datei mit fileopen öffnen und dann filereadline OHNE Zeilenparameter aufrufen. Dann wird nämlich immer die jeweils nächste Zeile ausgelesen anstatt von Anfang an durchlaufen.

  • Hash-Table in purem AutoIt

    • AspirinJunkie
    • 21. Dezember 2020 um 16:53

    Eine Datenstruktur, welche ich nahezu täglich verwende (z.B. über das Scripting.Dictionary-Objekt) ist die Hash-Tabelle.

    Wie diese funktioniert war mir zwar in den absoluten Grundzügen klar, aber im Grunde war es dann eben doch eher eine Art Blackbox für mich.

    Das wollte ich nun ändern und ein tieferes Verständnis für die Funktionsweise einer Hash-Tabelle erlangen.
    Was gibt es da für einen besseren Ansatz als einfach mal selbst eine komplette Hash-Tabelle in AutoIt zu implementieren?

    Herausgekommen ist dabei folgende UDF.
    Diese ist ausdrücklich lediglich als Übungsprojekt zum Verständnis gedacht und kann nicht mit z.B. Scripting.Dictionary mithalten (habe ich auch gar nicht erst getestet). (wie sich herausgestellt hat, kann diese bei einer großen Elementanzahl eben DOCH mithalten).

    Einige Dinge bergen auch noch deutliches Optimierungspotential (z.B. eine vernünftige Hash-Funktion) und sind erst einmal nur für das grundsätzliche Funktionieren implementiert.

    Wer sich jedoch wie ich ein bisschen mehr mit Hash-Tabellen auseinander setzen möchte, dem kann eventuell diese UDF beim Verständnis ein wenig weiterhelfen.

    Kurzes Beispiel damit jeder sieht, dass sie tatsächlich funktioniert:

    AutoIt
    #include "hashtable.au3"
    
    Global $aTable = _hashtable_Create()
    
    _hashtable_Add($aTable, "Banane", "Der Wert zu Key Banane")
    _hashtable_Add($aTable, "Apfel", "Der Wert zu Key Apfel")
    _hashtable_Add($aTable, "Aprikose", "Der Wert zu Key Aprikose")
    _hashtable_Add($aTable, "Apfelsine", "Der Wert zu Key Apfelsine")
    
    ; remove element:
    _hashtable_Remove($aTable, "Apfel")
    
    ; get value by key:
    $value = _hashtable_Get($aTable, "Aprikose")
    MsgBox(0, "Der Wert zu Aprikose", $value)
    
    ; get the Keys as an array
    $aKeys = _hashtable_getKeys($aTable)
    _ArrayDisplay($aKeys, "The keys of the hash-table", "", 64)
    
    ; get the values as an array
    $aValues = _hashtable_getValues($aTable)
    Alles anzeigen

    Dateien

    hashtable.au3 6,99 kB – 693 Downloads
  • Performance-Analyse der neuen Datenstruktur "Map"

    • AspirinJunkie
    • 16. Dezember 2020 um 12:46

    Ich habe mir das ganze nochmal mit der aktuellen Beta angesehen (3.3.15.3).

    Dieses mal getrennt im Hinblick auf assoziative Arrays und sequentielle Arrays.

    Kurz zusammengefasst: Es gibt nicht DIE Datenstruktur die alle anderen outperformed, sondern es hängt viel mehr davon ab wieviele Elemente die Datenstruktur schlussendlich enthält.

    Zeitaufwand für das (einzelne hinzufügen) Erstellen eines assoziativen Arrays mit N Elementen:

    build_associative.png

    Zeitaufwand für das (einzelne hinzufügen) Erstellen eines sequentiellen Arrays mit N Elementen:

    build_sequential.png

    Zeitaufwand für das (jedes einzeln) Auslesen aller Elemente eines assoziativen Arrays mit N Elementen:

    read_associative.png

    Zeitaufwand für das (jedes einzeln) Auslesen aller Elemente eines sequentiellen Arrays mit N Elementen:

    read_sequential.png

    Testskripte und Diagramme als PDF liegen im Anhang.

    Edit: Assoziatives Array als 2D-Array mit binärer Suche hinzugefügt - interessantes Ergebnis da dies bei großen Datenmengen auch Map und Dictionary überholt.

    Dateien

    DataStructureComparison.zip 64,31 kB – 594 Downloads
  • Kratzer an Hintertür, was tun?

    • AspirinJunkie
    • 15. Dezember 2020 um 16:06

    Ähm Leute schaut euch mal seinen ersten Beitrag hier im Forum (widerspricht sich schonmal mit seiner Aussage, dass er sich extra wegen dem Auto-Thema angemeldet hat) an und nach dem Text hier kann man ziemlich sicher von ausgehen, dass es sich hier um einen Bot handelt.

  • Anfuehrungszeichen in einem String entfernen

    • AspirinJunkie
    • 4. Dezember 2020 um 11:00
    AutoIt
    StringReplace($String, '"', '')

    ?

  • JSON-UDF

    • AspirinJunkie
    • 30. November 2020 um 21:45

    Das ging flott. Aktueller Status lautet "Fix sent to Jon." 8)

    Nächstes mal nehme ich direkt den Bug-Tracker anstatt erst sinnlose Diskussionen im Forum dort führen zu müssen.

  • JSON-UDF

    • AspirinJunkie
    • 30. November 2020 um 09:51

    >>Ticket<< wurde erstellt.

    Hab auch einen Thread im Forum erstellt aber der ist wieder einmal intellektuell nicht sonderlich ergiebig.

  • JSON-UDF

    • AspirinJunkie
    • 29. November 2020 um 11:55

    Das Skript hängt tatsächlich nicht sondern ist wirklich so langsam.

    Der Grund ist folgender: In der UDF wird der String schrittweise mit StringRegEx auseinander genommen.

    Das heißt also zig einzelne Aufrufe an StringRegExp() wo jedesmal der riesen String an die Funktion übergeben wird.

    Hierbei wird jedoch nicht einfach nur der Pointer auf den String übergeben sondern anscheinend(!) eine lokale Kopie des Strings erzeugt und übergeben.

    Mal ein einfaches Skript zur Demonstration:

    AutoIt
    ; Pattern vorkompilieren (für fairen Zeitvergleich)
    StringRegExp("", "^.")
    
    ; Zeitbedarf für ein simples RegEx auf einen kleinens String ermitteln:
    $iT = TimerInit()
    StringRegExp("Test", "^.")
    ConsoleWrite(StringFormat("Zeitbedarf für StringRegEx: % 8.3f ms\n", TimerDiff($iT)))
    
    ; erzeuge großen String (sollte ca. 400mB ergeben da UTF-16 intern verwendet wird)
    Global $sString = ""
    For $i = 1 To 20 * 1024 * 1024
        $sString &= "xxxxxxxxxx"
    Next
    
    ; Zeitbedarf für ein simples RegEx auf diesen String ermitteln:
    $iT = TimerInit()
    StringRegExp($sString, "^.")
    ConsoleWrite(StringFormat("Zeitbedarf für StringRegEx: % 6.1f   ms\n", TimerDiff($iT)))
    Alles anzeigen

    Hier sieht man, dass die Ausführungsgeschwindigkeit direkt von der Größe des Strings abhängt obwohl das Pattern selbst nur das erste Zeichen auswertet.

    Wenn nun also jedes RegEx - egal wie simpel es ist - eine halbe Sekunde braucht, dann ist klar dass dies bei 100.000en Aufrufen die für eine solche Datei nötig wären, unheimlich hohe Bearbeitungszeiten herauskommen.

    So - wie nun also damit umgehen? Das Grundproblem liegt außerhalb meines Einflussbereiches.

    Ich werde das eventuell mal aufbereiten und im englischen Forum vortragen - in der Hoffnung, dass intern auf by Reference umgestellt wird.

    Bei StringLeft() oder StringMid() hat man dieses Phänomen übrigens nicht.

    Oder eine ganz andere Lösung die ich noch nicht sehe.

    Für so große JSON-Strings sollte man daher auf AutoIt-externe Lösungen zurückgreifen.

    Für diesen Fall gibt es z.B. die >>JSMN-basiert UDF<<. Diese verwendet JSMN als Parser. Das Parsing wird also nicht von AutoIt erledigt.

    Des Weiteren wird auch nicht der ganze String in native Datentypen gecastet sondern es wird lediglich eine Liste erzeugt wo an welcher Stelle welche Datentypen stehen.

    So ist die Struktur erstmal ganz fix geparsed und die Objekte selbst werden erst gecasted wenn wirklich auf sie zugegriffen wird.

    Kurz und knapp: Das ist deutlich fixer als eine AutoIt-basierte Lösung wie bei mir und sollte insbesondere bei derart großen Files die passende Alternative darstellen.

    Außer natürlich es findet sich noch ne Lösung für die Übergabe der großen Strings an StringRegExp() ;)

  • Stringmanipulation in einer Funktion

    • AspirinJunkie
    • 27. November 2020 um 08:56

    Da es sich um eine json-Datei handelt ist es naheliegend wenn man einen entsprechenden JSON-Parser verwendet.

    Dann ist die Abfrage simpel und vor allem stabil denn die Definition "zwischen 3. und 4. Anführungszeichen" passt vielleicht auf den aktuellen Zustand aber wenn zusätzliche Infos mal reinkommen oder die Reihenfolge der Values wechselt dann crasht das ganze.

    Mit der UDF von hier siehts so aus:

    AutoIt
    #include <JSON.au3>
    
    $sString = '{"version":"0.170.14.7","oldVersion":"0.170.13.804"}'
    
    ; JSON parsen
    $oObject = _JSON_Parse($sString)
    
    ; Version abfragen und in Variable schreiben:
    $sVersion = _JSON_Get($oObject, "version")
    
    ; Version ausgeben:
    MsgBox(0,"", $sVersion)
    Alles anzeigen

    Edit:

    Zitat von Thorkfumble

    Ich habe eine Funktion geschrieben welche mittels FileRead eine Variable mit Text abgefüllt

    Wenn damit gemeint ist, dass der genannte Abschnitt vorher aus einer größeren JSON-Datei rausgeholt wird, dann kannst du dir den Schritt bei Verwendung eines JSON-Parsers direkt sparen, da du direkt den gewünschten Wert aus dem Gesamtkonstrukt holen kannst ohne erst vorher einen bestimmten Teilbereich herauszuschälen. Bei Bedarf poste einfach mal die ganze Datei.

  • 'Run' führt Exe NICHT aus die Adminrechte benötigt, 'ShellExecute' tut's

    • AspirinJunkie
    • 19. November 2020 um 22:49
    Zitat von Professor Bernd

    Solange ich nicht in den Quellcode von Run sehen kann, ist das Thema somit "gelöst".

    ShellExecute ruft die Windows-API-Funktion >>ShellExecute<< (oder auch ShellExecuteEx) auf.

    Run() ruft die Windows-API-Funktion >>CreateProcess<< auf.

    Dort findet sich folgender wichtiger Hinweis:

    Zitat von CreateProcess-Dokumentation

    The new process runs in the security context of the calling process.

    Heißt: Es ist schlicht gar nicht vorgesehen, dass das aufrufende Programm in einem anderen Security-Kontext laufen kann. Daher schlägt der Aufruf auch fehl da im derzeitigen Kontext nicht genügend Rechte für die Anforderung bereit stehen.

    Edit: Achso - du wolltest ja den Quellcode zur Run()-Funktion:

    Code
    AUT_RESULT AutoIt_Script::Run(int nFunction, VectorVariant &vParams, uint iNumParams, Variant &vResult)
    {
        STARTUPINFO                si;
        STARTUPINFOW            wsi;
    
        PROCESS_INFORMATION        pi;
        char                    szRun[AUT_MAX_LINESIZE+1];
        wchar_t                    *wszRun;
        char                    szDir[AUT_MAX_LINESIZE+1];
        wchar_t                    *wszDir;
        BOOL                    bRes;
    
        HINSTANCE                    hinstLib = NULL;
        MyCreateProcessWithLogonW    lpfnDLLProc = NULL;
    
    
        // init structure for running programs
        si.cb            = sizeof(STARTUPINFO);
        si.lpReserved    = NULL;
        si.lpDesktop    = NULL;
        si.lpTitle        = NULL;
        si.dwFlags        = STARTF_USESHOWWINDOW;
        si.cbReserved2    = 0;
        si.lpReserved2    = NULL;
        si.wShowWindow    = SW_SHOWNORMAL;
    
    
        // Must contain at least one parameter
        strcpy(szRun, vParams[0].szValue());
    
        if (iNumParams >= 2)                        // Has working dir
            strcpy(szDir, vParams[1].szValue());        // Get working directory, if blank get the current working dir
        else
            szDir[0] = '\0';
    
        if (szDir[0] == '\0')
            GetCurrentDirectory(_MAX_PATH, szDir);
    
        if (iNumParams == 3)                        // Has show flag
            si.wShowWindow = (WORD)vParams[2].nValue();    // Default is SW_SHOWNORMAL
    
    
        // If required, init RunAs (dynamically link to retain compatibility with 95)
        if (m_bRunAsSet)
        {
            // Get a handle to the DLL module that contains CreateProcessWithLogonW
            hinstLib = LoadLibrary("advapi32.dll");
            if (hinstLib != NULL)
            {
                lpfnDLLProc = (MyCreateProcessWithLogonW)GetProcAddress(hinstLib, "CreateProcessWithLogonW");
                if (lpfnDLLProc != NULL)
                {
                    // Set up wide char version that we need for CreateProcessWithLogon
                    // init structure for running programs (wide char version)
                    wsi.cb            = sizeof(STARTUPINFOW);
                    wsi.lpReserved    = NULL;
                    wsi.lpDesktop    = NULL;
                    wsi.lpTitle        = NULL;
                    wsi.dwFlags        = STARTF_USESHOWWINDOW;
                    wsi.cbReserved2    = 0;
                    wsi.lpReserved2    = NULL;
                    wsi.wShowWindow = si.wShowWindow;                // Default is same as si
    
                    wszRun = Util_ANSItoUNICODE(szRun);                // Get wide char version of the run string
                    wszDir = Util_ANSItoUNICODE(szDir);                // Get wide char version of the dir string
                }
                else
                {
                    FreeLibrary(hinstLib);
                    FatalError(IDS_AUT_E_RUNASFAILED);
                    return AUT_ERR;
                }
            }
            else
            {
                FatalError(IDS_AUT_E_RUNASFAILED);
                return AUT_ERR;
            }
        }
    
    
        // RunAs or Normal?
        if (lpfnDLLProc == NULL)
            bRes = CreateProcess(NULL, szRun, NULL, NULL, FALSE, 0, NULL, szDir, &si, &pi);
        else
        {
            bRes = lpfnDLLProc( m_wszRunUser, m_wszRunDom, m_wszRunPwd, m_dwRunAsLogonFlags, 0, wszRun, 0, 0, wszDir, &wsi, &pi );
            delete [] wszRun;                        // Free our wide strings
            delete [] wszDir;
        }
    
    
        // Check for success
        if (bRes == FALSE)
        {
            if (hinstLib)
                FreeLibrary(hinstLib);
    
            if (m_bRunErrorsFatal == true)
            {
                FatalError(IDS_AUT_E_RUNPROG, FormatWinError());
                return AUT_ERR;
            }
            else
            {
                SetFuncErrorCode(1);                // Indicate an error (silently)
                vResult = 0;                        // Also set result to 0 (default 1)
                return AUT_OK;                        // Nothing to tidy, so return now
            }
        }
    
    
        // Tidy up
        if (hinstLib)
            FreeLibrary(hinstLib);
    
        CloseHandle(pi.hThread);
    
    
        // If this is a RUNWAIT command, track the process
        if (nFunction == 1)                            // RUNWAIT
            m_piRunProcess = pi.hProcess;
        else                                        // RUN
        {
            vResult = (double)pi.dwProcessId;        // Pass the PID back as the result
            CloseHandle(pi.hProcess);
        }
    
        return AUT_OK;
    
    } // Run()
    Alles anzeigen
  • Neue Functionsnamen in der "Excel.au3" ?

    • AspirinJunkie
    • 5. November 2020 um 07:30

    Die wird mit AutoIt mitgeliefert.

    Die aktuellste UDF ist daher die in der aktuellen Beta von AutoIt.

  • Geheimnis "scripting.dictionary" AutoIt 3.3.14.5

    • AspirinJunkie
    • 5. November 2020 um 06:55
    Zitat von GML

    Mit _filetoarrayrec würde es funktionieren (getestet :thumbup: ) aber da verliere ich ein paar Möglichkeiten und müßte vor allem das ganze Programm ändern.

    Auf welche Möglichkeiten kommt es denn konkret an?

    Vielleicht finden wir ja eine bessere Alternative, anstatt zu versuchen diese umständlich umzubiegen?

  • Dateinamen ab einem bestimmten Zeichen nach rechts entfernen funktioniert nicht immer => Umstieg zu Autoit

    • AspirinJunkie
    • 2. November 2020 um 17:28
    Zitat von Masel_tov

    Die anderen Lösungen haben bisweilen den Vorteil, daß ich nur eine Klammer entfernen kann, da es doch evtl. vorkommt, daß noch eine weitere Klammer im String steht.

    Was wie in welcher Form alles auftauchen kann, lässt sich am besten anhand von ein paar Beispielen beschreiben.

    Dann kann man entsprechende Regeln in Form von regulären Ausdrücken daraufhin definieren (die StringRegEx-Funktionen).

    Das Problem hieran ist, dass man sich erstmal in diese einarbeiten muss, da deren Syntax alles andere als autoplausibel ist.

    Es lohnt sich aber definitiv - eben weil es nicht AutoIt-spezifisch ist sondern überall auftaucht.

    Auch hier bei uns gibt es ein >>entsprechendes Tutorial<<.

    Zum Nachvollziehen ist daher alpines Variante erst einmal die bessere Variante, da man sich diese ohne groß einlesen selbst erschließen kann.

    Gib also mal ein paar Beispiele was wie auftauchen kann und entfernt werden soll.

    Zitat von Masel_tov

    Hallo "Gürteltier",

    Nene - das ist ein Erdferkel...

    Zitat von Masel_tov

    Ich hoffe mal, daß Du nicht wie ich auf Aspirin angewiesen bist.

    Meine letzte Aspirin habe ich wohl vor ca. 2 Jahren mal genommen.

    Der Name kommt aus meiner präpubertären Phase (war ca. 12 Jahre) im Jahre 1999 - der Hochzeit von AOL - als auch Normalsterbliche das Internet für sich entdeckten und es unglaublich witzig fanden ganz "verrückte" Nicknames in diesem neuen Ding namens "Chat" zu verwenden.

    Über die Zeit kam dann immer mehr Bartwuchs dazu - der Nick blieb jedoch.

    Im Grunde mag ich ihn also selbst nicht - kann und will ihn jedoch nicht mehr ändern, da eine gewisse Identität hieran geknüpft ist.

  • Dateinamen ab einem bestimmten Zeichen nach rechts entfernen funktioniert nicht immer => Umstieg zu Autoit

    • AspirinJunkie
    • 2. November 2020 um 12:14

    Eventuell wäre ein Ordnerauswahldialog auch eine komfortable Lösung?:

    AutoIt
    ; Ordnerpfad über Dialog bestimmen:
    Global $sPath = FileSelectFolder("Pfad wählen", @ScriptDir, 2)
    
    ; Dateiauflistung initialisieren:
    $hSearchHandle = FileFindFirstFile($sPath & "\*(*)*")  ; findet nur Dateien die mind. eine öffnende und schließende Klammer im Namen haben
    
    ; Dateien abarbeiten:
    Do
        $sFileName = FileFindNextFile($hSearchHandle)
        If @error Then ExitLoop         ; Schleife beenden falls keine weiteren Dateien mehr existieren
        If @extended Then ContinueLoop    ; Ordner sollen ignoriert werden
    
        ; Klammerausdrücke aus Dateinamen entfernen:
        $sNewName = StringRegExpReplace($sFileName, '\h*\(.+\)\h*', "")
    
        ; umbenennen falls es was zum umbenennen gibt:
        If $sNewName <> $sFileName Then FileMove($sPath & "\" & $sFileName, $sPath & "\" & $sNewName)
    Until 0
    
    ; Handle schließen (hier fast egal - aber gehört sich so):
    FileClose($hSearchHandle)
    Alles anzeigen
  • JSON-UDF

    • AspirinJunkie
    • 21. Oktober 2020 um 10:48

    Na das war ja mal ekelhaft zu debuggen...

    Problem war den Fehler überhaupt erst einmal zu detektieren.

    Ursache war ein Stack-Overflow bei der PCRE-Engine aufgrund einem zu exzessiven Backtracking bei langen Strings.

    Die Behebung war dann ein Klacks: Einfach ein + hinzufügen (um einen Quantifier possesiv zu machen).

    Jetzt sollte es aber auch mit deiner Aerosmith_Lesbar.json klappen.

    Selbst die Aerosmith.json parst er nun, obwohl die mir jeder JSON-Validator mir die um die Ohren haut.

    Als Nebeneffekt sollte auch die Performance wieder ein Stück gestiegen sein.

  • JSON-UDF

    • AspirinJunkie
    • 18. Oktober 2020 um 11:00

    Ich bin dran wird aber wohl noch ne Weile dauern, da das Debugging in dem Fall echt eklig ist.

    Hab ein paar Vermutungen und auch schon einen ersten Bug gefunden.
    Dürfte die nächsten Tage aber hinreichend Zeit dafür fnden (Quarantäne - Yeah!).

  • Java-Seite Quelltext

    • AspirinJunkie
    • 11. Oktober 2020 um 21:14

    Mach mal ein Sleep(3000) hinter das_IECreate. Dann sollte es funktionieren (noch abhängig von deiner Verbindungsgeschwindigkeit).

    Ein _IELoadWait bringt in dem Fall nichts, da die Seite ja m Grunde vollständig geladen wurde. Die anderen Inhalte werden ja dynamisch per Ajax nachgeladen.

    Ganz ehrlch: Such dir ne andere Quelle für die Ermittlung der aktuellen JAVA-Version - mit der Seite wirst du nicht viel Freude haben.

    Edit:Hier in bisschen anderer Form formatiert findest du die jeweils aktuellen Versionen hier:

    http://javadl-esd-secure.oracle.com/update/baseline.version

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™