Umlaute in Dateien aus DOS-Befehlen

HansJ54

Nach längerer Suche frage ich doch lieber:

Die Ausgabe von einem DOS-Dir-Befehl in eine Datei macht Probleme mit den Umlauten. Alles Mögliche versucht, um beim Öffnen der Datei mit Excel oder Notepad++ eine korrekte Darstellung zu erhalten sind gescheitert. Wie kann ich entweder die Ausgabe von Dir direkt mit richtigen Umlauten erzeugen oder alternativ wie kann ich eine Datei mit den "falschen" Umlauten "übersetzen"?

Ich habe eine Function von AspirinJunkie gefunden, die das vielleicht kann. Aber die bricht immer ab in der Zeile
$s_Ret = DllCall($h_User32DLL, 'BOOL', 'OemToChar', 'str', $s_Ret, 'str', '')[2] mit

!>14:13:26 AutoIt3.exe ended.rc:-1073741819. Was mache ich falsch?

Code

$s_Cmd = "Dir"
$sParameter = "J:\kunden"
$b_CmdSpec = True
$WorkDir = @WorkingDir
$sResult = RunCmd($s_Cmd, $sParameter , $b_CmdSpec, $WorkDir)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $sResult = ' & $sResult & @CRLF)

; #FUNCTION# ======================================================================================
; Name ..........: RunCmd()
; Description ...: runs commandline programs or cmd-command and return their output
; Syntax ........: RunCmd($s_Cmd, [$sParameter = '', [$b_CmdSpec = False, [$WorkDir = @WorkingDir]]])
; Parameters ....: $s_Cmd        - the command which should be executed (can be full command or without parameters)
;                  $sParameter   - additional parameters for the command (also array of parameters)
;                  $b_CmdSpec    - If true the command is interpreted as a command for cmd.exe
;                  $WorkDir      - the working directory
; Return values .: Success: returns a string with the output
;                  Failure: set @error and returns a debug-string
; Author ........: AspirinJunkie
; =================================================================================================
Func RunCmd($s_Cmd, $sParameter = '', $b_CmdSpec = False, $WorkDir = @WorkingDir)
    Local Static $h_User32DLL = DllOpen('user32.dll')
    If @error Then Return SetError(1, @error, "")
    If $b_CmdSpec Then $s_Cmd = @ComSpec & " /c " & $s_Cmd
    Local $s_Ret, $s_Line, $s_Err
    If $sParameter <> '' Then
        If IsArray($sParameter) Then
            Local $s_Par = ""
            For $j In $sParameter
                $s_Par &= " " & $j
            Next
            $sParameter = $s_Par
        Else
            $sParameter = ' ' & $sParameter
        EndIf
    EndIf
    Local $iPID = Run($s_Cmd & $sParameter, $WorkDir, @SW_HIDE, 0x2 + 0x4)
    If @error Then Return SetError(2, @error, "")
    Do
        Sleep(10)
        $s_Line = StdoutRead($iPID)
        If @extended > 0 Then $s_Ret &= $s_Line
    Until @error
    Do
        Sleep(10)
        $s_Line = StderrRead($iPID)
        If @extended > 0 Then $s_Err &= $s_Line
    Until @error
    $s_Ret = DllCall($h_User32DLL, 'BOOL', 'OemToChar', 'str', $s_Ret, 'str', '')[2]
    If $s_Err <> "" Then
        If $s_Ret <> "" Then Return SetError(3, 0, "------- StdOut -----------" & @CRLF & $s_Ret & @CRLF & @CRLF & "------- StdErr -----------" & @CRLF & $s_Err)
        Return SetError(3, 0, $s_Err)
    EndIf
    Return $s_Ret
EndFunc   ;==>RunCmd

Alles anzeigen

**Schnuffel**

Ist J:\... ein Netzlaufwerk?

verwendest du eine Batch? (.bat oder .com) ?

Wie erstellst du die Batch Datei?

Wenn mit Notepad++, dann die Sprache auf MS-Dos Style ändern und dann erst abspeichern.

In der Batch Datei würde ich folgendes schreiben:

Code

chcp 1252
Dir C:\.... > Ausgabe.txt

~~Bei der Lösung von Aspirinjunkie kann ich mir vorstellen, dass Netzlaufwerke ein Problem darstellen könnten.~~

Das Script läuft auch mit Netzlaufwerken.

Der von dir geschilderte Fehler ist i.d.R. ein "harter" Error eines Dll-Aufrufs, der mit irgendeinem Parameter an die Wand gefahren ist.

ich hab die Funktion von AspirinJunkie mal verschlankt und optimiert.

AutoIt

$s_Cmd = "Dir"
$sParameter = "C:\Users\Oliver"
$b_CmdSpec = True
$WorkDir = @WorkingDir
$sResult = RunCmd($s_Cmd, $sParameter , $b_CmdSpec, $WorkDir)
ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $sResult = ' & $sResult & @CRLF)

