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

  • Cairo unter Autoit nutzen

    • AspirinJunkie
    • 24. März 2024 um 18:13

    Ja du übergibst es ja auch als Double.
    Integer 5 ist anders kodiert als 5.0 Double.
    Und DllCall übergibt eben als Double.
    Integer zu übergeben wird daher nicht funktionieren.

    Das heißt im Grunde, man kann nur ganzzahlige Werte übergeben aber dennoch als Double kodiert.
    Was für ein Unsinn.

  • Cairo unter Autoit nutzen

    • AspirinJunkie
    • 24. März 2024 um 17:57

    Wenn ich Round($t + $iW / 4) eintrage, dann geht es wieder.
    Offensichtlich dürfen dort nur ganzzahlige Werte eingetragen werden.
    Das widerspricht aber bisschen dem Double-Typ.
    Da hätte man ja gleich einen Integer dafür nehmen können.
    Vielleicht verstehen wir da was prinzipielles noch nicht.

  • Cairo unter Autoit nutzen

    • AspirinJunkie
    • 24. März 2024 um 17:42
    Zitat von UEZ

    nur wenn ich die Position über eine Variable in der cairo_rectangle Funktion hinzufüge, dann passiert nichts mehr.

    Ich verstehe noch nicht ganz die Problemlage.
    Du verwendest doch bereits Variablen für die Positionsparameter.
    Und augenscheinlich funtkionieren diese bei mir auch.

    Hab es auch mal so angepasst, dass sie sich ändern und das ganze daher animiert wird:

    AutoIt
    Local $x = 0, $y = 0
    	Do
            _WinAPI_BeginPaint($hGUI, $tPAINTSTRUCT)
    		$x = Mod($x+ 1, $iW)
    		$y = Mod($y + 1, $iH)
    
    		$c = 0.5 + 0.5 * Sin($t)
    		Cairo_ClearContext($pContext, $c, $c, $c)
    
    		DllCall($g_hCairoDLL, "none:cdecl", "cairo_set_source_rgba", "ptr", $pContext, "double", 0, "double", 0, "double", 0.5 + 0.5 * Cos($t), "double", 1.0)
    		DllCall($g_hCairoDLL, "none:cdecl", "cairo_set_line_width", "ptr", $pContext, "double", $iH / 10)
    		DllCall($g_hCairoDLL, "none:cdecl", "cairo_rectangle", "ptr",  $pContext, "double", $x, "double", $y, "double", $iW / 2, "double", $iH / 2)
    		DllCall($g_hCairoDLL, "none:cdecl", "cairo_stroke", "ptr", $pContext)
    Alles anzeigen

    Auch das funktioniert bei mir wunderbar.
    Ich habe dein Problem also offensichtlich noch nicht ganz verstanden.

  • Array über Programmdauer hinweg speichern

    • AspirinJunkie
    • 22. März 2024 um 21:10
    Zitat von Kanashius

    Boolean ist 1 bit, der String "False" sind 5 byte (40bit oder noch mehr, je nach encodierung des textes (Standard wäre UTF-8 glaub ich, also 8*4*5 => 160bits)). In deinem Anwendungsfall ggf. nicht so wichtig, je nach Menge der Datensätze, ist aber schon das 160 fache an Datenverbrauch.

    Auch wenn ich der Grundaussage "Nimm die richtigen Datentypen" sehr zustimme will ich die massiven Werte hier vielleicht doch mal ein wenig runterholen.
    Boolean in Sqlite verbraucht nicht 1 Bit sondern ist intern ein Integer. Diese werden je nach Wert in 1 bis 8 Byte gespeichert. Auch wenn ich es nicht genau weiß, gehe ich bei boolean in Sqlite daher von 1 Byte aus.
    Übrigens: Wenn man in Sqlite ein Boolean-Attribut hat und diesem den Wert "True" oder "False" zuweist, dann macht der auch brav 1 oder 0 daraus und meckert nicht weil es ja kein String ist.

    Zum Thema UTF-8: Der Witz an UTF-8 ist ja eben, dass diese Kodierung keine feste Länge hat sondern zwischen 1 und 4 Byte kodiert.
    Die Zeichen, welche man für "False" benötigt, befinden sich alle im ASCII-Bereich. Und dieser Bereich braucht in UTF-8 auch nur jeweils 1 Byte pro Zeichen.
    Es sind also 5 Byte. Nimmt man noch ein Byte dazu für das Stringende als Null-Char dann wären es 6 bzw. 5 bei "True".

    Sprich: Wir hätten also eher einen 5 bis 6-fachen Datenverbrauch zu erwarten.
    Ist viel ohne Frage aber klingt schon ganz anders als 160x.

  • [PHP] [JAVA] [XML] [JSON] - Unbekannte Übergabe verläuft fehlerhaft

    • AspirinJunkie
    • 22. März 2024 um 18:22

    Ich habe tatsächlich ehrlich gesagt noch nicht ganz begriffen was nun an was genau übergeben wird und wer nun genau den Fehler schmeißt.
    ich sehe aber deine Beispiele und kann dazu etwas sagen.

    Zitat von Nachid

    $val = "<timetable><interval type=\"week\"><from>10</from><to>12</to></interval></timetable>";        Fehler in ResponseWrapper - Unexpected Char 119 (w)


    Das ist valider PHP-Code mit korrektem escape. Dieser erzeugt einen String, welcher korrekt formatierten XML-Code (mal von der XML-Deklaration abgesehen) als Variableninhalt erzeugt.
    Alternativ würde auch folgendes den gleichen String erzeugen:

    Code
    $var = '<timetable><interval type="week"><from>10</from><to>12</to></interval></timetable>'
    Zitat von Nachid

    { "data" : "<timetable><interval type=\"week\"><from>10</from><to>12</to></interval></timetable>" }

    Das ist volkommen valider JSON-Code mit korrektem escape.

    Wer schmeißt jetzt nun den Fehler und was und in welcher Form wird da die Eingabe erwartet?
    Ich sehe korrekten PHP Code, welcher korrekten XML-Code erzeugt und sehe korrekten JSON-Code welcher den XML-String korrekt enthält.

  • Maps mit Arrays (Map in Array in Map)

    • AspirinJunkie
    • 15. März 2024 um 18:24
    Zitat von aSeCa

    Danke dir, das ist schade... Wenn ich dann da wieder ein Array speichern will, dann klappt das mit der UDF auch nicht mehr.

    Doch natürlich kannst du dort ein Array speichern:

    AutoIt
    Global $aArray[] = [1,2,3]
    _JSON_addChangeDelete($mData, "parts[0].einArray", $aArray)

    Aktuell kann diese Funktion nicht mit 2D-Arrays umgehen, da es diese im JSON-Umfeld schlicht nicht gibt. Kann man aber auch noch implementieren zur Not (hab ich bei der _JSON_Get() gemacht)

    Zitat von aSeCa

    Mache mich ja schon echt unflexibel mit Maps, wenn die hier an ihre Grenzen kommen,

    Maps sind nicht unflexibler als Arrays. Bei verschachtelten Arrays verhalten sich diese genauso wie verschachtelte Maps.

  • Maps mit Arrays (Map in Array in Map)

    • AspirinJunkie
    • 15. März 2024 um 17:08

    Die Variante mit dem verschachtelten Direktzugriff klappt primär zum Auslesen der Werte.
    Den genauen Mechanismus dahinter habe ich jetzt nicht parat aber es werden - zumindest in deinem Fall - auf dem Weg Kopien der einzelnen Datenstrukturen erzeugt.
    Man gibt also nicht einen Pfad auf den man schreibt an, sondern liest erst etwas aus und versucht das zu beschreiben.
    Also kurz: Auslesen auf diese verschachtelte Art: Ok - Beschreiben in dieser Syntax - nicht ok.

    Um dennoch ohne viel manuelles auslesen und wiederbeschreiben von Unterobjekten Werte in tiefen verschachtelten Ebenen zu verändern, habe ich mal hierfür eine Funktion geschrieben.
    Diese findest du in der JSON-UDF, da man in diesem Umfeld häufig mit heftig verschachtelten Datenstrukturen zu tun hat.
    Mit dieser würde man dein Beispiel folgendermaßen beheben können:

    AutoIt
    #include "JSON.au3"
    
    Local $mData[] ; Große Map
    Local $aArray[1] ; Array mit Liste zusammengehörender Teile
    Local $mMapOther[] ; Kleine Map mit Eigenschaften der Teile im Array
    
    $mMapOther["otherValue"] = "other"
    $aArray[0] = $mMapOther
    
    $mData["parts"] = $aArray ; Ich will ja das Array ablegen, nicht das erste Teil der Liste
    
    ConsoleWrite($mData.parts[0].otherValue & @CRLF)
    
    _JSON_addChangeDelete($mData, "parts[0].otherValue", "nein")
    
    ConsoleWrite($mData.parts[0].otherValue & @CRLF)
    
    ConsoleWrite("Die ganze Struktur: " & _JSON_Generate($mData) & @CRLF)
    Alles anzeigen
  • Konverter C++ Quellcode zu AutoIt-Skript

    • AspirinJunkie
    • 12. März 2024 um 12:26
    Zitat von PSblnkd

    Damit gibt es m.E. nun ein hilfreiches Werkzeug den mitunter sehr kryptischen C++Code verstehen zu können, wenn man kein C++-Profi ist.

    Hast du mal ChatGPT und Konsorten probiert?
    Dort kannst du dem einfach den Code vor die Füße werfen und fragen: "Was macht dieser Code?"
    Die Erläuterungen hierbei sind oft erstaunlich akkurat und das auch noch in humaner Sprache.

  • Durchschleifen einer ArrayList und dabei einzelne Listeneinträge löschen

    • AspirinJunkie
    • 6. März 2024 um 15:14

    Gibt es einen spezifischen Grund warum es die ArrayList sein muss?
    Das grundlegende Verhalten von dieser kannst du auch mit den in AutoIt integrierten Maps ( siehe MapAppend()) erreichen.

  • Umlaute in Dateien aus DOS-Befehlen

    • AspirinJunkie
    • 6. März 2024 um 06:24

    Ich hab für soetwas auch eine entsprechende Funktion rumliegen, welche neben der Möglichkeit mit regulären Ausdrücken zu filtern auch die Option bietet mit komplett eigenen Funktionen zu filtern.
    Für deinen Fall reicht der RegEx-Filter ja aber aus.
    Warum könnte die Funktion für dich dennoch etwas sein, obwohl du bereits die schlanke, elegante Variante von Kanashius vorliegen hast?
    Du sagtest letztens, dass du mehrere Ordner durchsuchen musst und daher mehrmals die Funktion aufrufen und die Arrays am Ende zusammenfügen musst.

    Mit der folgenden Funktion kannst du direkt mehrere Ordner (durch "|" getrennt) übergeben und dir damit evtl das Leben ein bisschen einfacher gestalten:

    AutoIt
    #include <Array.au3>
    
    
    $aFiles = _listFilesFlexible(@SystemDir & "|" & @UserProfileDir, "\_\d{4}", 2)
    _ArrayDisplay($aFiles)
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _listFilesFlexible()
    ; Description ...: Finds files and/or folders in a directory tree with multiple filtering options
    ; Syntax ........: _listFilesFlexible($sSD, [Const $sPat = '', [Const $iF = 3, [Const $1BASED = 0, [Const $pProcess = Default]]]])
    ; Parameters ....: $sSD           - search location[s] (you can separate multiple with "|")
    ;                  Const $sPat    - [optional] regular expression for filename matching or a function pointer for more complex matching
    ;                                   remark: RegEx is normally case-sensitive - add (?i) at pattern start to switch to case-insensitive
    ;                                   "" (Default): No filename matching - all elements will be retrieved
    ;                  Const $iF      - [optional] 1=only files, 2=only folders, 3=files and folders (default:3)
    ;                  Const $1BASED  - [optional] 0= zero-based - no count in $Array[0] (Default), 1= 1-based - count in $Array[0]
    ;                  Const $pProcess- [optional] A special function with which the handling of file matches can be completely customized. For the structure (especially the use of the 2nd parameter $iSwitch) see the example.
    ; Return values .: Success - Return Array with Matches
    ;                  Failure - Return "" and set @error
    ; Author ........: AspirinJunkie
    ; =================================================================================================
    Func _listFilesFlexible($sSD, Const $sPat = Default, Const $iF = 3, Const $1BASED = 0, Const $pProcess = Default)
    	Local $cEl = $1BASED, $cAS = 1 ; counter for number of elements vs. current array size
    	Local $aRet[1] = [0]
    
    	Local $aSD = StringSplit($sSD, '|', 2) ; queue for search folders
    	Local $iNextSD = 0, $iTotalSD = UBound($aSD), $iFirstSD = 0, $iLengthSD, $aTmp[0]
    	Local $FFFF, $FFNF, $sDir, $sP
    
    	Local $hDLL = DllOpen('kernel32.dll')
    	Local $p_F = DllCall($hDLL, "ptr", "GetProcAddress", "handle", DllCall($hDLL, "handle", "GetModuleHandleW", "wstr", "kernel32.dll")[0], "str", "GetFileAttributesW")[0] ; get the function address of GetModuleHandleW
    	If Not ($iF = 3 Or $iF = 1 Or $iF = 2) Then Return SetError(3, 0, "")
    
    	; initialize user-based processing if used:
    	If $pProcess <> Default Then $pProcess("", 1)
    
    	If $sPat = Default Then
    		Do
    			; pull next dir from subfolder Queue
    			$sDir = $aSD[$iFirstSD] & "\"
    			$iFirstSD += 1
    			If $iFirstSD = UBound($aSD) Then $iFirstSD = 0
    			$iTotalSD -= 1
    
    			$FFFF = FileFindFirstFile($sDir & '*')
    			If $FFFF <> -1 Then
    				Do
    					$FFNF = FileFindNextFile($FFFF)
    					If @error Then ExitLoop
    					$sP = $sDir & $FFNF
    					If @extended Then ; folder
    
    						If BitAND($iF, 2) Then ; matched dir
    							If $pProcess = Default Then ; normal array return
    								If $cEl >= $cAS Then
    									$cAS += $cAS
    									ReDim $aRet[$cAS]
    								EndIf
    								$aRet[$cEl] = $sP
    								$cEl += 1
    							Else ; user defined match handling
    								$pProcess($sP)
    							EndIf
    						EndIf
    
    						; ignore reparse points
    						If BitAND(DllCallAddress('dword', $p_F, 'wstr', $sP)[0], 0x400) Then ContinueLoop
    
    						; push subfolder to folder Queue
    						If UBound($aSD) = $iTotalSD Then ; resize and rearrange
    							Dim $aTmp[UBound($aSD) * 2]
    							$iLengthSD = UBound($aSD)
    							For $i = 0 To $iLengthSD - 1
    								$aTmp[$i] = $aSD[Mod($iFirstSD + $i, $iLengthSD)]
    							Next
    							$aSD = $aTmp
    							$iFirstSD = 0
    							$iNextSD = $iTotalSD
    						EndIf
    						$aSD[$iNextSD] = $sP
    						$iNextSD += 1
    						If $iNextSD = UBound($aSD) Then $iNextSD = 0
    						$iTotalSD += 1
    
    					ElseIf BitAND($iF, 1) Then ; matched file
    						If $pProcess = Default Then ; normal array return
    							If $cEl >= $cAS Then
    								$cAS += $cAS
    								ReDim $aRet[$cAS]
    							EndIf
    							$aRet[$cEl] = $sP
    							$cEl += 1
    						Else     ; user defined match handling
    							$pProcess($sP)
    						EndIf
    					EndIf
    				Until 0
    				FileClose($FFFF)
    			EndIf
    		Until $iTotalSD < 1
    
    	ElseIf IsFunc($sPat) Then ; $sPat = function
    		Do
    			; pull next dir from subfolder Queue
    			$sDir = $aSD[$iFirstSD] & "\"
    			$iFirstSD += 1
    			If $iFirstSD = UBound($aSD) Then $iFirstSD = 0
    			$iTotalSD -= 1
    
    			$FFFF = FileFindFirstFile($sDir & '*')
    			If $FFFF <> -1 Then
    				Do
    					$FFNF = FileFindNextFile($FFFF)
    					If @error Then ExitLoop
    					$sP = $sDir & $FFNF
    					If @extended Then ; folder
    						If BitAND($iF, 2) And $sPat($sP) Then ; match by function
    							If $pProcess = Default Then ; normal array return
    								If $cEl >= $cAS Then
    									$cAS += $cAS
    									ReDim $aRet[$cAS]
    								EndIf
    								$aRet[$cEl] = $sP
    								$cEl += 1
    							Else ; user defined match handling
    								$pProcess($sP)
    							EndIf
    						EndIf
    
    						; ignore reparse points
    						If BitAND(DllCallAddress('dword', $p_F, 'wstr', $sP)[0], 0x400) Then ContinueLoop
    
    						; push subfolder to folder Queue
    						If UBound($aSD) = $iTotalSD Then ; resize and rearrange
    							Dim $aTmp[UBound($aSD) * 2]
    							$iLengthSD = UBound($aSD)
    							For $i = 0 To $iLengthSD - 1
    								$aTmp[$i] = $aSD[Mod($iFirstSD + $i, $iLengthSD)]
    							Next
    							$aSD = $aTmp
    							$iFirstSD = 0
    							$iNextSD = $iTotalSD
    						EndIf
    						$aSD[$iNextSD] = $sP
    						$iNextSD += 1
    						If $iNextSD = UBound($aSD) Then $iNextSD = 0
    						$iTotalSD += 1
    
    						; file
    					ElseIf BitAND($iF, 1) And $sPat($sP) Then ; match by function
    						If $pProcess = Default Then ; normal array return
    							If $cEl >= $cAS Then
    								$cAS += $cAS
    								ReDim $aRet[$cAS]
    							EndIf
    							$aRet[$cEl] = $sP
    							$cEl += 1
    						Else     ; user defined match handling
    							$pProcess($sP)
    						EndIf
    					EndIf
    				Until 0
    				FileClose($FFFF)
    			EndIf
    		Until $iTotalSD < 1
    
    	Else ; $sPat = regex
    		Do
    			; pull next dir from subfolder Queue
    			$sDir = $aSD[$iFirstSD] & "\"
    			$iFirstSD += 1
    			If $iFirstSD = UBound($aSD) Then $iFirstSD = 0
    			$iTotalSD -= 1
    
    			$FFFF = FileFindFirstFile($sDir & '*')
    			If $FFFF <> -1 Then
    				Do
    					$FFNF = FileFindNextFile($FFFF)
    					If @error Then ExitLoop
    					$sP = $sDir & $FFNF
    					If @extended Then ; folder
    						If BitAND($iF, 2) And StringRegExp($FFNF, $sPat) Then ; match by regex
    							If $pProcess = Default Then ; normal array return
    								If $cEl >= $cAS Then
    									$cAS += $cAS
    									ReDim $aRet[$cAS]
    								EndIf
    								$aRet[$cEl] = $sP
    								$cEl += 1
    							Else ; user defined match handling
    								$pProcess($sP)
    							EndIf
    						EndIf
    
    						; ignore reparse points
    						If BitAND(DllCallAddress('dword', $p_F, 'wstr', $sP)[0], 0x400) Then ContinueLoop
    
    						; push subfolder to folder Queue
    						If UBound($aSD) = $iTotalSD Then ; resize and rearrange
    							Dim $aTmp[UBound($aSD) * 2]
    							$iLengthSD = UBound($aSD)
    							For $i = 0 To $iLengthSD - 1
    								$aTmp[$i] = $aSD[Mod($iFirstSD + $i, $iLengthSD)]
    							Next
    							$aSD = $aTmp
    							$iFirstSD = 0
    							$iNextSD = $iTotalSD
    						EndIf
    						$aSD[$iNextSD] = $sP
    						$iNextSD += 1
    						If $iNextSD = UBound($aSD) Then $iNextSD = 0
    						$iTotalSD += 1
    
    					ElseIf BitAND($iF, 1) And StringRegExp($FFNF, $sPat) Then ; match by regex
    						If $pProcess = Default Then ; normal array return
    							If $cEl >= $cAS Then
    								$cAS += $cAS
    								ReDim $aRet[$cAS]
    							EndIf
    							$aRet[$cEl] = $sP
    							$cEl += 1
    						Else     ; user defined match handling
    							$pProcess($sP)
    						EndIf
    					EndIf
    				Until 0
    				FileClose($FFFF)
    			EndIf
    		Until $iTotalSD < 1
    	EndIf
    
    	DllClose($hDLL)
    	If $pProcess = Default Then ; normal file array
    		If $1BASED = 1 Then $aRet[0] = $cEl - 1
    		ReDim $aRet[$cEl]
    		Return $aRet
    	Else ; user-based processing
    		Return $pProcess("", 2)
    	EndIf
    EndFunc   ;==>_listFilesFlexible
    Alles anzeigen

    Edit: Ich erinnere mich, dass du junctions finden wolltest. Die Funktion hier filtert aber ganz bewusst junctions (in dem Fall alle reparse points) heraus.
    Müsstest du also mal entsprechend testen.

  • Umlaute in Dateien aus DOS-Befehlen

    • AspirinJunkie
    • 5. März 2024 um 14:07
    Zitat von HansJ54

    in meinem ersten Beispiel wird der alte Inhalt des eindimensionalen Arrays gelöscht.

    Das ist was anderes als eine 3. Spalte hinzufügen.
    Bei Änderungen der Dimensionsanzahl geht bei ReDim immer der Inhalt verloren.
    _ArrayColInsert macht hierbei auch nichts anderes als du manuell: Es kopiert den Inhalt einzeln in ein neues Array.

  • Umlaute in Dateien aus DOS-Befehlen

    • AspirinJunkie
    • 5. März 2024 um 13:15
    Zitat von HansJ54

    Array: ich habe einfach ein großes Array definiert mit 120.000 und nachher mit ReDim angepasst. Das reduzierte die Zeit von 6 Stunden auf die 4 1/2 Minuten. Wenn ich vorher _DynArray-UDF gekannt hätte, wäre es sicher einfacher gewesen. ;)

    Nein da musst du nicht erst mit einer extra UDF rumbasteln.
    Dein Weg führt für deinen Fall einfacher und schneller ans Ziel.
    Das bisschen Speichermehrverbrauch ist hierbei zu verschmerzen.

    Zitat von HansJ54

    Array: wie kann ich bei einem Array[20][2] eine dritte Spalte zufügen, ohne den Inhalt zu verlieren? Bei ReDim war der Inhalt weg. Geht das ohne For $i ... und einem neuen Array?

    Bei mir bleibt der Inhalt bestehen:

    AutoIt
    #include <Array.au3>
    
    Global $aArray[4][2] = [[1,2],[3,4],[5,6],[7,8]]
    _ArrayDisplay($aArray, "vorher")
    
    Redim $aArray[4][3]
    _ArrayDisplay($aArray, "nachher")
    Zitat von HansJ54

    in eine .csv um mit Excel weiterzuarbeiten. Da sind dann beim Öffnen die Umlaute falsch.

    Ja dann ist es ja kein Problem von AutoIt sondern von Excel, welches zu dumm ist eine Kodierung korrekt zu erkennen.
    Damit auch Excel als letzter es rafft bietet es sich an die Datei mit BOM zu speichern:

    Zitat von HansJ54

    Bei FileOpen() gibt es den Parameter, bei _FileWriteFromArray() scheinbar nicht.

    _FileWriteFromArray() nimmt entweder einen Pfad oder eben ein FileHandle wie es von FileOpen() zurückgegeben wird.
    Sprich: die Datei manuell zum Schreiben in der richtigen Kodierung mit FileOpen() öffnen und mit dem Handle _FileWriteFromArray() füttern:

    AutoIt
    #include <Array.au3>
    #include <File.au3>
    
    Global $aArray[][2] = [["Düs","üst"],["äin","Täst"]]
    $sPath = @ScriptDir & "\Test.csv"
    
    ; schreibe csv Datei in UTF-8-Kodierung mit BOM
    $hPath = FileOpen($sPath, 2 + 128)
    _FileWriteFromArray($hPath, $aArray, 0, Default, ";")
    FileClose($hPath)
    
    ; Datei wieder in ein Array einlesen
    Global $aFile
    _FileReadToArray($sPath, $aFile, 0, ";")
    
    _ArrayDisplay($aFile, "wieder eingelesen")
    Alles anzeigen
  • Umlaute in Dateien aus DOS-Befehlen

    • AspirinJunkie
    • 5. März 2024 um 07:29
    Zitat von HansJ54

    EIn Problem war, dass ArrayAdd() ab über 10.000 Einträgen immer langsamer wurde und endlos dauerte.

    Das ist eine erwartbare Eigenschaft von _ArrayAdd() und schlägt öfters mal als Problem auf.
    Hintergrund ist, dass bei jedem Aufruf von _ArrayAdd ein neuer größerer Speicherbereich alloziert wird (ReDim) und das bisherige Array dorthin verschoben wird - jedes einzelne mal.
    Je mehr Elemente im Array stehen umso länger dauert das halt.

    Möglichkeiten das schneller zu gestalten als einzelne Werte mit _ArrayAdd hinzuzufügen:

    • Wenn nicht nur 1 Element hinzugefügt werden soll sondern mehrere gleichzeitig, dann kann man _ArrayAdd auch ein Array übergeben - so wird nur einmal ein ReDim durchgeführt).
    • Maps sind dynamischer. Man kann sich auch damit mit Hilfe von MapAppend() schrittweise eine entsprechende Datenstruktur aufbauen und am Ende diese, falls notwendig, in ein Array überführen.
    • Arrays können auch dynamischer gestaltet werden, wenn man dessen Größe flexibler anpasst. Nennt sich dann ArrayList und wurde auch in AutoIt mal umgesetzt: >>DynArray-UDF<<
    Zitat von HansJ54

    Jetzt bleibt nur noch das Restproblem, dass die gefundenen und in einer .csv gespeicherten kritischen Pfade (_FileWriteFromArray() nach _FileListToArrayRec() ) wieder Probleme mit den Umlauten haben.

    Bei _FileListToArrayRec() selbst sollte es keine Probleme mit Umlauten geben. Wenn du dessen Ergebnis erst in eine Datei schreibst und wieder ausliest (warum eigentlich?) liegt das Problem an dieser Stelle.
    Achte darauf, dass sowohl beim Schreiben als auch Lesen dieser Dateien die gleiche Kodierung verwendet wird. Am besten eine mit BOM. $FO_UTF8 wäre als Modus für FileOpen() daher geeignet.

    Die OemToChar bringt hierbei nichts, da diese einen OEM-kodierten String übersetzt. Diese Kodierung wird aber fast nur bei den Windows-Konsolenbefehlen verwendet.
    Und da du ja kein "DOS"-Dir (es gibt schon seit Windows XP kein DOS mehr) verwendest, brauchst du diese Konvertierung daher nicht.

  • Umlaute in Dateien aus DOS-Befehlen

    • AspirinJunkie
    • 2. März 2024 um 16:44

    Ok um die Problemlage mal noch etwas detaillierter zu beschreiben.
    Das eigentliche Problem ist nicht die Größe des Eingangsstrings.
    Stattdessen ist es die Größe des Puffers für den Ausgabestring.
    Das ist der 2. Parameter der Funktion und im problematischen Aufruf, wurde dieser einfach als Leerstring des Typs "str" definiert.
    Das führt dazu, dass AutoIt hierfür einen Speicherbereich von 65536 Zeichen reserviert.
    Klar - AutoIt kann ja auch nicht wissen wie groß der Speicher sein muss.

    Wenn der Eingabestring nun größer als diese 65536 Zeichen ist, dann reicht dieser Platz also nicht aus und wir laufen in den beobachteten Fehler.

    Kann man was dagegen tun?`
    Ja - man kann selbst einen Puffer erzeugen und diesem die korrekte Größe zuweisen.
    Das sähe dann ungefähr so aus:

    AutoIt
    Func __prc_OemToChar($sStr)
    	; input string
    	Local $tIn = DllStructCreate("CHAR [" & StringLen($sStr) + 1 & "]")
    	DllStructSetData($tIn, 1, $sStr)
    
    	; output buffer
    	Local $tOut = DllStructCreate("CHAR [" & StringLen($sStr) + 1 & "]")
    
    	Local $aCall = DllCall("user32.dll", 'BOOL', 'OemToCharA', 'PTR', DllStructGetPtr($tIn), 'PTR', DllStructGetPtr($tOut))
    	If @error Or Not $aCall[0] Then Return SetError(@error + 10, @extended, '')
    		
    	Return DllStructGetData($tOut, 1)
    EndFunc   ;==>__prc_OemToChar
    Alles anzeigen
  • Umlaute in Dateien aus DOS-Befehlen

    • AspirinJunkie
    • 2. März 2024 um 15:35

    Das Problem ist, dass OemToChar keine Eingangsstrings mit einer Größe > 65536 verträgt.
    Das könnte man lösen, indem man den Eingangsstring entsprechend aufsplittet und schrittweise konvertiert.
    Aber genau das haben die Programmierer der von AutoIt mitgelieferten Funktion _WinAPI_OemToChar() bereits schon so umgesetzt.
    Daher kann man auch direkt diese Funktion stattdessen verwenden.
    Ich selbst habe auch die Funktion mit der ich sowas ausführe mittlerweile entsprechend umgebaut:

    AutoIt
    #include <WinAPIConv.au3>
    
    $sReturn = _prc_RunWithReturn("dir", True, Default, @SystemDir)
    
    ConsoleWrite($sReturn & @CRLF)
    
    
    
    ; #FUNCTION# ======================================================================================
    ; Name ..........: _prc_RunWithReturn()
    ; Description ...: Executes programs or command line commands and returns their output
    ; Syntax ........: _prc_RunWithReturn($sCmd, [$bComspec = False, [$nFlags = 0x8, [$sWorkDir = '', [$nTimeOut = 0]]]])
    ; Parameters ....: $sCmd      - the command to be executed as you would use it in Run()
    ;                  $bComspec  - [optional] if true: The command is executed as a command line command of cmd.exe
    ;                  $nFlags    - [optional] flags that control the handling of the two streams stdout and stderr:
    ;                               0x2: [Default] Return a string with the content of stdout
    ;                               0x4: [Default] Return a string with the content of stderr
    ;                               0x6: Return a array with the content of stdout in $Array[0] and stderr in $Array[1]
    ;                               0x8: Return a string with the combined content of stdout and stderr
    ;                  $sWorkDir  - [optional] the working directory like in Run()
    ;                  $nTimeOut  - [optional] the maximum time to wait for the process to be completed (see @error return)
    ;                               default = 0: infinite; every other number: wait time in seconds
    ; Return values .: Success:   String with cmdline output or if $nFlags = 0x6: array with cmdline outputs and set
    ;                             @extended = return code of the process
    ;                  Failure:   "" and set @error to:
    ;                             | 1: error during run; @extended = @error of Run()
    ;                             | 2: ProcessWaitClose reaches timeout before completion
    ;                             | 3: content written in stderr - indicates error messages of the program
    ; Author ........: AspirinJunkie
    ; Modified ......: 2024-02-08 (AspirinJunkie)
    ; Related .......: _WinAPI_OemToChar()
    ; Example .......: ConsoleWrite(_prc_RunWithReturn("dir", True, Default, @SystemDir))
    ; =================================================================================================
    Func _prc_RunWithReturn($sCmd, $bComspec = False, $nFlags = 0x2, $sWorkDir = '', $nTimeOut = 0)
    	; handling Default keyword word for the parameters
    		If IsKeyWord($bComspec) = 1 Then $bComspec = True
    		If IsKeyWord($nFlags)   = 1 Then $nFlags   = 0x2
    		If IsKeyWord($sWorkDir) = 1 Then $sWorkDir = ""
    	
    	; start the cmd/process
    		Local $iPID = Run(($bComspec ? '"' & @ComSpec & '" /c ' : "") & $sCmd, $sWorkDir, @SW_Hide, $nFlags)
    		If @error Then Return SetError(1, @error, "")
    	
    	; wait until process ends
    		If ProcessWaitClose($iPID, $nTimeOut) = 0 Then Return SetError(2, 0, "")
    	; read out the process results
    		Local $iExit = @extended
    		Local $sStdOut = StdoutRead($iPID), $sStdErr = BitAND($nFlags, 0x4) ? StderrRead($iPID) : ""
    	
    	; return only stderr
    		If $nFlags = 0x4 Then
    			Return SetExtended($iExit, _WinAPI_OemToChar($sStdErr))
    	
    	; return array if stdout and stderr should be read separately
    		ElseIf $nFlags = 0x6 Then
    			Local $aRet[2] = [_WinAPI_OemToChar($sStdOut), _WinAPI_OemToChar($sStdErr)]
    			Return SetError($sStdErr = "" ? 0 : 3, $iExit, $aRet)
    		EndIf
    	
    	; return a string
    		Return SetExtended($iExit, _WinAPI_OemToChar($sStdOut))
    	EndFunc
    Alles anzeigen
  • Verschiedene Werte beim Auslesen eines NFC-Tags

    • AspirinJunkie
    • 1. März 2024 um 06:17
    Zitat von hipfzwirgel

    wenn ich das große D eingebe und beim kleinen D Zeichen 68 was eigentlich numerische Taste 8 ist. Bei E ist es Zeichen 69 sehr seltsam...

    Ich verstehe noch nicht was daran seltsam sein soll.
    68 ist der ASCII-Code vom großen D und 69 ist der ASCII-Code vom großen E.
    Also in Hex-Darstellung 0x44 und 0x45.
    Und so hast du es ja auch in deine Map eingetragen (auch wenn wie gesagt ein Chr() wohl reichen würde).

  • Verschiedene Werte beim Auslesen eines NFC-Tags

    • AspirinJunkie
    • 29. Februar 2024 um 13:57

    Ich wiederhole mich mal:

    Zitat von AspirinJunkie

    Hast du die Stelle mal debuggt, indem du die Inhalte der Variablen ausgeben lässt?


    Ansonsten sind die zugeordneten Codes 1:1 die entsprechenden ASCII-Codes.
    Anstatt einer extra Map sollte hier auch ein Chr($tKEYHOOKS.vkCode) ausreichend sein.
    Aber wie gesagt: dazu muss $tKEYHOOKS.vkCode auch tatsächlich das enthalten was du erwartest.
    Das sollte man halt zum Debugging prüfen.
    Dann sollte aber auch die Map-Variante funktionieren.

    Daher zum letzten mal: Debugge und lass dir die relevanten Variableninhalte samt ihrem Datentyp ausgeben.

  • Verschiedene Werte beim Auslesen eines NFC-Tags

    • AspirinJunkie
    • 23. Februar 2024 um 10:49
    Zitat von hipfzwirgel

    Trotzdem erkennt die IF -Abfrage in Zeile 69 die Buchstaben nicht und gibt den Fehlercode 815 zurück.

    Was gibt Fehlercode 815 zurück?
    MapExists?
    Hast du die Stelle mal debuggt, indem du die Inhalte der Variablen ausgeben lässt?

    Ansonsten kann ich selbst nicht viel testen, da ich kein NFC-Reader habe.
    Wenn du ein Minimalbeispiel baust, welches den Fehler reproduziert und auch so bei anderen lauffähig ist (z.B. den Wert im Programm direkt verwenden anstatt über NFC-Device auslesen), dann kann man dir wahrscheinlich eher weiterhelfen.

  • Verschiedene Werte beim Auslesen eines NFC-Tags

    • AspirinJunkie
    • 22. Februar 2024 um 12:37

    2147483647 ist der größte darstellbare Wert eines 32 Bit signed Integer.

    Der andere Wert liegt darüber.

    Könnte also ein Problem des Wertebereiches des Datentyps sein.

  • Data Collection-Variables / Maps in AutoIt - Status?

    • AspirinJunkie
    • 20. Februar 2024 um 09:57
    Zitat von Mars

    Irgendwo habe ich neulich auch eine Table-UDF (für Tabellen) gesehen. Habe aber vergessen wo.

    Na gut, da es jetzt doch erwähnt wird, will ich trotz der Gefahr der Schleichwerbung und zusätzlicher Verwirrung noch meinen Ansatz hierfür, welcher in der >>TableData-UDF<< implementiert wurde vorstellen.
    Diese UDF arbeitet mit Objekten (Maps um genau zu sein), welche die Daten von den Headern trennen.
    Das macht am Ende das Arbeiten mit diesen Daten einfacher, da statt Indizes Attributnamen verwendet werden können.

    Am besten am Beispiel: Hier konvertieren wir ein 2D-Array in ein solches Objekt und lassen es uns anzeigen (es kann aber auch von Strings, CSV-Dateien usw. eingelesen werden):

    AutoIt
    #include "TableData.au3"
    
    ; Ausgangsdaten: 2D-Array mit Header-Elementen in der 1. Zeile (man kann auch einen eigenen Header definieren)
    Global $aArray[5][4] = [["Name", "Alter", "Gehalt", "verheiratet"], ["Max", 25, 5000.50, True], ["Anna", 30, 6000.75, False], ["Peter", 35, 7000.25, True], ["Lena", 28, 5500.50, False]]
    
    ; Konvertierung in ein Tabellenobjekt:
    $mData = _td_fromArray($aArray, True)
    
    ; Daten anzeigen
    _td_display($mData, "Beispiel", True)

    Nun kann man diese Daten mit den mitgelieferten Funktionen so verwenden, dass man einfacher mit ihnen arbeiten kann.


    Z.B. kann man auf die Attributdaten der Datensätze einfach mit deren Namen zugreifen:

    AutoIt
    ; Alle Datensätze durchgehen und Zugriff auf deren Attribute per Attributname
    For $mP in _td_toObjects($mData)
    	ConsoleWrite( $mP.Name &  " (" & $mP.Alter & "): " & $mP.Gehalt & "€" & @CRLF)
    Next
    
    
    ; oder Einzelzugriff auf die Datensätze per Array-Index:
    $aDaten = _td_toObjects($mData)
    MsgBox(0,"Einzelzugriff", $aDaten[2].Name & " (" & $aDaten[2].Alter & ")")


    Oder wenn in einer Spalte Werte stehen, welche als Primärschlüssel geeignet sind, dann kann man diese auch nehmen um auf die einzelnen Elemente zuzugreifen:

    AutoIt
    ; konvertiere in Map, deren Key ein Primärschlüsselattribut ist:
    $mTable = _td_toPrimaryKeys($mData)
    
    ; Greife auf die Datensätze über ihren Primärschlüssel zu:
    MsgBox(0, "Annas Gehalt", $mTable.Anna.Gehalt)


    Oder man filtert die Daten anhand ihrer Eigenschaften:

    AutoIt
    ; Daten filtern
    $mData = _td_filter($mData, "$x.Gehalt > 5999")
    
    ; gefilterte Daten anzeigen
    _td_display($mData, "Großverdiener", True)


    Oder man extrahiert sich einzelne Spalten anhand ihres Namens:

    AutoIt
    ; Summe über das Gehalt bilden (hierzu Spalte "Gehalt" als 1D-Array extrahieren):
    MsgBox(0, "Gehaltssumme", __Sum(_td_getColumn($mData, "Gehalt")))
    
    
    ; Funktion um Summe eines 1D-Arrays zu berechnen
    Func __Sum($aArray)
    	Local $nResult = 0
    	For $i = 0 To UBound($aArray) - 1
    		$nResult += $aArray[$i]
    	Next
    	Return $nResult
    EndFunc
    
    ; extrahiere mehrere Spalten als 2D-Array
    $aGehaltName = _td_getColumn($mData, "Gehalt;Name")
    _ArrayDisplay($aGehaltName)
    Alles anzeigen


    Oder man verknüpft seine Tabellendaten mit Daten aus anderen Tabellen:

    AutoIt
    #include "TableData.au3"
    
    Global $aPersonen[5][4] = [["Name", "Alter", "Gehalt", "verheiratet"], ["Max", 25, 5000.50, True], ["Anna", 30, 6000.75, False], ["Peter", 35, 7000.25, True], ["Lena", 28, 5500.50, False]]
    Global $aPositionen[5][2] = [["Name", "Position"], ["Max", "Referent"], ["Lena", "Direktor"], ["Peter", "Sachbearbeiter"], ["Anna", "Mitarbeiter"]]
    
    ; Konvertierung in Tabellenobjekte:
    $mPersonen = _td_fromArray($aPersonen, True)
    $mPositionen = _td_fromArray($aPositionen, True)
    
    ; verknüpfe beide Tabellen zu einer gemeinsamen anhand des Attributes "Name"
    $mJoined = _td_join($mPersonen, $mPositionen, "Name")
    
    ; verknüpfte Daten anzeigen
    _td_display($mJoined, "Verknüpfung", True)
    Alles anzeigen


    Das ganze lässt sich dann auch fix in eine CSV-Datei schreiben oder als normales 2D-Array wieder weiterverwenden - ganz wie man möchte.
    So ich denke das war jetzt genug Werbung.

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™