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

  • Variablen in RAM speichern - Daten zentralisieren - für mehrere Scripts zugänglich machen

    • AspirinJunkie
    • 24. November 2021 um 22:20

    Ich hatte mir vor zig Jahren mal ein Template fürs Multi-Processing mit einem Shared-Memory geschrieben.
    Da wäre ein Weg beschrieben wie man auf einen gemeinsamen Speicher zugreifen kann:

    AutoIt
    #pragma compile(x64, true)
    
    #include <Misc.au3>
    #include <WinAPI.au3>
    #include <WinAPIFiles.au3>
    #include <WinAPIProc.au3>
    
    
    #Region Globale Einstellungen (Konstanten und son zeugs)
    Global Const $tag_MySharedStruct = "LONG NProcMax; LONG NProcesses;LONG Success" ; Aufbau des shared-Memory
    Global Const $h_dll_Kernel32 = DllOpen("kernel32.dll")
    
    Global $d_ProcessID = 0
    
    ; Mutex für den gesamten Shared-Memory
    $h_Mutex_SharedStruct = _WinAPI_CreateMutex("s_Mutex_SharedStruct", False)
    ; Alternative = Semaphore (damit kann auf mehr als einen beschränkt werden)
    ; Sinnvoll zum Beispiel um Sicherzustellen, dass immer nur genauso viele Prozesse laufen wie es Kerne gibt obwohl in der Summe weit mehr Prozesse gestartet werden (https://www.autoitscript.com/forum/topic/177568-using-semaphores/?do=findComment&comment=1277033)
    #EndRegion Globale Einstellungen (Konstanten und son zeugs)
    
    
    #Region shared memory erstellen oder öffnen
    Global Const $s_FileMappingName = "AutoIt Shared Memory Test"
    Global $h_Mapping = _WinAPI_OpenFileMapping($s_FileMappingName, $FILE_MAP_READ + $FILE_MAP_WRITE)
    If Not $h_Mapping Then ; Master
        HotKeySet("^!q", _EndeMaster)
        OnAutoItExitRegister(_EndeMaster)
    
        If Not _Singleton($s_FileMappingName & "_Singleton") Then _EndeMaster() ; zusätzliche Sicherheit damit nicht mehrere Master geöffnet werden
    
    
        Global $h_Mapping = _WinAPI_CreateFileMapping(-1, DllStructGetSize(DllStructCreate($tag_MySharedStruct)), $s_FileMappingName, 0x4)
        If Not $h_Mapping Or @extended Then Exit MsgBox(0, "", "Konnte Shared-Memory nicht erstellen")
        Global $p_shared = _WinAPI_MapViewOfFile($h_Mapping) ; Pointer zum Shared-Memory
        Global $strct_Shared = DllStructCreate($tag_MySharedStruct, $p_shared)
        $strct_Shared.NProcesses = 0
    
        ; Anzahl an Prozessen (=Anzahl an HT-Cores um 100%-Auslastung zu erreichen)
        Global $d_NProcesses = ObjGet("winmgmts:").ExecQuery("SELECT * FROM Win32_Processor", "WQL", 16).ItemIndex(0).NumberOfLogicalProcessors
        $strct_Shared.NProcMax = $d_NProcesses
    Else ; Slave
        HotKeySet("^!q", _EndeSlave)
        OnAutoItExitRegister(_EndeSlave)
    
        Global $p_shared = _WinAPI_MapViewOfFile($h_Mapping) ; Pointer zum Shared-Memory
        Global $strct_Shared = DllStructCreate($tag_MySharedStruct, $p_shared)
        Global $d_NProcesses = $strct_Shared.NProcMax
    
        ; Prozesszähler erhöhen
        Global $d_ProcessID = _atomic_Increment($strct_Shared, "NProcesses")
        If $d_ProcessID > $d_NProcesses Then _EndeSlave()
    EndIf
    #EndRegion shared memory erstellen oder öffnen
    
    
    #Region Master-Prozess
    If $d_ProcessID = 0 Then ; Master-Process (verwaltet lediglich die Slaves)
        Global $a_ProcessIDs[$d_NProcesses]
    
        ; Slave-Prozesse starten
        For $i = 1 To $d_NProcesses
            $a_ProcessIDs[$i - 1] = Run(@Compiled ? @ScriptFullPath : '"' & @AutoItExe & '" "' & @ScriptFullPath & '"')
            ProcessWait($a_ProcessIDs[$i - 1])
        Next
    
        Do
            Sleep(10)
    
    ;~         ; Falls ein Slave Success gemeldet hat:
            If $strct_Shared.Success > 0 Then
                ;irgendwie noch darauf reagieren
    
                ;dann
                _EndeMaster()
            EndIf
    
            ; Ende falls alle Slave-Prozesse beendet sind (ohne eine Erfolgsmeldung)
        Until $strct_Shared.NProcesses <= 0
        #EndRegion Master-Prozess
    
    Else ; Slave-Process
        #Region Slave-Prozess
        If $strct_Shared.Success > 0 Then _EndeSlave() ; zusätzliche Abfrage auf Success eines anderen Prozesses auf Slave-Seite
    
        Sleep(Random(1, 5000))
    
        ; hier das Zeug was der Slave-Prozess machen soll eintragen
        FileWrite($d_ProcessID & ".txt", "Test")
    
        ;erfolgreich-Meldung senden (so dass Masterprozess alles abwickeln kann)
    ;~     _atomic_Increment($strct_Shared, "Success")
    EndIf
    #EndRegion Slave-Prozess
    
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _EndeMaster()
    ; Description ...: Funktion welche beim Beenden des Master-Prozesses aufgerufen wird
    ; Syntax ........: _EndeMaster()
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func _EndeMaster()
        For $d_PID In $a_ProcessIDs
            ProcessClose($d_PID)
        Next
        _WinAPI_UnmapViewOfFile($p_shared)
        _WinAPI_CloseHandle($h_Mutex_SharedStruct)
    
        _WinAPI_CloseHandle($h_Mapping)
        Exit
    EndFunc   ;==>_EndeMaster
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _EndeSlave()
    ; Description ...: Funktion welche beim Beenden des Slave-Prozesses aufgerufen wird
    ; Syntax ........: _EndeSlave()
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func _EndeSlave()
        _WinAPI_CloseHandle($h_Mutex_SharedStruct)
    
        ; Da der Prozess beendet wird, den Threadzähler wieder um eins verringern:
        _atomic_Decrement($strct_Shared, "NProcesses")
        Exit
    EndFunc   ;==>_EndeSlave
    
    
    
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _atomic_Increment()
    ; Description ...: erhöht den Wert an einer LONG-Speicherstelle um 1 atomar (threadsicher)
    ; Syntax ........: _atomic_Increment(ByRef $strct, Const $num)
    ; Parameters ....: ByRef $strct - DllStructCreate-Struktur welche die Speicherstelle beinhaltet
    ;                  Const $num   - Struktur-Element (Name oder Nummer) welches inkrementiert werden soll
    ; Return values .: Success: Den Wert der Speicherstelle nach der Erhöhung
    ;                  Failure
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func _atomic_Increment(ByRef $strct, Const $num)
        Local $d_Ret
        If @AutoItX64 Then ; x64-Befehle sollten atomic sein - nicht so jedoch in AutoIt
            _WinAPI_WaitForSingleObject($h_Mutex_SharedStruct)
            $d_Ret = DllStructGetData($strct, $num) + 1
            DllStructSetData($strct, $num, $d_Ret)
            _WinAPI_ReleaseMutex($h_Mutex_SharedStruct)
        Else
            $d_Ret = DllCall("Kernel32.dll", "Long", "Interlockedcrement", "ptr", DllStructGetPtr($strct, $num))[0]
        EndIf
        Return $d_Ret
    EndFunc   ;==>_atomic_Increment
    
    
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _atomic_Decrement()
    ; Description ...: verringert den Wert an einer LONG-Speicherstelle um 1 atomar (threadsicher)
    ; Syntax ........: _atomic_Decrement(ByRef $strct, Const $num)
    ; Parameters ....: ByRef $strct - DllStructCreate-Struktur welche die Speicherstelle beinhaltet
    ;                  Const $num   - Struktur-Element (Name oder Nummer) welches dekrementiert werden soll
    ; Return values .: Success
    ;                  Failure
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func _atomic_Decrement(ByRef $strct, Const $num)
        Local $d_Ret
        If @AutoItX64 Then
            _WinAPI_WaitForSingleObject($h_Mutex_SharedStruct)
            $d_Ret = DllStructGetData($strct, $num) - 1
            DllStructSetData($strct, $num, $d_Ret)
            _WinAPI_ReleaseMutex($h_Mutex_SharedStruct)
        Else
            $d_Ret = DllCall("Kernel32.dll", "Long", "InterlockedDecrement", "ptr", DllStructGetPtr($strct, $num))[0]
        EndIf
        Return $d_Ret
    EndFunc   ;==>_atomic_Decrement
    Alles anzeigen
  • Bilder aus Word extrahieren

    • AspirinJunkie
    • 8. November 2021 um 09:16

    Ne sollte es eigentlich nicht, da doc-Dateien keine umgelabelten zip-Dateien sind.

  • Bilder aus Word extrahieren

    • AspirinJunkie
    • 7. November 2021 um 21:15

    Wenn es docx-Dateien sind dann benenne die Datei mal in xxx.zip um und schaue sie dir mal genau an.
    Insbesondere den Unterordner "word/media".

  • Alternative zu "Sleep"

    • AspirinJunkie
    • 1. November 2021 um 05:57

    Kanashius fragte wie du "vollständig gestartet" definierst.
    Erst wenn dies klar ist kann man überlegen mit welchen Mitteln man dies programmiertechnisch angeht.

  • Problem mit SciTE

    • AspirinJunkie
    • 27. Oktober 2021 um 12:18
    Zitat von BigRox

    Wen dem so ist, dann sollte die Hilfe zu include aber entsprechend angepasst

    In der Hilfe zu AutoIt haben Befindlichkeiten eventuell verwendeter Editor nichts zu suchen.
    Mit welchem Editor man AutoIt-Code schreibt ist ja völlig unabhängig von der Sprache und dem Interpreter der Sprache - und nur um die geht es in der Hilfe.

    Sonst wäre die Hilfe voll mit Hinweisen zu Scite, Notepad++, Sublime Text, VSC, vim, atom .... etc.

  • JSON-UDF

    • AspirinJunkie
    • 24. Oktober 2021 um 20:45

    mko

    Jo danke - ich werde mich wohl zwingen MustDeclareVars mehr zu verwenden.

    Zur Diskussion ob die Deklaration innerhalb oder außerhalb der Schleife besser aufgehoben wäre würde ich gern etwas ausholen, da ein "ist schlechter Stil" in der Regel als Begründung unbefriedigend ist:
    Local/Global/Dim vor dem Variablennamen bedeuten immer eine [Neu]Deklaration einer Variable.
    Das heißt im Speicher wird Platz für eine neue Variable reserviert und dieser Speicher entsprechend vorbereitet.
    Da AutoIt-Variablen intern etwas aufwendiger aufgebaut sind, ist diese Deklaration also in AutoIt besonders aufwendig.

    Das reine Zuweisen eines Wertes ("Definition") hingegen ist simpler, da einfach nur der Wert an die bereits vorhandene Speicherstelle geschrieben wird.

    Sprich: Es ist effizienter eine Variable nur einmal zu deklarieren und danach nur noch ihren Wert entsprechend zu ändern.
    Und um es ganz anschaulich zu machen hier ein kurzes Beispiel um den Effekt zu sehen:

    Code
    $tT = TimerInit()
    Local $x
    For $i = 1 To 1e6
       $x = 1
    Next
    $iT = TimerDiff($tT)
    ConsoleWrite(StringFormat("\n% 15s: % 6.2f ms\n", "außerhalb Loop", $iT))
    
    
    $tT = TimerInit()
    For $i = 1 To 1e6
       Local $x = 1
    Next
    $iT = TimerDiff($tT)
    ConsoleWrite(StringFormat("% 15s: % 6.2f ms\n\n", "in Loop", $iT))
    Alles anzeigen

    Zu der Dim/Global/Local-Diskussion:
    Stimmt schon alles.
    Das Hauptargument gegen Dim ist eben, dass man beim Codeteil nicht weiß ob es nun eine globale oder eine lokale Variable werden soll.
    Es kommt schlicht darauf an in welchem Kontext die Funktion ausgeführt wird.
    Das führt natürlich dazu, dass eine Funktion 100x funktioniert weil die Variable local wird und beim 101. Skript geht auf einmal alles schief weil in dem Skript auf einmal jemand eine globale Variable mit selben Namen definiert hat.
    Dim ist daher tatsächlich zu vermeiden wenn man nicht einen ganz bewussten Anwendungsfall hierfür hat.

    Genau so ein arg konstruiertes Beispiel wo der Einsatz von Dim Sinn macht hätte ich sogar zufällig:
    Wenn man eine ByRef-Variable in seiner Funktion zur Rückgabe von Werten als Array verwenden möchte.

    Hier kann es jedoch sein, dass der User entweder ein Array oder eben doch einen Skalar übergibt.

    Bei einem Skalar kann man daraus jedoch kein Array mehr basteln, deswegen muss der User eine Array-Variable übergeben.
    Mit Dim hingegen kann man dies umgehen:

    Code
    #include <Array.au3>
    
    Global $x
    Test($x)
    
    _ArrayDisplay($x)
    
    Func Test(ByRef $aArray)
        Dim $aArray[2] = ["Ein", "Test"]
    EndFunc
  • HEX Zahlen die per Schleife erzeugt wurden in ein Array (Variable) schreiben

    • AspirinJunkie
    • 14. Oktober 2021 um 15:44

    Die -1 ist im Grunde eigentlich gar nicht wirklich falsch.
    Bei Integerdatentypen wird oftmals das erste (bzw. letzte - je nach Sicht) Bit dafür genommen um das Vorzeichen festzulegen.

    Ein Int32, welches die Bitfolge 0xFFFFFFFF interpretiert ist also tatsächlich ganz korrekt -1

    Die höchste darstellbare Int32-Zahl wäre ergo hingen 0x7FFFFFFF.

    Eine Int64-Zahl hingegen hat ein paar Stellen mehr. Dort ist die höchste darstellbare Zahl die 0x7FFFFFFFFFFFFFFF

    Und hier sieht man auch, dass der Bereich für 0xFFFFFFFF noch im positiven Bereich liegt.
    Daher entspricht die Zahl als Int64 kodiert der 4294967295 und als Int32 der -1.


    Wie macht man nun AutoIt klar, ob man es nun mit einer Int32 oder einer Int64 zu tun haben will?
    Entweder über die expliziten Parameter von z.B. Dec() oder Number() oder man gibt einfach mehr Stellen an, als in eine Int32 passen - nämlich so:

    AutoIt
    Local $iVal = 0x0FFFFFFFF
    ConsoleWrite('Dec("0FFFFFFFF", 0) ............ = ' & Dec("0FFFFFFFF", 0) & @CRLF)
    ConsoleWrite('Dec("0FFFFFFFF") ............... = ' & Dec("0FFFFFFFF") & @CRLF)
    ConsoleWrite("ConsoleWrite $iVal ............. = " & $iVal & @CRLF)
  • HEX Zahlen die per Schleife erzeugt wurden in ein Array (Variable) schreiben

    • AspirinJunkie
    • 14. Oktober 2021 um 11:37

    Das scheint eine Art Bug zu sein.
    Dec kennt noch einen flag-Parameter welcher den Datentyp angibt.
    Wenn man ihn weglässt sollte dieser automatisch auf 0 stehen ($Number_Auto) - und dort würde er schauen wieviele Stellen die Hex-Zahl hat und auf $Number_64BIT ausweichen.

    So steht es zumindest in der Hilfe.

    Stattdessen scheint er aber per Default auf $NUMBER_32BIT zu gehen und dort kommt zurecht der Fehler, da es außerhalb des Wertebereiches eines 32 Bit-Integers liegt.

    Abhilfe sollte also schaffen, explizit das flag auf Auto zu setzen:

    AutoIt
    Dec("FFFFFFFF",0)
  • Mehrere Intervalle: For $i = 1 To 10 Step 1

    • AspirinJunkie
    • 6. Oktober 2021 um 15:23
    AutoIt
    For $i = 1 To 20
        ConsoleWrite($i & @CRLF)
    
        If $i = 10 Then $i = 14
    Next

    Edit: eine Millisekunde zu spät

  • Sammelthread "AutoIt Interne Funktionen : Erwartetes Ergebnis -> Tatsächliches Ergebnis"

    • AspirinJunkie
    • 5. Oktober 2021 um 10:56

    Das Problem hat eigentlich nichts mit AutoIt's Umwandlung in Int64 (oder auch Int32) zu tun, sondern in der merkartigen Behandlung von Datentypen in der Windows-API hier im speziellen Fall.

    Was meine ich damit?

    Die _WinAPI_GetDriveNumber() ruft die Windows-API-Funktion DeviceIoControl auf. Was diese zurückgibt wird primär über den Parameter dwIoControlCode gesteuert.
    Die AutoIT-UDF trägt hier hart die 0x002D1080 ein. Dieser Wert entspricht (etwas schwierig nachzuvollziehen) der API-Konstante IOCTL_STORAGE_GET_DEVICE_NUMBER.

    Damit ergibt sich, dass der Parameter lpOutBuffer vom Typ STORAGE_DEVICE_NUMBER sein muss.

    Diese ist in der WinIoCtl.h folgendermaßen definiert:

    Code
    typedef struct _STORAGE_DEVICE_NUMBER {
        DEVICE_TYPE DeviceType;
        DWORD       DeviceNumber;
        DWORD       PartitionNumber;
    } STORAGE_DEVICE_NUMBER, *PSTORAGE_DEVICE_NUMBER;

    Die PartitionNumber - also dein fraglicher Parameter in deiner Struktur ist dabei als DWORD-Typ definiert.

    Was ist ein DWORD? - in der WinDef.h wird dword folgendermaßen definiert: typedef unsigned long DWORD;

    Bis hierhin stimmt die UDF auch (bis auf den kleinen Aspekt, dass sie ulong statt dword genommen haben - was aber äquivalent ist).

    Die wirklich interessante Frage ist jedoch: Wie kommt Microsoft darauf einem unsigned integer einen Wert von -1 zuzuweisen?
    Dieser Wert liegt außerhalb vom Wertebereich von dword. Ist also defacto falsch.
    Im Wertebereich von 0 bis 2.147.483.647 tut dies im Grunde auch gar nicht weh, da diese Zahlen auf binärer Ebene als dword und int völlig gleich sind (nämlich in beiden Fällen 00000000 - 7FFFFFFF).
    Die Weiterbehandlung ist daher nicht wirklich problematisch.
    Ekelhaft wird es erst wenn man Zahlen außerhalb dieses Bereiches nimmt (also bei denen das 1. Bit gesetzt wird) wie eben die -1.

    Das ist (meiner Meinung nach) für dword schlicht falsch - es tut in C aber schlicht nicht wirklich dolle weh, da folgendes weiterhin funktioniert:

    Code
    (DWORD)4294967295 == -1   // ergibt true

    Man kann also munter weiter gegen -1 testen obwohl der Wertebereich von dword dafür gar nicht ausgelegt ist.

    Zusammengefasst: AutoIt analysiert die Struktur, erkennt ein dword und muss daher davon ausgehen, dass eine Zahl mit dem Binärwert 0xFFFFFFFF als unsigned long interpretiert werden muss und daher dem Gegenwert 4.294.967.295 entspricht. Es hat keine Möglichkeit von den Spielereien in C zu wissen wo auch ein unsigned long gegen negative Zahlen getestet werden kann.

    Ich kann daher kein wirkliches Fehl- oder Spezialverhalten von AutoIt in diesem Beispiel erkennen. AutoIt macht im Grunde alles richtig. (Edit: Bis auf den Umstand, dass in der Hilfe -1 als möglicher Rückgabewert angegeben wird - was defacto nicht möglich ist)
    Das kann man auch schön daran erkennen, dass auch in C 4.294.967.295 herauskommt wenn man sich ordentlich an die Doku hält:

    C
    #include <windows.h>
    #include <winioctl.h>
    #include <stdio.h>
    
    int main(int argc, char *argv[])
    {
        HANDLE hDevice;
        DWORD junk;
        
        hDevice = CreateFile(TEXT("\\\\.\\d:"), 
                        0,                
                        FILE_SHARE_READ | 
                        FILE_SHARE_WRITE,
                        NULL,             
                        OPEN_EXISTING,    
                        0,                
                        NULL);            
        
        STORAGE_DEVICE_NUMBER sdn;
        
        DeviceIoControl(hDevice,  
            IOCTL_STORAGE_GET_DEVICE_NUMBER, 
            NULL, 0, 
            &sdn, sizeof(sdn),     
            &junk,                 
            (LPOVERLAPPED) NULL);      
        
        printf("%u\n", sdn.PartitionNumber);
    }
    Alles anzeigen

    Edit: Hab mal >>ein Ticket<< dazu aufgemacht, so dass die Funktion auch -1 zurückgeben würde.

    Edit2: Gefixt und soll in 3.3.15.5 behoben sein

  • Url im Hintergrund öffnen und wieder schließen

    • AspirinJunkie
    • 24. September 2021 um 11:22

    Bzw. InetRead (was die TCP-Connection selbst händelt):

    AutoIt
    InetRead('http://192.168.0.3/?Rly3=1')
  • Variable Zeile für Zeile abarbeiten und verändern

    • AspirinJunkie
    • 10. September 2021 um 11:47
    Zitat von Moombas

    Zudem würde ich deine Schleife anders aufbauen:

    _FileCountLines nutzen anstatt While und @error

    1. Dann geht er die Datei 2x mal durch anstatt wie jetzt nur einmal. Dazu hat er während des _FileCountLines die gesamte Datei schon im Speicher und schmeißt sie dann wieder raus um sie anschließend zeilenweise wieder durchzuarbeiten. Ressourceneffizient geht anders.
    2. Wozu muss man vor der Schleife die Anzahl der Zeilen zu wissen? Ich hoffe nicht um mit dieser den line-Parameter von FileReadLine zu befüllen - dann wird es nämlich erst richtig lahm.

    Wenn man eine Datei wirklich zeilenweise durchgehen will ohne die gesamte Datei im Speicher vorzuhalten ist der Grundaufbau von Sascha meiner Meinung nach schon die grundsätzlich vernünftigste Methode.

  • Mit Autoit selbst erstelltes Programm veröffentlichen - Vorgehensweise

    • AspirinJunkie
    • 10. September 2021 um 11:35
    Zitat von hipfzwirgel

    1. Wenn ich ein mit AutoIt selbst erstelltes und kompiliertes Programm veröffentlichen will, habe ich da in Bezug auf Lizenz-Rechte, etc. seitens AutoIt etwas zu beachten?

    Hierzu ein Zitat aus den Lizenzbedingungen von AutoIt - sollte selbsterklärend sein:

    Zitat

    Commercial Use. You may use the SOFTWARE PRODUCT for commercial purposes. You may sell for profit and freely distribute scripts and/or compiled scripts that were created with the SOFTWARE PRODUCT.

  • Variable Zeile für Zeile abarbeiten und verändern

    • AspirinJunkie
    • 10. September 2021 um 11:20

    Ja man kann natürlich auch eine Variable zeilenweise durchgehen.

    Es kommen zum Fall hier für mich jedoch einige Fragen zusammen:

    • Warum soll zeilenweise gearbeitet werden und warum reicht hier nicht soetwas aus?
    AutoIt
    $sNewFile = StringReplace(FileRead("test.txt"), ".", "")
    FileDelete("test.txt")
    FileWrite("test.txt", $sNewFile)
    • Welche Verbesserung erhoffst du dir durch die Umstellung auf die Bearbeitung der Variable anstatt der Datei?
    • So wie ich deine FileVariante verstehe, dürfte diese nicht funktionieren, da 1. die Datei im Overwrite-Modus geöffnet wird und damit die Datei noch vor dem Einlesen geleert wird und 2. werden die veränderten Zeilen nur an das Ende drangehangen anstatt, dass die vorherigen überschrieben werden.

    Da mir konkrete Problemstellung und Seitenbedingungen fehlen, weiß ich nicht ob folgendes deine Frage beantwortet:

    AutoIt
    Global $sFile = ""
    For $sLine In FileReadToArray("test.txt") 
        $sFile &= StringReplace($sLine, ".", "") & @CRLF
    Next
    $sFile = StringTrimRight($sFile, 2) ; das letzte CRLF wieder entfernen
    
    ; Der bearbeitete Variableninhalt:
    ConsoleWrite($sFile)
  • xlsxNative - XLSX/XLSM-Dateien ohne Excel einlesen und erzeugen

    • AspirinJunkie
    • 6. September 2021 um 08:32

    Also: Das Problem ist nicht die Anzahl der Spalten (hätte mich auch gewundert).

    Das Problem ist stattdessen die Anzahl der Zeilen.

    Inhaltlich sind nur 344 Zeilen beschrieben.
    Definiert (z.B. durch Zuweisung einer Formatierung oder ähnlichem) sind hingegen satte 1.046.932 Zeilen.

    Und die stehen alle Zeile für Zeile, Zelle für Zelle in der Datei drin.

    Das hat zur Folge, dass die xml für das Worksheet 108 MB groß ist.
    Und hier streikt dann direkt der XML-Parser.

    Daher bringt es gar nichts wenn ich noch eine Beschränkung für die Zeilen mit aufnehme.

    Die Lösung ist aber entsprechend einfach: Alle Zeilen ab der 345. löschen (entsprechende Datei hier im Anhang).
    Und dem Kollegen auf die Finger klopfen der offensichtlich eiskalt bis zum Ende runtergescrollt hat und aus lauter Blödheit einfach mal sinnfrei Zellen formatiert hat.

    Dateien

    20210826 Bsp.Tabelle_shrinked.7z 198,73 kB – 414 Downloads
  • Include Befehle Herkunft herausfinden

    • AspirinJunkie
    • 26. August 2021 um 19:02
    Zitat von Moombas

    Ok includes mit "" sind immer im lokalen Ordner de Programms und eigene (fremde) AU3.

    Nicht ganz. Die Frage ob man <...> oder "..." nimmt hat lediglich Einfluss auf die Suchreihenfolge in welchen Ordnern nach der jeweiligen UDF gesucht wird.

    Bei <...> wird erst im AutoIt-Include-Verzeichnis geschaut, dann optional in einem selbstfestgelegtem, welchen man in der Registry eintragen kann und erst wenn dort nichts gefunden wurde wird im Skriptverzeichnis geschaut.

    Bei "..." ist es genau andersherum: Es wird also erst im Skriptverzeichnis geschaut und erst am Schluss im AutoIt-Include-Verzeichnis.

    Es ist also durchaus möglich die AutoIt-internen UDFs mit Anführungszeichen zu includen.

  • xlsxNative - XLSX/XLSM-Dateien ohne Excel einlesen und erzeugen

    • AspirinJunkie
    • 25. August 2021 um 22:15

    Ja klar könnte ich das mit implementieren.
    Wird aber ne zeitlang dauern.
    Komme wahrscheinlich erst im September wieder dazu.

    Prinzipiell sind mehr Spalten nicht unbedingt ein Problem.
    Es kommt auf das interne Format an. Es gibt die Möglichkeit jede Zeile einzeln mit ihrer Koordinate einzutragen.
    Das ist gut bei dünn besetzten Tabellen - also vielen Lücken zwischen den Zellen.

    Oder die Zellen werden zeilenweise eingetragen egal ob da was drin steht oder nicht.

    Ansonsten schick mir mal die Datei - anhand solcher Beispiele findet man oftmals noch Optimierungsmöglichkeiten.

  • Beschreibung von Punkten und ihren Kanten zu anderen Punkten

    • AspirinJunkie
    • 10. August 2021 um 07:34
    Zitat von Mars

    Weil ich neugierig war ob der "ich nehme einfach unmengen For-Loops und lehne mich zurück" Ansatz klappt habe ich es kurz implementiert... Entweder ist da was falsch, oder es gibt wesentlich weniger gültige Permutationen als ich gedacht habe... Bei so viel Zahlensalat habe ich mich bestimmt irgendwo vertippt

    Ich habe mal einen unabhängigen Ansatz versucht und komme auf das gleiche Ergebnis wie du.
    Sollte also wahrscheinlich so stimmen:

    AutoIt
    Global $aSpielerPositionen = [ _
            Array(0, 9), _ ; Torwart immer bei 0, aber ab und zu will er die Sau rauslassen an Position 9
            Array(1, 2, 3), _
            Array(2, 4, 6), _
            Array(4, 5, 8), _
            Array(1, 5, 10), _
            Array(3, 7, 8), _
            Array(5, 6, 0), _ ; Ersatztorwart. Spielt am liebsten an Pos 5 und 6, aber zur Not auch ins Tor...
            Array(4, 5, 6, 7, 8), _
            Array(8, 9, 10), _
            Array(8, 9, 10), _
            Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)] ; Der letze Spieler ist Jesus, der kann überall spielen.
    
    Global $aAufstellungen = _comb_Permute_restricted($aSpielerPositionen)
    MsgBox(0,"", @extended & " mögliche Aufstellungen gefunden")
    
    ; Formationen auf Konsole ausgeben:
    For $aAufstellung In $aAufstellungen
        For $iNr In $aAufstellung
            ConsoleWrite($iNr & @TAB)
        Next
        ConsoleWrite(@CRLF)
    Next
    
    
    
    
    Func Array($a = 0, $b = 0, $c = 0, $d = 0, $e = 0, $f = 0, $g = 0, $h = 0, $i = 0, $j = 0, $k = 0)
        Local $1 = [$a, $b, $c, $d, $e, $f, $g, $h, $i, $j, $k]
        ReDim $1[@NumParams]
        Return $1
    EndFunc   ;==>Array
    
    ; permute elements but for each element is defined on which positions it is allowed to appear
    ; $aArray = [$aPosElement1[...], $aPosElement2[...], ..., $aPosElementN[...]]
    ; return: Array[$N] with element indices
    Func _comb_Permute_restricted(ByRef $aArray, Const $iC = 0)
        Local Static $iRet, $aRet[0][0], $aSample[0], $N
    
        If $iC = 0 Then ; initialisiere in äußerer Rekursion
            $iRet = 0
            $N = UBound($aArray)
            Redim $aSample[$N]
            Redim $aRet[(__comb_factorial($N) > 16777216 ? 16777216 : __comb_factorial($N))]
    
            For $i = 0 To UBound($aSample) - 1    ; set every element to unset status (-1)
                $aSample[$i] = -1
            Next
        EndIf
    
        For $iPos In $aArray[$iC]
            If $aSample[$iPos] <> -1 Then ContinueLoop
            $aSample[$iPos] = $iC
    
            If $iC = $N -1 Then ; last element reached
                $aRet[$iRet] = $aSample
                $iRet += 1
    
                $aSample[$iPos] = -1
                Return
            EndIf
    
            _comb_Permute_restricted($aArray, $iC + 1)
            $aSample[$iPos] = -1
        Next
    
        If $iC = 0 Then
            Redim $aRet[$iRet]
            Return SetExtended($iRet, $aRet)
        EndIf
    EndFunc
    
    
    
    Func __comb_factorial(Const $x)
        If $x < 0 Or (Not IsInt($x)) Then Return SetError(1, $x, Null)
        Local $f = 1
    
        For $i = 1 To $x
            $f *= $i
        Next
    
        Return $f
    EndFunc   ;==>__comb_factorial
    Alles anzeigen
    Zitat von aSeCa

    Also auf die Kern-Frage, wie ich die Beschreibung der Formation am Besten abspeichere, ist dein Vorschlag eine Matrix für jede Position in dieser Formation in einem 2D-Array anzulegen und dann jeweils bei den Kanten zu sagen, ob sie "verbunden" sind?

    Vllt. habe ich es auch noch nicht ganz durchschaut, aber das kommt mir sehr kompliziert und rechenaufwendig vor.

    Die relevanten Fachbegriffe für die Google-Suche hierzu sind Adjazenzmatrix für die Abbildung als Matrix wie von Mars vorgeschlagen und als Alternative hierzu die Adjazenzliste.
    Welche Struktur man für die Knotenbeziehung in Graphen verwendet hängt hierbei vor allem davon ab ob eine Adjazenzmatrix dünn oder dicht besetzt wäre. In dem Fall hier würde ich wohl eher zu einer Adjazenzliste neigen, da jeder Knoten ja nur max. 2 Kanten haben kann (hab ich das so richtig verstanden? ne jetzt sehe ich in deinem Bild, dass es auch mehr Verknüpfungen sein können). Außerdem hat man in einer Adjazenzliste sofort alle Nachbarknoten vorliegen, während man in einer Adjazenzmatrix die komplette Spalte jeweils durchgehen müsste.

  • Problem mit "ProcessWaitClose"

    • AspirinJunkie
    • 6. August 2021 um 11:27

    Ich kann das Verhalten bei mir mit Prozessen nachstellen, welche mit einem höheren Benutzer gestartet wurden.
    Ich denke daher es hat irgendetwas mit den Rechten zu tun.

    Versuche daher einfach mal folgenden Workaround:

    AutoIt
    While ProcessExists("StarMoney.exe")
        Sleep(250)
    WEnd
  • Script zur Ermittlung des passenden Gutscheins

    • AspirinJunkie
    • 5. August 2021 um 12:17
    Zitat von Inferior

    Du hast sogar mit eingebaut, dass er möglichst die Lösung mit den wenigsten Gutscheinen (Anzahl) verwenden soll.

    Das ist das einzige was nicht funktioniert hat.


    Ich meine den Fehler gefunden zu haben:

    Zeile 61 müsste meiner Meinung nach heißen: If ($nRabatt = $nRabattMax) and ($iRabattMaxN <= UBound($aIndGroup)) Then ContinueLoop

    Super gesehen. Genau dort liegt ein Fehler.

    Du hast definitiv das Skript verstanden :thumbup:

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™