; #FUNCTION# ======================================================================================
; Name ..........: RunCmd()
; Description ...: runs commandline programs or cmd-command and return their output
; Syntax ........: RunCmd($s_Cmd, [$sParameter = '', [$b_CmdSpec = False, [$WorkDir = @WorkingDir]]])
; Parameters ....: $s_Cmd        - the command which should be executed (can be full command or without parameters)
;                  $sParameter   - additional parameters for the command (also array of parameters)
;                  $b_CmdSpec    - If true the command is interpreted as a command for cmd.exe
;                  $WorkDir      - the working directory
; Return values .: Success: returns a string with the output
;                  Failure: set @error and returns a debug-string
; Author ........: AspirinJunkie
; =================================================================================================
Func RunCmd($s_Cmd, $sParameter = '', $b_CmdSpec = False, $WorkDir = @WorkingDir)
    Local Static $h_User32DLL = DllOpen('user32.dll')
    If @error Then Return SetError(1, @error, "")
    If $b_CmdSpec Then $s_Cmd = @ComSpec & " /c " & $s_Cmd
    Local $s_Ret, $s_Err
    If $sParameter <> '' Then
        If IsArray($sParameter) Then
            Local $s_Par = ""
            For $j In $sParameter
                $s_Par &= " " & $j
            Next
            $sParameter = $s_Par
        Else
            $sParameter = ' ' & $sParameter
        EndIf
    EndIf
    Local $iPID = Run($s_Cmd & $sParameter, $WorkDir, @SW_HIDE, 0x2 + 0x4)
    If @error Then Return SetError(2, @error, "")
	ProcessWaitClose($iPID)

    $s_Ret = DllCall($h_User32DLL, 'BOOL', 'OemToChar', 'str', StdoutRead($iPID), 'str', '')[2]
	$s_Err = DllCall($h_User32DLL, 'BOOL', 'OemToChar', 'str', StderrRead($iPID), 'str', '')[2]
    If $s_Err <> "" Then
        Return SetError(3, 0, "------- StdOut -----------" & @CRLF & $s_Ret & @CRLF & @CRLF & "------- StdErr -----------" & @CRLF & $s_Err)
    EndIf
    Return $s_Ret
EndFunc   ;==>RunCmd

Alles anzeigen

**AspirinJunkie**

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

**AspirinJunkie**

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

HansJ54

Code

Global $sSubOrdner = "Allgemein", $aSearchDeli= "_", $sFilePath = "J:\Kunden\Error.txt"

$sSearch = @ComSpec & ' /c dir J:\Kunden\*' & $aSubOrdner[$i] & ' /s/b/ad |find "' & $aSearchDeli[$j] & '" >> ' & $sFilePath
$iPID = Run($sSearch, "", @SW_HIDE)
ProcessWaitClose($iPID)

So erzeuge ich die Datei.

HansJ54

Code

