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

  • Community Projekt: Teil 1 - Interesse an einem gemeinsamen größeren (Software)Projekt?

    • AspirinJunkie
    • 31. Januar 2024 um 10:19
    Zitat von MojoeB

    brauchen wir nicht eine Art Zustimmung für Pakete?

    Ich hatte im Kopf, dass man bei den Paketen direkt auf die Setups bei den Herstellerseiten verlinkt und von dort bezieht.
    Könnt ihr natürlich machen wie ihr das wollt.

    Zitat von MojoeB

    was für Pakete hast du den im sinn? Software o.o oder ?

    Allgemein wie bei den Linux-Distros auch - Anwendungssoftware, Bibliotheken etc.
    Ansonsten hatte ich nicht viel im Sinn - ich hab nur gesehen, dass ihr momentan was Vorschläge angeht noch bisschen in der Luft hängt und hab daher das nur spontan eingeworfen.

  • Community Projekt: Teil 1 - Interesse an einem gemeinsamen größeren (Software)Projekt?

    • AspirinJunkie
    • 31. Januar 2024 um 07:16

    Projektvorschlag: Ein Paketmanager für Windows.
    Man hat dort mit Dateisystemoperationen zu tun, mit einem Frontend, Netzwerkkommunikation, Datenbanken usw.
    Und von der Performance gibt es keine Ansprüche, welche AutoIt nicht bedienen können sollte.
    Klingt abwechslungsreich.
    Erstmal vielleicht auf self-hosted-Basis so dass jeder sein eigenes Repository pflegt und wenn die Nummer funktioniert kann man ja ein öffentliches draus machen.

  • DllStruct to Array - DllStructs übersichtlich anzeigen lassen

    • AspirinJunkie
    • 29. Januar 2024 um 21:57
    Zitat von UEZ

    Mag sein, dass mein Post oben "zu trocken" war,

    Der war genau richtig und hat richtig gut gesessen. Mach das jetzt nicht kaputt ;)

  • DllStruct to Array - DllStructs übersichtlich anzeigen lassen

    • AspirinJunkie
    • 29. Januar 2024 um 20:20

    Ne - oder? ||

    Glaub ich ja jetzt nicht - die Funktion ist ja noch cooler und dann auch noch built-in.
    Wann ist die denn da rein gekommen?
    Hoffentlich erst nachdem ich meine geschrieben habe - da wärs nicht ganz so peinlich.

    Notiz an mich: :rtfm:

  • Synthaxfrage zu RUN

    • AspirinJunkie
    • 29. Januar 2024 um 14:57
    Zitat von igillan

    Ich möchte einfach nur ein paar Tasmota Steckdosen schalten

    Dann brauchst du eigentlich keine externen Geschichten wie powershell oder curl.
    Ein InetRead("http://192.168.8.66/cm?cmnd=Power%20On") sollte den gleichen Effekt haben.

    Je nachdem was du genau machen möchtest, wäre evtl. MQTT die effektivere Wahl.
    Tasmota unterstützt das glaube ich auch.
    Aber den genauen Anwendungsfall kennen wir ja nicht.

  • Synthaxfrage zu RUN

    • AspirinJunkie
    • 29. Januar 2024 um 12:36
    Zitat von igillan

    mit "Run" in einem Script ausführen. Durch die Anführungszeichen bekomme ich aber immer Fehlermeldungen.

    Um in AutoIt einen String zu definieren muss man ihn entweder in doppelte Anführungszeichen setzen oder in einfache.
    Beide Varianten existieren unter anderem, damit man im String die jeweils anderen Anführungszeichen verwenden kann.
    Würde man z.B. einen String in doppelte Anführungszeichen anfangen und im String selbst sollen wiederrum selbst doppelte vorkommen, dann hat der Interpreter keine Chance zu unterscheiden ob die Anführungszeichen nun das Ende des Strings definieren sollen oder zum Inhalt der Zeichenkette gehören sollen.

    Nun hast du allerdings einen Fall, bei dem im String selbst sowohl doppelte als auch einfache Anführungszeichen vorkommen.
    Hier gibt es noch eine weitere Methode um diese dann für den Interpreter zu maskieren: doppeln
    Sprich: Wenn man einen String in doppelten Anführungszeichen einschließt und darin auch doppelte Anführungszeichen verwenden möchte, dann schreibt man diese 2x: $sString = "Ein ""Test"" für Anführungszeichen"
    Analog würde man dies mit den einfachen auch machen.

    Sprich: Du musst festlegen ob du deinen String in doppelten oder einfachen Anführungszeichen definieren willst und dann dieses Zeichen im String selbst doppeln.
    Dann wird alles als gemeinsamer String erkannt.

  • DllStruct to Array - DllStructs übersichtlich anzeigen lassen

    • AspirinJunkie
    • 29. Januar 2024 um 08:45

    Eine kleine Funktion, welche schon längere Zeit bei mir liegt und mir beim Umgang mit Dll-Strukturen schon öfters mal geholfen hat.
    Ich denke die Funktion könnte auch für den ein oder andere nützlich sein:

    AutoIt
    #include-once
    #include <Array.au3>
    
    ; die Strukturdefinition
    Local $sStructStr = "Align 16;Short Albi;byte;hwnd;char;align 8;byte;short[2];dword;byte;short;byte;int64;char[9];int64;byte;" & _
    		"byte;ptr;char;double;short;wchar[3];byte;float;byte;uint_ptr;byte;char buffer[128];int;byte[13];word 2bytes;handle isptr;hwnd isalsoptr;" & _
    		"boolean isbyte[2];bool isint;dword_ptr;long_ptr;ulong_ptr;lparam;wparam;lresult;byte;"
    
    ; Struktur anhand der Definition erzeugen
    Local $stStruct = DllStructCreate($sStructStr)
    DllStructSetData($stStruct, 12, "Test")
    
    ; Konvertierung der Struktur in ein Array
    Global $aArray = _DllStruct2Array($sStructStr, $stStruct)
    
    ; Ausgabe des Arrays
    _ArrayDisplay($aArray, "DllStruct", "" , 64, Default, "Index|Name|Typ|Arraygröße|Wert|Größe|Offset|Pointer")
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _DllStruct2Array()
    ; Description ...: converts a DllStruct variable to a 2D array based on its structure string
    ; Syntax ........: _DllStruct2Array($tagStruct, ByRef $tStruct)
    ; Parameters ....: $tagStruct     - A string representing the structure to create (like "Struct" in DllStructCreate)
    ;                  ByRef $tStruct - a  structure variable with the structure described in $tagStruct
    ; Return values .: Success: 2D-Array with the following structure:
    ;                  |[[index N, name N, type N, arraysize N, value N, size N, offset N, isPointer N], [...], ...]
    ;                  Failure: Null and set @error to:
    ;                  |@error = 1: $tStruct is not a dll struct variable
    ; Author ........: aspirinjunkie
    ; Modified ......: 2022-07-13
    ; Remarks .......: for LRESULT/[LW]PARAM/PTR/HWND/HANDLE value is pointer address,
    ;                  for xxx_PTR value is taken from the address where the pointer points,
    ;                  for [W]CHAR value is a string if element is an [W]CHAR-array, otherwise the numerical value
    ; Link ..........: x
    ; Example .......: Yes
    ;                  #include <Array.au3>
    ;                  $tagSTRUCT1 = "struct;int var1;byte var2;uint var3;char var4[128];endstruct"
    ;                  Local $tSTRUCT1 = DllStructCreate($tagSTRUCT1)
    ;                  $aStructInfo = _DllStruct2Array($tagSTRUCT1, $tSTRUCT1)
    ;                  _ArrayDisplay($aStructInfo, "DllStruct", "" , 64, Default, "Index|Name|Typ|Arraygröße|Wert|Größe|Offset|Pointer")
    ; =================================================================================================
    Func _DllStruct2Array($tagStruct, ByRef $tStruct)
    	Local Enum $eIndex, $eName, $eType, $eArraySize, $eValue, $eSize, $eOffset, $eIsPointer
    	Local $aRegEx, $sTmp
    	Local $aElements = StringSplit($tagStruct, ";", 3)
    
    	If Not IsDllStruct($tStruct) Then Return SetError(1, 0, Null)
    
    	Local $aArray[UBound($aElements)][8], $iC = 0, $tTmp, $iBaseAddress = DllStructGetPtr($tStruct)
    
    	For $tagElement In $aElements
    		$aArray[$iC][$eArraySize] = ""
    		$aArray[$iC][$eIsPointer] = ""
    
    		; a data element
    		$aRegEx = StringRegExp($tagElement, "(?i)^\h*(BOOL(?>EAN)?|BYTE|(?>U|W)?CHAR|DOUBLE|D?WORD(?>_PTR)?|FLOAT|HANDLE|HWND|U?INT(?>64|_PTR)?|(?>L|W)PARAM|LRESULT|PTR|U?SHORT|U?LONG(?>_PTR)?)", 3)
    		If @error Then ContinueLoop ; no "align", "struct", "endstruct" etc. handling - only elements
    
    		; element data type
    		$aArray[$iC][$eType] = $aRegEx[0]
    
    		; element index
    		$aArray[$iC][$eIndex] = $iC + 1
    
    		; element offset
    		$aArray[$iC][$eOffset] = Int(DllStructGetPtr($tStruct, $aArray[$iC][$eIndex]) - $iBaseAddress)
    
    		; pointer type?
    		$sTmp = StringStripWS(StringTrimLeft($tagElement, StringLen($aArray[$iC][$eType])), 2)
    		If StringInStr($sTmp, "*", 1) Then $aArray[$iC][$eIsPointer] = True
    
    		;  Array defined?
    		$aRegEx = StringRegExp($sTmp, "\[\h*(\d+)\h*\]", 3)
    		If Not @error Then $aArray[$iC][$eArraySize] = Int($aRegEx[0])
    
    		; element name
    		$aRegEx = StringRegExp($sTmp, "(\w+)\h*(?>$|\[)", 3)
    		If Not @error Then $aArray[$iC][$eName] = $aRegEx[0]
    
    		;  element size
    		$aArray[$iC][$eSize] = -1
    		If StringRegExp($aArray[$iC][$eType], "(?i)^(BOOLEAN?|BYTE|U?CHAR)$") Then $aArray[$iC][$eSize] = 1
    		If StringRegExp($aArray[$iC][$eType], "(?i)^(WCHAR|U?SHORT|WORD)$") Then $aArray[$iC][$eSize] = 2
    		If StringRegExp($aArray[$iC][$eType], "(?i)^(U?INT|U?LONG|BOOL|DWORD|FLOAT)$") Then $aArray[$iC][$eSize] = 4
    		If StringRegExp($aArray[$iC][$eType], "(?i)^(U?INT64|DOUBLE)") Then $aArray[$iC][$eSize] = 8
    		If StringRegExp($aArray[$iC][$eType], "(?i)^(.+\_PTR|LRESULT|[LW]PARAM|PTR|HWND|HANDLE)") Then     ; pointer type
    			$aArray[$iC][$eIsPointer] = True
    			$aArray[$iC][$eSize] = @AutoItX64 ? 8 : 4
    		EndIf
    		If $aArray[$iC][$eArraySize] > 1 Then $aArray[$iC][$eSize] *= $aArray[$iC][$eArraySize]
    
    		; element value
    		If $aArray[$iC][$eIsPointer] Then ; pointer type
    
    			If StringRegExp($aArray[$iC][$eType], "(?i)\_PTR$") Then ; pointer to integer values
    				$tTmp = DllStructCreate(StringTrimRight($aArray[$iC][$eType], 4), DllStructGetPtr($tStruct, $aArray[$iC][$eIndex]))
    				$aArray[$iC][$eValue] = DllStructGetData($tTmp, 1)
    				$tTmp = Null
    			Else ; normal unspecific pointer
    				$aArray[$iC][$eValue] = DllStructGetData($tStruct, $aArray[$iC][$eIndex])
    			EndIf
    
    		ElseIf $aArray[$iC][$eArraySize] > 0 Then ; array elements
    
    			If StringRegExp($aArray[$iC][$eType], "(?i)W?CHAR") Then ; char array (a string)
    				$aArray[$iC][$eValue] = DllStructGetData($tStruct, $aArray[$iC][$eIndex])
    			Else ; normal element array
    				Local $aTmp[$aArray[$iC][$eArraySize]]
    				For $i = 0 To $aArray[$iC][$eArraySize] - 1
    					$aTmp[$i] = DllStructGetData($tStruct, $aArray[$iC][$eIndex], $i + 1)
    				Next
    				$aArray[$iC][$eValue] = $aTmp
    			EndIf
    
    		Else
    			$aArray[$iC][$eValue] = DllStructGetData($tStruct, $aArray[$iC][$eIndex])
    		EndIf
    
    		$iC += 1
    	Next
    	ReDim $aArray[$iC][UBound($aArray, 2)]
    
    	Return SetExtended(DllStructGetSize($tStruct), $aArray)
    EndFunc   ;==>_DllStruct2Array
    Alles anzeigen
  • AU3 Code während der Laufzeit nachladen?

    • AspirinJunkie
    • 26. Januar 2024 um 19:17
    Zitat von uuchip

    ob wenn man ein Skript mit AutoIt3ExecuteScript() aufruft, dessen Funktionen nach dem Aufruf im "Hauptprogramm" zur Verfügung stehen?

    Nein

  • AU3 Code während der Laufzeit nachladen?

    • AspirinJunkie
    • 26. Januar 2024 um 18:34

    Nun nur mit Einschränkungen.
    Du kannst Code aus Strings oder Dateien ausführen lassen aber da gibt es ein paar Einschränkungen.

    Methode 1 - Execute():

    hierbei kann kurzer Code in Strings ausgeführt werden und deren Rückgabewert im Hauptskript weiterverwendet werden.
    Mehrzeilige Konstrukte wie Schleifen oder Funktionsdefinitionen gehen damit nicht.
    Auch Variablenzuweisungen klappen nicht.
    Variablen aus dem Hauptskript können zwar in diesen Ausdrücken verwendet, aber nicht überschrieben werden - nur der Return-Wert von Execute() könnte hierfür dienen.

    Methode 2 -  /AutoIt3ExecuteLine bzw. /AutoIt3ExecuteScript:

    Man kann den AutoIt-Interpreter aufrufen und entweder eine Codezeile oder ein ganzes Skript angeben, welches ausgeführt werden soll.
    Das geht auch mit der kompilierten Exe-Datei des Hauptskriptes, wenn es mit der richtigen Compileroption kompiliert wurde.
    Damit kann man auch umfangreichere Skripte ausführen, aber diese haben keine Verknüpfung zum Hauptskript - teilen sich also keine Variablen usw.
    Es wird einfach nur aufgerufen:

    AutoIt
    #pragma compile(AutoItExecuteAllowed, True)
    
    ; je nachdem ob Skript kompiliert vorliegt oder direkt über den Interpreter aufgerufen wird
    $sAutoItExe = @Compiled ? @ScriptFullPath : @AutoItExe
    
    ; einzelne Zeile Code ausführen:
    $sVar = "msgbox(0,'','Test')" ; AutoIt-Code, welcher irgendwie in eine Variable gelangt ist
    RunWait(StringFormat('"%s" /AutoIt3ExecuteLine "%s"', $sAutoItExe, $sVar))
    
    ; ein anderes AutoIt-Skript aufrufen, welches noch nicht kompiliert vorliegt
    RunWait(StringFormat('"%s" /AutoIt3ExecuteScript "%s"', $sAutoItExe, @ScriptDir & "\other.au3"))
    Alles anzeigen
  • Geschwindigkeit JSON UDF

    • AspirinJunkie
    • 24. Januar 2024 um 18:50

    Ich finde die 50s aber schon ziemlich heftig.
    Die sind meiner Meinung nach auch viel zu lange.
    Ob das am Zugriff über Wine liegt - keine Ahnung.
    Aber eine Antwort auf meine Frage ob du die aktuelle Version von AutoIt verwendest steht noch aus.

  • Anzahl Minuten in Stunden und Minuten umrechnen

    • AspirinJunkie
    • 24. Januar 2024 um 17:18

    Dein Skript scheint ja nur ein Ausschnitt zu sein.
    Wenn ich das richtig verstehe (und da kann ich natürlich meilenweit falsch liegen), dann hast du diesen Code mindestens 6x vorliegen - oder?
    Also das scheint ja nur der Code für $Input6 zu sein.
    Die anderen Zeiten fehlen ja noch in dem Gezeigten.

    Es ist sicherlich nicht gut was ich jetzt mache aber mich hat es irgendwie gerade gejuckt zu versuchen, dass was ich vermute was dein Ziel ist mal etwas dynamischer zu implementieren.
    Wenn ich das richtig verstehe, hast du mehrere Edit-Felder wo die Zeiten eingetragen werden und am Ende kommt eine Summe heraus.
    Quasi eine Art Zeitenaddierer?

    Falls ja, dann würde ich dir gerne zeigen, dass man die Felder für die Zeiten und das ganze drumherum dynamisch schreiben kann, so dass man deutlich weniger Code hierfür benötigt und gleichzeitig flexibler ist.
    Es besteht natürlich die Gefahr, dass ich an deinem Thema vorbei schramme aber dann hab ich mir eben halt damit kurz die Zeit vertrieben:

    AutoIt
    #include <GUIConstantsEx.au3>
    
    #Region GUI erstellen
    ; Eventmode statt Message-Loop-Modus (gefällt mir persönlich besser)
    Opt("GUIOnEventMode", 1)
    
    ; Über die Größe des Arrays, kann man die Anzahl der Einträge und die GUI-Größe steuern
    Global $aIdInputs[6] ; hält die Control-IDs für die Zeitinputs
    
    ; GUI erstellen
    GUICreate("Zeitaddierer", 120, UBound($aIdInputs) * 25 + 70)
    GUISetOnEvent($GUI_EVENT_CLOSE, "raus")
    
    ; die Inputs für die Zeitangaben erstellen
    For $i = 0 To UBound($aIdInputs) - 1
    	$aIdInputs[$i] = GUICtrlCreateInput("", 10, 5 + $i * 25, 100, 20)
    	GUICtrlSetOnEvent(-1, "_gui_eingetragen")
    Next
    
    ; Edit-Control für die Ausgabe der Summe:
    Local $idSumme = GUICtrlCreateInput("", 10, UBound($aIdInputs) * 25 + 35, 100, 20) 
    
    ; GUI sichtbar schalten
    GUISetState(@SW_SHOW)
    
    ; Endlosschleife für das GUI
    Do
    	Sleep(10)
    Until 0
    #EndRegion
    
    
    
    ; Funktion um über das Kreuz zu beenden
    Func raus()
    	Exit
    EndFunc
    
    ; Funktion, welche aufgerufen wird, wenn eine Zeit eingetragen wurde
    Func _gui_eingetragen()
    	Local $sInputRaw = GUICtrlRead(@GUI_CtrlId)
    
    	; wenn eingetragene Form nicht stimmt - aufhören
    	If Not StringRegExp($sInputRaw, '^(\d{3,4}|\d{1,2}:\d{2})$', 0) Then Return
    
    	; Doppelpunkt hinzufügen, falls nicht vorhanden:
    	If Not StringInStr($sInputRaw, ':') Then $sInputRaw = StringTrimRight($sInputRaw, 2) & ":"  & StringRight($sInputRaw, 2)
    
    	; führende 0 hinzufügen:
    	$sInputRaw = StringRight("0" & $sInputRaw, 5)
    	
    	; aufgehübschte Zeit eintragen:
    	GUICtrlSetData(@GUI_CtrlId, $sInputRaw)
    
    	; Summe berechnen und ausgeben:
    	_calcTimeSum($sInputRaw, @GUI_CtrlId)	
    EndFunc
    
    
    ; berechnet die Summe aller Zeiten
    Func _calcTimeSum($sWert, $sCtrlID)
    	Local Static $mZeiten[] ; map, welche die eingetragenen Zeiten hält
    
    	; Zeit in h und m zerlegen
    	Local $aZeit = StringSplit($sWert, ":", 3)
    	If @error Then Return
    	
    	; aus String Integer machen:
    	$aZeit[0] = Int($aZeit[0])
    	$aZeit[1] = Int($aZeit[1])
    	
    	; Bereichscheck:
    	If $aZeit[1] < 0 Or $aZeit[1] > 59 Then Return
    	
    	; den Zeiten hinzufügen:
    	$mZeiten[$sCtrlID] = $aZeit
    
    	; Alle Zeiten zusammenrechnen und Summe ausgeben:
    	Local $nMinuten = 0, $aZeitTmp
    	For $iID In MapKeys($mZeiten)
    		$aZeitTmp = $mZeiten[$iID]
    		$nMinuten += $aZeitTmp[0] * 60 + $aZeitTmp[1]
    	Next
    	Local $nStunden = Floor($nMinuten / 60)
    	$nMinuten = Mod($nMinuten, 60)
    
    	; ausgeben
    	GUICtrlSetData($idSumme, StringFormat("%02d:%02d", $nStunden, $nMinuten)) 
    EndFunc
    Alles anzeigen
  • Ordner älter 24 h löschen

    • AspirinJunkie
    • 24. Januar 2024 um 13:05

    Ja Run() in Verbindung mit @Comspec.

  • Geschwindigkeit JSON UDF

    • AspirinJunkie
    • 24. Januar 2024 um 13:03

    Schau mal meinen Edit oben bezüglich der AutoIt-Version an.
    Die JSON_Dictionary wird im übrigen seit einiger Zeit nicht mehr gepflegt.
    Da du aber eh Maps verwenden wolltest, verstehe ich nicht, warum du diese anstatt der JSON.au3 nimmst.

  • Geschwindigkeit JSON UDF

    • AspirinJunkie
    • 24. Januar 2024 um 12:36

    Ich kann dein Problem nicht reproduzieren.
    Die angehangene Datei "Rubber.json" wird bei mir in 1,6s eingelesen.

    Um das offensichtlich bei dir vorhandene Problem zu ergründen benötigen wir nun ein Minimalskript, welches das von dir beschriebene Verhalten reproduziert (nein - das bisher gepostete ist kein Minimalskript - es sind nur 2 Funktionen), sowie die tatsächlichen Daten mit der das Problem auftritt.
    Dass du die aktuelle Version der UDF verwendest, setze ich mal als gegeben voraus.

    Btw: In der JSON-Datei meine ich ein Problem mit den Datentypen zu sehen: Offensichtliche numerische Werte wie 3.245038e+01 sind in der JSON-Datei als Stringtyp hinterlegt (in Anführungszeichen).
    Da die _JSON_Generate() nicht einfach aus numerischen Typen Strings bastelt, muss der falsche Datentyp bereits in den Ausgangsdaten vorhanden sein.


    Edit: Oder noch viel wichtiger: Welche Version von AutoIt verwendest du?
    In Version 3.16.0 wurde ein Bug in StringRegExp gefixt, welcher insbesondere Mehrfachaufrufe von großen Strings enorm ausgebremst hat.
    Das war insbesondere für die UDF hier tödlich.
    Heißt: Mit allen älteren Versionen sollte das von dir beschriebene Verhalten auftauchen.

  • Anzahl Minuten in Stunden und Minuten umrechnen

    • AspirinJunkie
    • 24. Januar 2024 um 10:35
    Zitat von hipfzwirgel

    Wenn ich jetzt meine Arbeitsstunden vom Dezember mit der Abrechung vergleiche steht 103,99 zu 104 da. Ist wohl der Rundung geschuldet.

    Rundungsfehler? Hm - zeig mal dein Skript.
    Im Grunde kann man das nahezu vollständig auf Integerbasis aufbauen - da sollte es nicht zu derartigen Rundungsfehlern kommen.

  • Anzahl Minuten in Stunden und Minuten umrechnen

    • AspirinJunkie
    • 23. Januar 2024 um 18:35

    Bingo

  • Anzahl Minuten in Stunden und Minuten umrechnen

    • AspirinJunkie
    • 23. Januar 2024 um 17:46

    Vielleicht ist es etwas einfacher zu rechnen, wenn du genau andersherum rangehst.
    Anstatt Minuten in Stunden umzurechnen um sie dann zu addieren, sollte es einfacher sein eine Summe aller Minuten $nMinuten zu berechnen.
    Das ist einfach, da man nur die Minuten addieren braucht und die Stunden sind ja nur noch mit 60 zu multiplizieren.

    Dann ist die Rechnung am Ende ziemlich easy:

    AutoIt
    $nStunden = Floor($nMinuten / 60)
    $nMinuten = Mod($nMinuten, 60)
  • Ordner älter 24 h löschen

    • AspirinJunkie
    • 23. Januar 2024 um 06:38

    Nun du hast folgende Teilaufgaben vor dir:

    1. Eine Liste aller Ordner erstellen: _FileListToArray würde hierfür gehen aber auch mit den zugrunde liegenden Funktion FileFindFirst/NextFile könnte man dies machen.
    2. Die Liste in einer Schleife durchlaufen
    3. Für jeden Ordner den Erstellzeitpunkt ermitteln: FileGetTime
    4. Die Differenz zu jetzt bestimmen: Entweder manuell über die einzelnen Zeitbestandteile oder mit Hilfe der Funktion _DateDiff - dort müsstest du dir aber noch den Zeitstring aus FileGetTime entsprechend formatieren.
    5. Falls die Differenz ein bestimmte Maß überschreitet - Ordner löschen.
  • MAPs - Datenstruktur/ Typ direkt abspeichern?

    • AspirinJunkie
    • 22. Januar 2024 um 09:35
    Zitat von uuchip

    In dem beigefügten Code-Schnipsel müsste eigentlich $B = $A sein, aber die Quelle $A ist ein 2D Array, und B besteht scheinbar aus 2x 1D Array, bzw. _ArrayDisplay kann $B nicht richtig auflösen/ darstellen.

    Exakt. JSON, als auch CBOR hat keine Möglichkeit mehrdimensionale Arrays von verschachtelten Arrays zu unterscheiden.
    Dies hängt damit zusammen, dass viele Programmiersprachen mehrdimensionale Arrays in dieser Form gar nicht kennen (Javascript oder Python wären Beispiele hierfür).
    Ein 2D-Array wird dort also implizit in ein Array-In-Array serialisiert.
    Beim Einlesen wiederrum, gibt es keine Möglichkeit zu detektieren ob es sich mal um ein mehrdimensionales Array oder ein Array-In-Array handeln soll.
    Daher obliegt es dem User die Arrays bei Bedarf in die Form zu bringen, welche er benötigt.

    Genau daher gibt es in der JSON-UDF Funktionen, welche genau dies bewerkstelligen, so dass dein Skript folgendermaßen anzupassen wäre:

    AutoIt
    #include <JSON.au3>
    #include <Array.au3>
    
    ; Aufbau der Datenstruktur in AutoIt
    Global $A[2][2] = [[1, 2], [3, 4]]
    Global $M[]
    $M["A"] = $A
    $M["S"] = "Hallo Welt"
    Global $M1 = $M
    $M["M"] = $M1
    
    ; erstmal löschen - sonst wird es nur angefügt
    FileDelete("mtest.json")
    
    ; AutoIt-Variable in JSON-Datei serialisieren
    FileWrite("mtest.json", _JSON_GenerateCompact($M))
    
    ; JSON-Datei wieder in AutoIt deserialisieren:
    Global $InPut = FileRead("mtest.json")
    Global $M2 = _JSON_Parse($InPut)
    
    ; Array-In-Array in ein 2D-Array konvertieren:
    $B = __JSON_AinAToA2d($M2["A"])
    
    ; Ausgeben
    _ArrayDisplay($A, "$A")
    _ArrayDisplay($B, "$B")
    Alles anzeigen
  • MAPs - Datenstruktur/ Typ direkt abspeichern?

    • AspirinJunkie
    • 21. Januar 2024 um 19:43
    Zitat von uuchip

    Der beschriebene Weg ist wahrscheinlich der von Profis!
    [...]
    Ich denke jetzt evtl. zu naiv, und weil ich keine Schnittstelle zu anderen Sprachen benötige, dass man die Map im Speicher lokalisieren könnte, und diese Daten dann in einem binären Format abspeichert, und später wieder einlesen kann?

    So richtig weiß ich ehrlich gesagt nicht was du denkst.
    Du wolltest eine Funktionialität mit welcher du verschachtelte AutoIt-Strukturen in Dateien abspeichern kannst und später wieder einlesen.
    Sowohl CBOR als auch JSON machen das mit dem nur denkbar geringsten Aufwand.

    Beispiel JSON:

    AutoIt
    ; AutoIt-Variable in Datei speichern
    FileWrite("myData.json", _JSON_GenerateCompact($mMap))
    
    ; AutoIt-Struktur aus JSON-formatierter Datei einlesen:
    $mMap = _JSON_Parse(FileRead("myData.json"))

    Beispiel CBOR:

    AutoIt
    ; AutoIt-Variable in Datei speichern
    FileWrite("myData.bin", _cbor_encode($mMap))
    
    ; AutoIt-Struktur aus CBOR-formatierter Datei einlesen:
    $mMap = _cbor_decode(FileRead("myData.bin"))


    Ich weiß nicht was dich daran stört.
    Das Label "Profi" verstehe ich auch nicht in dem Zusammenhang.
    Mal abgesehen davon, dass ich genauso wenig Profi bin wie du (vermutlich), sollte die Auswahl der Werkzeuge sich bei einem Amateur nicht wirklich von einem Profi unterscheiden.
    In beiden Fällen wird das Werkzeug genommen mit der man eine gestellte Aufgabe möglichst effektiv und effizient lösen kann.
    Die Anforderungen bei einem Profi sind es, welche eine Unterscheidung bringen können.
    Aber bei gleicher Aufgabenstellung sollten auch ähnliche Lösungen herauskommen.

    Du möchtest den vorgeschlagenen Ansatz nun nicht verwenden weil sie deiner Meinung nach "Profis" vorbehalten ist? - hab ich das so richtig verstanden?
    Was möchtest du dann?
    Eine umständlichere, fehleranfälligere Lösung damit sie mehr nach Amateur aussieht?
    JSON und CBOR darfst du als "Amateur" genauso verwenden ohne dass jemand dann mit dir schimpft.

    Wenn ich dir stattdessen zeigen wöllte was für ein toller Hecht ich doch bin, dann hätte ich dir einfach die Begriffe Avro, Thrift oder protobuf vor die Füße geworfen und mich dann als echt großer Profi gefühlt...
    Das hätte dich kein Stück weiter gebracht - im Gegensatz zu meinem Vorschlag mit JSON und CBOR.
    Das war tasächlich ernst gemeint von mir, dass ich dies für die sinnvollste Lösung für deine Problemstellung halte.
    Aber behalte im Hinterkopf: Es ist nur eine Amateurmeinung - Profis würden dir vielleicht zu etwas ganz anderem raten...

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™