Global $aArray = _FileListToArrayRec($sSearchDir, "Allgemein\;Daten\", $FLTAR_FOLDERS, $FLTAR_RECUR, $FLTAR_NOSORT, $FLTAR_RELPATH)

Bin auf diesen Befehl gestoßen, mit dem ich alle Verzeichnisse sammeln will, die unter einem Ordner "Allgemein" oder "Daten" noch Unterverzeichnisse haben. Mit dem \ in der Maske bekomme ich aber @extended = 2 wogegen der Befehl mit "Allgemein;Daten" ohne \ funktioniert, mir dann aber auch zusätzlich alle Verzeichnisse sammelt, die mit ...\Allgemein und ...\Daten enden. Fehler in der Function? Kann man das umgehen?

**Schnuffel**

wenn du 2 bestimmte Ordner rekursive erfassen möchtest, würde ich das so lösen:

AutoIt

Global $sSearchDir = "C:\Windows"
Global $aDir_Allgemein = _FileListToArrayRec($sSearchDir & "\Web", "*", 2, 1)
Global $aDir_Daten = _FileListToArrayRec($sSearchDir & "\Help", "*", 2, 1)
_ArrayConcatenate($aDir_Allgemein, $aDir_Daten, 1)
$aDir_Allgemein[0] = UBound($aDir_Allgemein) - 1
_ArrayDisplay($aDir_Allgemein)

musst halt die Ordner und des $sSearchDir an deine Bedürfnisse abändern

PS: der Parameter $iReturn kann dir auch deine Junktions liefern

+ $FLTAR_NOLINK (16) - Link/junction folders

HansJ54

Danke, aber ich denke ich muss das noch anders lösen. Im Verzeichnis sind mehr als 100.000 Unterverzeichnisse und ich habe 12 Suchbegriffe (nicht nur die beiden). Das dauert wenn ich die alle 12 nacheinander durchgehe ...

Neue Idee: ich sammle sämtliche Ordner ohne Einschränkung in einem Array und laufe dann einmal über das Array und selektiere die gewünschten Ordner dabei.

Noch mal zur Info warum ich das mache:

ich suche immer noch in diesem Riesenverzeichnis die Unterverzeichnisse, die von irgendjemandem mit der Maus ungeschickt in ein anderes Verzeichnis verschoben wurden (habe aus einer Zeit von einem Jahr schon 5-fache Verschachtelungen untereinander gefunden. Wenn in einem Ordnerpfad 2 oder mehr von meinen Suchbegriffen sind, dann ist das einer der Treffer. Oder wenn ein Verzeichnis in der ersten Ebene keine Ordner und Daten hat.

Wenn ich dann noch ohne großen Aufwand zu diesen gefundenen Ordnern den jeweiligen "Besitzer" abfragen und in mein Array bekommen könnte, dann hätte ich auch eine Statistik, wer jeweils der Verursacher war. Hat jemand dazu eine Idee?

Danach muss ich in einem anderen Verzeichnis alle Unterordner finden, in denen eine Junction ist (eine Junction darf nur in der ersten Ebene sein, die besteht nur aus Junctions). Das ist aber nur ein untergeordnetes Problem, die stören nicht wirklich.

AspirinJunkie _prc_RunWithReturn() funktioniert einwandfrei, kann ich an anderer Stelle gut gebrauchen.

**Schnuffel**

hier noch ein Ansatz. Aber bitte erst ausprobieren an einem nicht so großen Verzeichnis...

AutoIt

#include <Array.au3>
#include <File.au3>
Global $sHDD, $sfoldername, $aOutput, $aTemp
$sHDD = "C:\"
$sfoldername = "Users"
RunWait(@ComSpec & " /c " & "dir " & $sHDD & $sfoldername & " /A:D /Q /S /B > output.txt", @DesktopDir, @SW_HIDE)
_FileReadToArray(@DesktopDir & "\output.txt", $aOutput)
;If FileExists(@DesktopDir & "\output.txt") Then FileDelete(@DesktopDir & "\output.txt")

Global $aArray2[$aOutput[0] + 1][5]
$aArray2[0][0] = $aOutput[0]
$aArray2[0][1] = "Owner"
$aArray2[0][2] = "Size"
$aArray2[0][3] = "Files Count"
$aArray2[0][4] = "Dir Count"
For $i = 1 To $aOutput[0]
	$aArray2[$i][0] = $aOutput[$i]
	$aArray2[$i][1] = _GetOwner($aOutput[$i])
	$aTemp = DirGetSize($aOutput[$i], 3)
	If Not @error Then
		$aArray2[$i][2] = $aTemp[0]
		$aArray2[$i][3] = $aTemp[1]
		$aArray2[$i][4] = $aTemp[2]
	EndIf
Next

_ArrayDisplay($aArray2)

Func _GetOwner($sFile_Folder)
	Local $objSD, $oWMIService = ObjGet("winmgmts:")
	Local $oFolderSecuritySettings = $oWMIService.Get("Win32_LogicalFileSecuritySetting='" & $sFile_Folder & "'")
	Local $intRetVal = $oFolderSecuritySettings.GetSecurityDescriptor($objSD)
	If $intRetVal = 0 Then
		Return $objSD.Owner.Domain & "\" & $objSD.Owner.Name
	Else
		Return
	EndIf
EndFunc   ;==>_GetOwner

Alles anzeigen

Das Array sollte alle Ordner rekursiv liefern alphabetisch sortiert, den Besitzer, die Größe (im Moment nicht rekursiv), Anzahl Ordner und Anzahl Dateien.

Wenn die Größe rekursiv ermittelt werden soll, dann in Zeile 19 die 3 mit einer 1 ersetzen

Bei fehlender Leseberechtigung auf einen Ordner bricht das Script bis jetzt ab. Das müsste man sich noch ansehen um das abzufangen.

HansJ54

Klappt perfekt, aber Problem mit Umlauten im Pfad - da muss ich wohl die Function von AspirinJunkie reinmischen!? Oder kann man das nicht direkt innerhalb AutoIt in ein Array einlesen?

HansJ54

Code

Global $aOutput = _FileListToArrayRec($sSearchDir, "*", $FLTAR_FOLDERS, $FLTAR_RECUR, $FLTAR_NOSORT, $FLTAR_FULLPATH)

So klappt es - danke !

Allerdings eliminiere ich im ersten Schritt alle Verzeichnisse, die nicht verschoben sind und beim Rest - ca. 100-300 - hole ich mir den Owner. Wochenende gerettet

HansJ54

4 1/2 Minuten für über 100.000 Verzeichnisse mit _FileListToArrayRec() ohne DOS-Dir. EIn Problem war, dass ArrayAdd() ab über 10.000 Einträgen immer langsamer wurde und endlos dauerte. Daher alles sukzessive in vordefinierte Arrays gespeichert.
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. Wie kann ich die konvertieren?

Kann ich dafür irgendwie $aCall = DllCall("user32.dll", 'BOOL', 'OemToCharA', 'PTR', DllStructGetPtr($tIn), 'PTR', DllStructGetPtr($tOut)) nutzen? Oder kann ich direkt eine passende Codepage irgendwie benutzen?

**AspirinJunkie**

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.

HansJ54

Zuerst noch mal: vielen Dank für Eure Hilfe - zur Information über mich: ich habe im Studium noch mit Lochkarten gearbeitet ...

DOS-Dir: alles was ich über das "schwarze CMD-Fenster" abschicke ist für mich gefühlt noch DOS

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.

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?

BOM (Byte Order Mark - musste ich erst mal googeln): _FileListToArrayRec() passt für _ArrayDisplay() in AutoIt, aber anschließend schreibe ich mit _FileWriteFromArray($sFileNegPath, $aNegative, 1) in eine .csv um mit Excel weiterzuarbeiten. Da sind dann beim Öffnen die Umlaute falsch. Nach dem BOM habe ich mit dem Hexeditor geschaut: kein BOM vorhanden. Jetzt brauche ich noch Hilfe, wie ich ein Array speichern kann mit einem passenden BOM. Bei FileOpen() gibt es den Parameter, bei _FileWriteFromArray() scheinbar nicht. Array in String umwandeln und dann mit FileOpen/FileWrite schreiben oder gibt es eine bessere Lösung?

**AspirinJunkie**

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

HansJ54

Klappt alles perfekt, nochmals vielen Dank!

Bis auf ReDim, da habe ich mich wohl nicht exakt ausgedrückt - in meinem ersten Beispiel wird der alte Inhalt des eindimensionalen Arrays gelöscht. Aber ich habe _ArrayColInsert() gefunden, damit geht es natürlich (vorher vermutlich mal wieder nicht sinnvoll gesucht).

Code

#include <Array.au3>

Global $aArray[4] = [1,3,5,7]
_ArrayDisplay($aArray, "vorher")

Redim $aArray[4][2]
_ArrayDisplay($aArray, "nachher")

Code

#include <Array.au3>

Global $aArray[4] = [1,3,5,7]
_ArrayDisplay($aArray, "vorher")

_ArrayColInsert($aArray,1)
_ArrayDisplay($aArray, "nach ColInsert")

**AspirinJunkie**

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.

HansJ54

Noch was für die Spezialisten: jetzt muss ich noch alle Verzeichnisse suchen, die nicht im Root sind, also irgendwo tiefer, in denen irgendwo _nnnn vorkommt, also ein Unterstrich und 4 Zahlen. Es würde mir aber auch schon reichen, alle _nnn überhaupt zu filtern. Kann man bei _FileListToArrayRec() irgendetwas mit RegEx machen?

**Kanashius**

Bei _FileListToArrayRec nicht, das hat nur die "Mask" und die ist eher eingeschränkt.

Man kann das ganze aber einfach selbst implementieren:

AutoIt

#include <Array.au3>
Local $arFiles = _FileListFilteredToArrayRec("tmpData", "\_\d{4}.*", Default)
_ArrayDisplay($arFiles)

Func _FileListFilteredToArrayRec($sPath, $sRegExpMatch, ByRef $mRes, $bIncludeFolders = True, $bReturnArray=True)
	If $mRes=Default Then
		Local $mData[]
		$mRes = $mData
	EndIf
	Local $hSearch = FileFindFirstFile($sPath&"\*")
	If $hSearch<0 Then return SetError(1, @error, -1)
	Local $sFileName = ""
	While True
		$sFileName = FileFindNextFile($hSearch)
		If @error Then ExitLoop
		If @extended=1 Then
			_FileListFilteredToArrayRec($sPath&"\"&$sFileName, $sRegExpMatch, $mRes, $bIncludeFolders, False)
			If StringRegExp($sFileName, "^"&$sRegExpMatch&"$") and $bIncludeFolders Then MapAppend($mRes, $sFileName)
		Else
			If StringRegExp($sFileName, "^"&$sRegExpMatch&"$") Then MapAppend($mRes, $sFileName)
		EndIf
	WEnd
	If $bReturnArray Then
		Local $arRes[UBound($mRes)]
		Local $arKeys = MapKeys($mRes)
		For $i=0 to UBound($arKeys)-1 step 1
			$arRes[$i] = $mRes[$arKeys[$i]]
		Next
		return $arRes
	EndIf
	return $mRes
EndFunc

Alles anzeigen

**AspirinJunkie**

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.