how to "dir /b /s /on" into an array?

[Javik]

Is there some really simple way to do this that I am not seeing?

Apparently I would need to "dir /b /s /on" into a temporary file, then read the temporary file into an array?

How do I pick a temporary file name that is not already in use by some other program?

[water]

There are a lot of FileListToArray programs available in the Example Scripts forum.

You look for function _TempFile:

Generate a name for a temporary file. The file is guaranteed not to exist yet.

[iamtheky]

[Spiff59]

You don't really need to use an intermediate temp file, nor add a big 400-line+ 8-function UDF.

#include <Array.au3>

Global $sDirectory = @WindowsDir, $sStdOut

$PID = Run(@ComSpec & ' /c DIR "' & $sDirectory & '" /B /S /ON', "", @SW_HIDE, 2) ; 2 = $STDOUT_CHILD
While Not @error
    $sStdOut &= StdoutRead($PID)
WEnd
$aStdOut = StringSplit(StringStripWS($sStdOut, 7), @CRLF)
_ArrayDisplay($aStdOut)

[kylomas]

@spiff59 - one caution, the arraydisplay will stop at appx. 65,500 file names

@javik - you can use spiff59's technique and write an output file. Post #2 shows how to ensure a unique file

kylomas

[Mechaflash]

Utilize post #2 & #3 and you win!

[BrewManNH]

@spiff59 - one caution, the arraydisplay will stop at appx. 65,500 file names

The array display stops at around 65000 items, but the array should still hold them all.

@javik - you can use spiff59's technique and write an output file. Post #2 shows how to ensure a unique file

kylomas

With the code spiff59 posted, there's no need for an output file which I believe the OP was trying to avoid.

[Mechaflash]

Wouldn't spiff59's code be double the work compared to utilizing like a _RecFileListToArray()? If done by spiff's, it will take a process to read the output, then take another process to parse the output into an array as opposed to just parsing the files directly into an array in a single process?

[BrewManNH]

spiff's was an alternate method without using a UDF to do it. It would be much slower, but would still do the job in less code.

[Mechaflash]

Ahh I understand.

Choice 1: Bloat the script size a bit to get much faster results

Choice 2: Slim the script down but get much slower results.

[Spiff59]

I don't know about double the work. I kind of doubt it in that, having spent a lot of time in the 2009 recursive _FileListToArray() rewrite thread, I recall that the DOS method was always far faster than anything done natively in Autoit. It was never considered a viable candidate as it could not chew through foreign (unicode) characters in filenames. The DOS method when also utilizing the /o sort parameter would have to be even faster yet than doing all that within Autoit.

Edit: Guess we need to conduct a speed test...

Edit2: The fastest little 60-line recursive FileListToArray() I know of takes 1.35 seconds to load up those 30k files (with no sort), as opposed to a full 2 seconds for the DOS version. I swear I recall someone presenting a DOS option that smoked all the others as to speed in that 2009 thread, as well as a more recent similar thread.

I'd have to download and run the _RecFileListToArray() and include a sort option to see how they really stack up. I'm guessing they might end up roughtly the same speed?

Edited October 31, 2012 by Spiff59

[BrewManNH]

Edit: Guess we need to conduct a speed test...

Already done

[Spiff59]

Already done

Must have been some of the earlier (slower) variants in the 2009 thread that were outdone by the DOS method...

I do think the DOS method would likely recoup any speed disadvantage if the tests were done with sorting enabled.

Edit: Simply appending an _Arraysort() to the prior test pushes the Autoit method over 5 seconds, compared to 2 for DOS. But the _RecFileListToArray() function does have the sort integrated, so am guessing it would be closer to 2 seconds on my PC.

Edit2: I must be doing something wrong below....

I'm getting the following numbers...

DOS: 2.1 seconds

Discreet recursive FLTA and Arraysort(): 5.2 seconds (1.3 + 3.9)

Recursive FLTA with built-in sort: 28 seconds

expandcollapse popup

#include <Array.au3>
Global $sDirectory = @WindowsDir, $sStdOut
$timer1 = TimerInit()
$PID = Run(@ComSpec & ' /c DIR "' & $sDirectory & '" /B /S ', "", @SW_HIDE, 2) ; 2 = $STDOUT_CHILD
While Not @error
$sStdOut &= StdoutRead($PID)
WEnd
$aStdOut = StringSplit(StringStripWS($sStdOut, 7), @CRLF)
$timer1 = Round(TimerDiff($timer1) / 1000, 2) & ' sec'
_ArrayDisplay($aStdOut, "DOS: " & $timer1)
$timer2 = TimerInit()
$aArray = _FileListToArrayPlus($sDirectory, "*", 0, "", "", 1, True)
$timer2 = Round(TimerDiff($timer2) / 1000, 2) & ' sec'
_ArrayDisplay($aArray, "Presort: " & $timer2)
$timer3 = TimerInit()
_ArraySort($aArray)
$timer3 = Round(TimerDiff($timer3) / 1000, 2) + $timer2 & ' sec'
_ArrayDisplay($aArray, "Postsort: " & $timer3)
$timer4 = TimerInit()
$aArray = _RecFileListToArray($sDirectory, "*", 0, 1, 2, 1)
$timer4 = Round(TimerDiff($timer4) / 1000, 2) & ' sec'
_ArrayDisplay($aArray, "All-in-one: " & $timer4)

;===================================================================================================================================
Func _FileListToArrayPlus($sPath, $sInclude = "", $iFlag = 0, $sExcludeFolder = "", $sExclude = "", $iPathType = 0, $bRecursive = False)
Local $sRet = "", $sReturnFormat = ""
$sPath = StringRegExpReplace($sPath, "[/]+z", "") & "" ; ensure single trailing slash
If Not FileExists($sPath) Then Return SetError(1, 1, "")
; Edit include files list
If $sInclude = "*" Then $sInclude = ""
If $sInclude Then
     If StringRegExp($sInclude, "[/:><|]|(?s)As*z") Then Return SetError(2, 2, "") ; invalid characters test
     $sInclude = StringRegExpReplace(StringRegExpReplace($sInclude, "(s*;s*)+", ";"), "A;|;z", "") ; Strip unwanted whitespace
     $sInclude = StringRegExpReplace($sInclude, "[][$.+^{}()]", "$0"); Ignore special characters
     $sInclude = StringReplace(StringReplace(StringReplace($sInclude, "?", "."), "*", ".*?"), ";", "$|") ; Convert ? to ., * to .*?, and ; to |
     $sInclude = "(?i)A(" & $sInclude & "$)"; case-insensitive, match from first char, terminate strings
EndIf
; Edit exclude folders list
If $sExcludeFolder Then
     $sExcludeFolder = StringRegExpReplace(StringRegExpReplace($sExcludeFolder, "(s*;s*)+", ";"), "A;|;z", "") ; Strip unwanted whitespace
     $sExcludeFolder = StringRegExpReplace($sExcludeFolder, "[][$.+^{}()]", "$0"); Ignore special characters
     $sExcludeFolder = StringReplace(StringReplace(StringReplace($sExcludeFolder, "?", "."), "*", ".*?"), ";", "$|") ; Convert ?=. *=.*? ;=|
     $sExcludeFolder = "(?i)A(?!" & $sExcludeFolder & "$)"; case-insensitive, match from first char, terminate strings
EndIf
; Edit exclude files list
If $sExclude Then
     $sExclude = StringRegExpReplace(StringRegExpReplace($sExclude, "(s*;s*)+", ";"), "A;|;z", "") ; Strip unwanted whitespace
     $sExclude = StringRegExpReplace($sExclude, "[][$.+^{}()]", "$0"); Ignore special characters
     $sExclude = StringReplace(StringReplace(StringReplace($sExclude, "?", "."), "*", ".*?"), ";", "$|") ; Convert ?=. *=.*? ;=|
     $sExclude = "(?i)A(?!" & $sExclude & "$)"; case-insensitive, match from first char, terminate strings
EndIf
; MsgBox(1,"Masks","File include: " & $sInclude & @CRLF & "File exclude: " & $sExclude & @CRLF & "Dir exclude : " & $sExcludeFolder)
If Not ($iFlag = 0 Or $iFlag = 1 Or $iFlag = 2) Then Return SetError(3, 3, "")
Local $sOrigPathLen = StringLen($sPath), $aQueue[64] = [1,$sPath], $iQMax = 63 ; tuned?
While $aQueue[0]
     $WorkFolder = $aQueue[$aQueue[0]]
     $aQueue[0] -= 1
     $search = FileFindFirstFile($WorkFolder & "*")
     If @error Then ContinueLoop
     Switch $iPathType
         Case 1 ; relative path
             $sReturnFormat = StringTrimLeft($WorkFolder, $sOrigPathLen)
         Case 2 ; full path
             $sReturnFormat = $WorkFolder
     EndSwitch
     While 1
         $file = FileFindNextFile($search)
         If @error Then ExitLoop
         If @extended Then ; Folder
             If $sExcludeFolder And Not StringRegExp($file, $sExcludeFolder) Then ContinueLoop ; ?
             If $bRecursive Then
                 If $aQueue[0] = $iQMax Then
                     $iQMax += 128 ; tuned?
                     ReDim $aQueue[$iQMax + 1]
                 EndIf
                 $aQueue[0] += 1
                 $aQueue[$aQueue[0]] = $WorkFolder & $file & ""
             EndIf
             If $iFlag = 1 Then ContinueLoop ; files only
             $sRet &= $sReturnFormat & $file & "|"
         Else ; File
             If $iFlag = 2 Then ContinueLoop ; folders only
If $sInclude And Not StringRegExp($file, $sInclude) Then ContinueLoop ; ?
If $sExclude And Not StringRegExp($file, $sExclude) Then ContinueLoop ; ?
$sRet &= $sReturnFormat & $file & "|"
         EndIf
     WEnd
     FileClose($search)
WEnd
If Not $sRet Then Return SetError(4, 4, "")
Return StringSplit(StringTrimRight($sRet, 1), "|")
EndFunc

; #INDEX# =======================================================================================================================
; Title .........: _RecFileListToArray
; AutoIt Version : v3.3.1.1 or higher
; Language ......: English
; Description ...: Lists files andor folders in specified path with optional recursion to defined level and result sorting
; Note ..........:
; Author(s) .....: Melba23
; Remarks .......: - Modified Array.au3 functions - credit: Jos van der Zande, LazyCoder, Tylo, Ultima, SolidSnake and gcriaco
;                - SRE patterns - credit: various forum members and Spiff59 in particular
;                - DllCall code suggestion - credit: guinness
;                - Despite the name, this UDF is iterative, not recursive
; ===============================================================================================================================
; #CURRENT# =====================================================================================================================
; _RecFileListToArray: Lists files andor folders in a specified path with optional recursion to defined level and result sorting
; ===============================================================================================================================
; #INTERNAL_USE_ONLY#============================================================================================================
; _RFLTA_ListToMask ......; Convert include/exclude lists to SRE format
; _RFLTA_AddToList .......; Add element to list which is resized if necessary
; _RFLTA_AddFileLists ....; Add internal lists after resizing and optional sorting
; _RFLTA_FileListSearch ..; Search file match list for files associated with a folder
; _RFLTA_ArraySort .......; Wrapper for QuickSort function
; _RFLTA_QuickSort .......: Recursive array sort
; _RFLTA_ArrayConcatenate : Join 2 arrays
; ===============================================================================================================================
; #FUNCTION# ====================================================================================================================
; Name...........: _RecFileListToArray
; Description ...: Lists files andor folders in a specified path with optional recursion to defined level and result sorting
; Syntax.........: _RecFileListToArray($sPath[, $sInclude_List = "*"[, $iReturn = 0[, $iRecur = 0[, $iSort = 0[, $iReturnPath = 1[, $sExclude_List = ""[, $sExclude_List_Folder]]]]]]])
; Parameters ....: $sPath - Initial path used to generate filelist. If path ends in  then folders will be returned with an ending 
;                $sInclude_List - Optional: filter for included results (default "*"). Multiple filters must be separated by ";"
;                $iReturn - Optional: specifies whether to return files, folders or both and omits those with certain attributes
;                            0 - Return both files and folders (Default)
;                                If non-recursive Include/Exclude_List applies to files and folders
;                                If recursive Include/Exclude_List applies to files only, all folders are searched unless excluded using $sExclude_List_Folder
;                            1 - Return files only - Include/Exclude_List applies to files only, all folders searched if recursive
;                            2 - Return folders only - Include/Exclude_List applies to folders only for searching and return
;                                Add one or more of the following to $iReturn to omit files/folders with that attribute
;                                + 4 - Hidden files and folders
;                                + 8 - System files and folders
;                                + 16 - Link/junction folders
;                                Note: Uses a different search algorithm and takes approx 50% longer
;                $iRecur - Optional: specifies whether to search recursively in subfolders and to what level
;                            1 - Search in all subfolders (unlimited recursion)
;                            0 - Do not search in subfolders (Default)
;                            Negative integer - Search in subfolders to specified depth
;                $iSort - Optional: sort ordered in alphabetical and depth order
;                            0 - Not sorted (Default)
;                            1 - Sorted
;                            2 - Sorted with faster algorithm (assumes files sorted within each folder - requires NTFS drive)
;                $iReturnPath - Optional: specifies displayed path of results
;                            0 - File/folder name only
;                            1 - Relative to initial path (Default)
;                            2 - Full path included
;                $sExclude_List - Optional: filter for excluded results (default ""). Multiple filters must be separated by ";"
;                $sExclude_List_Folder - Optional: only used if $iReturn = 0 AND $iRecur = 1 to exclude folders matching the filter
; Requirement(s).: v3.3.1.1 or higher
; Return values .: Success: One-dimensional array made up as follows:
;                        [0] = Number of FilesFolders returned
;                        [1] = 1st FileFolder
;                        [2] = 2nd FileFolder
;                        ...
;                        [n] = nth FileFolder
;                Failure: Null string and @error = 1 with @extended set as follows:
;                        1 = Path not found or invalid
;                        2 = Invalid $sInclude_List
;                        3 = Invalid $iReturn
;                        4 = Invalid $iRecur
;                        5 = Invalid $iSort
;                        6 = Invalid $iReturnPath
;                        7 = Invalid $sExclude_List
;                        8 = Invalid $sExclude_List_Folder
;                        9 = No files/folders found
; Author ........: Melba23
; Remarks .......: Compatible with existing _FileListToArray syntax
; Related .......:
; Link ..........;
; Example .......; Yes
; ===============================================================================================================================
Func _RecFileListToArray($sInitialPath, $sInclude_List = "*", $iReturn = 0, $iRecur = 0, $iSort = 0, $iReturnPath = 1, $sExclude_List = "", $sExclude_List_Folder = "")
Local $asReturnList[100] = [0], $asFileMatchList[100] = [0], $asRootFileMatchList[100] = [0], $asFolderMatchList[100] = [0], $asFolderSearchList[100] = [1]
Local $sFolderSlash = "", $iMaxLevel, $sInclude_File_Mask, $sExclude_File_Mask, $sInclude_Folder_Mask = ".+", $sExclude_Folder_Mask = ":"
Local $hSearch, $fFolder, $sRetPath = "", $sCurrentPath, $sName, $iAttribs, $iHide_HS = 0, $iHide_Link = 0
Local $asFolderFileSectionList[100][2] = [[0, 0]], $sFolderToFind, $iFileSectionStartIndex, $iFileSectionEndIndex
; Check for valid path
If Not FileExists($sInitialPath) Then Return SetError(1, 1, "")
; Check if folders should have trailing  and ensure that initial path does have one
If StringRight($sInitialPath, 1) = "" Then
     $sFolderSlash = ""
Else
     $sInitialPath = $sInitialPath & ""
EndIf
; Add path to folder search list
$asFolderSearchList[1] = $sInitialPath
; Check for H or S omitted
If BitAnd($iReturn, 4) Then
     $iHide_HS += 2
     $iReturn -= 4
EndIf
If BitAnd($iReturn, 8) Then
     $iHide_HS += 4
     $iReturn -= 8
EndIf
; Check for link/junction omitted
If BitAnd($iReturn, 16) Then
     $iHide_HS = 0x406
     $iReturn -= 16
EndIf
; Check for valid recur value
If $iRecur > 1 Or Not IsInt($iRecur) Then Return SetError(1, 4, "")
; If required, determine  count for max recursive level setting
If $iRecur < 0 Then
     StringReplace($sInitialPath, "", "", 2)
     $iMaxLevel = @extended - $iRecur
EndIf
; Create Include mask for files
If $sInclude_List = "*" Then
     $sInclude_File_Mask = ".+"
Else
     If Not _RFLTA_ListToMask($sInclude_File_Mask, $sInclude_List) Then Return SetError(1, 2, "")
EndIf
; Set Include mask for folders
Switch $iReturn
     Case 0
         ; Folders affected by mask if not recursive
         Switch $iRecur
             Case 0
                 ; Folders match mask for compatibility
                 $sInclude_Folder_Mask = $sInclude_File_Mask
             ;Case Else
                 ; All folders match
         EndSwitch
     ;Case 1
         ; All folders match
     Case 2
         ; Folders affected by mask
         $sInclude_Folder_Mask = $sInclude_File_Mask
EndSwitch
; Create Exclude List mask for files
If $sExclude_List = "" Then
     $sExclude_File_Mask = ":" ; Set unmatchable mask
Else
     If Not _RFLTA_ListToMask($sExclude_File_Mask, $sExclude_List) Then Return SetError(1, 7, "")
EndIf
; Set Exclude mask for folders
Switch $iReturn
     Case 0
         ; Folders affected by mask if not recursive
         Switch $iRecur
             Case 0
                 ; Folders match mask for compatibility
                 $sExclude_Folder_Mask = $sExclude_File_Mask
             Case Else
                 ; Exclude defined folders as set in extended
                 If $sExclude_List_Folder <> "" Then
                     If Not _RFLTA_ListToMask($sExclude_Folder_Mask, $sExclude_List_Folder) Then Return SetError(1, 8, "")
                 EndIf
         EndSwitch
     ;Case 1
         ; All folders match
     Case 2
         ; Folders affected by normal mask
         $sExclude_Folder_Mask = $sExclude_File_Mask
EndSwitch
; Verify other parameters
If Not ($iReturn = 0 Or $iReturn = 1 Or $iReturn = 2) Then Return SetError(1, 3, "")
If Not ($iSort = 0 Or $iSort = 1 Or $iSort = 2) Then Return SetError(1, 5, "")
If Not ($iReturnPath = 0 Or $iReturnPath = 1 Or $iReturnPath = 2) Then Return SetError(1, 6, "")
; Prepare for DllCall if required
If $iHide_HS Or $iHide_Link Then
     Local $tFile_Data = DllStructCreate("struct;align 4;dword FileAttributes;uint64 CreationTime;uint64 LastAccessTime;uint64 LastWriteTime;" & _
                         "dword FileSizeHigh;dword FileSizeLow;dword Reserved0;dword Reserved1;wchar FileName[260];wchar AlternateFileName[14];endstruct")
     Local $pFile_Data = DllStructGetPtr($tFile_Data), $hDLL = DllOpen('kernel32.dll'), $aDLL_Ret
EndIf
; Search within listed folders
While $asFolderSearchList[0] > 0
     ; Set path to search
     $sCurrentPath = $asFolderSearchList[$asFolderSearchList[0]]
     ; Reduce folder search list count
     $asFolderSearchList[0] -= 1
     ; Determine return path to add to file/folder name
     Switch $iReturnPath
         ; Case 0 ; Name only
             ; Leave as ""
         Case 1 ;Relative to initial path
             $sRetPath = StringReplace($sCurrentPath, $sInitialPath, "")
         Case 2 ; Full path
             $sRetPath = $sCurrentPath
     EndSwitch
     ; Get search handle - use code matched to required listing
     If $iHide_HS Or $iHide_Link Then
         ; Use DLL code
         $aDLL_Ret = DllCall($hDLL, 'ptr', 'FindFirstFileW', 'wstr', $sCurrentPath & "*", 'ptr', $pFile_Data)
         If @error Or Not $aDLL_Ret[0] Then
             ContinueLoop
         EndIf
         $hSearch = $aDLL_Ret[0]
     Else
         ; Use native code
         $hSearch = FileFindFirstFile($sCurrentPath & "*")
         ; If folder empty move to next in list
         If $hSearch = -1 Then
             ContinueLoop
         EndIf
     EndIf
     ; If sorting files and folders with paths then store folder name and position of associated files in list
     If $iReturn = 0 And $iSort And $iReturnPath Then
         _RFLTA_AddToList($asFolderFileSectionList, $sRetPath, $asFileMatchList[0] + 1)
     EndIf
     ; Search folder - use code matched to required listing
     While 1
         ; Use DLL code
         If $iHide_HS Or $iHide_Link Then
             ; Use DLL code
             $aDLL_Ret = DllCall($hDLL, 'int', 'FindNextFileW', 'ptr', $hSearch, 'ptr', $pFile_Data)
             ; Check for end of folder
             If @error Or Not $aDLL_Ret[0] Then
                 ExitLoop
             EndIf
             ; Extract data
             $sName = DllStructGetData($tFile_Data, "FileName")
             ; Check for .. return - only returned by the DllCall
             If $sName = ".." Then
                 ContinueLoop
             EndIf
             $iAttribs = DllStructGetData($tFile_Data, "FileAttributes")
             ; Check for hidden/system attributes and skip if found
             If $iHide_HS And BitAnd($iAttribs, $iHide_HS) Then
                 ContinueLoop
             EndIf
             ; Check for link attribute and skip if found
             If $iHide_Link And BitAnd($iAttribs, $iHide_Link) Then
                 ContinueLoop
             EndIf
             ; Set subfolder flag
             $fFolder = 0
             If BitAnd($iAttribs, 16) Then
                 $fFolder = 1
             EndIf
         Else
             ; Use native code
             $sName = FileFindNextFile($hSearch)
             ; Check for end of folder
             If @error Then
                 ExitLoop
             EndIf
             ; Set subfolder flag - @extended set in 3.3.1.1 +
             $fFolder = @extended
         EndIf
         ; If folder then check whether to add to search list
         If $fFolder Then
             Select
                 Case $iRecur < 0 ; Check recur depth
                     StringReplace($sCurrentPath, "", "", 0, 2)
                     If @extended < $iMaxLevel Then
                         ContinueCase ; Check if matched to masks
                     EndIf
                 Case $iRecur = 1 ; Full recur
                     If Not StringRegExp($sName, $sExclude_Folder_Mask) Then ; Add folder unless excluded
                         _RFLTA_AddToList($asFolderSearchList, $sCurrentPath & $sName & "")
                     EndIf
                 ; Case $iRecur = 0 ; Never add
                     ; Do nothing
             EndSelect
         EndIf
         If $iSort Then ; Save in relevant folders for later sorting
             If $fFolder Then
                 If StringRegExp($sName, $sInclude_Folder_Mask) And Not StringRegExp($sName, $sExclude_Folder_Mask) Then
                     _RFLTA_AddToList($asFolderMatchList, $sRetPath & $sName & $sFolderSlash)
                 EndIf
             Else
                 If StringRegExp($sName, $sInclude_File_Mask) And Not StringRegExp($sName, $sExclude_File_Mask) Then
                     ; Select required list for files
                     If $sCurrentPath = $sInitialPath Then
                         _RFLTA_AddToList($asRootFileMatchList, $sRetPath & $sName)
                     Else
                         _RFLTA_AddToList($asFileMatchList, $sRetPath & $sName)
                     EndIf
                 EndIf
             EndIf
         Else ; Save directly in return list
             If $fFolder Then
                 If $iReturn <> 1 And StringRegExp($sName, $sInclude_Folder_Mask) And Not StringRegExp($sName, $sExclude_Folder_Mask) Then
                     _RFLTA_AddToList($asReturnList, $sRetPath & $sName & $sFolderSlash)
                 EndIf
             Else
                 If $iReturn <> 2 And StringRegExp($sName, $sInclude_File_Mask) And Not StringRegExp($sName, $sExclude_File_Mask) Then
                     _RFLTA_AddToList($asReturnList, $sRetPath & $sName)
                 EndIf
             EndIf
         EndIf
     WEnd
     ; Close current search
     FileClose($hSearch)
WEnd
; Close the DLL if needed
If $iHide_HS Then
     DllClose($hDLL)
EndIf
If $iSort Then
     ; Check if any file/folders have been added depending on required return
     Switch $iReturn
         Case 0 ; If no folders then number of files is immaterial
             If $asRootFileMatchList[0] = 0 And $asFolderMatchList[0] = 0 Then Return SetError(1, 9, "")
         Case 1
             If $asRootFileMatchList[0] = 0 And $asFileMatchList[0] = 0 Then Return SetError(1, 9, "")
         Case 2
             If $asFolderMatchList[0] = 0 Then Return SetError(1, 9, "")
     EndSwitch
     Switch $iReturn
         Case 2 ; Folders only
             ; Correctly size folder match list
             ReDim $asFolderMatchList[$asFolderMatchList[0] + 1]
             ; Copy size folder match array
             $asReturnList = $asFolderMatchList
             ; Simple sort list
             _RFLTA_ArraySort($asReturnList)
         Case 1 ; Files only
             If $iReturnPath = 0 Then ; names only so simple sort suffices
                 ; Combine file match lists
                 _RFLTA_AddFileLists($asReturnList, $asRootFileMatchList, $asFileMatchList)
                 ; Simple sort combined file list
                 _RFLTA_ArraySort($asReturnList)
             Else
                 ; Combine sorted file match lists
                 _RFLTA_AddFileLists($asReturnList, $asRootFileMatchList, $asFileMatchList, 1)
             EndIf
         Case 0 ; Both files and folders
             If $iReturnPath = 0 Then ; names only so simple sort suffices
                 ; Combine file match lists
                 _RFLTA_AddFileLists($asReturnList, $asRootFileMatchList, $asFileMatchList)
                 ; Set correct count for folder add
                 $asReturnList[0] += $asFolderMatchList[0]
                 ; Resize and add file match array
                 ReDim $asFolderMatchList[$asFolderMatchList[0] + 1]
                 _RFLTA_ArrayConcatenate($asReturnList, $asFolderMatchList)
                 ; Simple sort final list
                 _RFLTA_ArraySort($asReturnList)
             Else
                 ; Size return list
                 Local $asReturnList[$asFileMatchList[0] + $asRootFileMatchList[0] + $asFolderMatchList[0] + 1]
                 $asReturnList[0] = $asFileMatchList[0] + $asRootFileMatchList[0] + $asFolderMatchList[0]
                 ; Sort root file list
                 _RFLTA_ArraySort($asRootFileMatchList, 1, $asRootFileMatchList[0])
                 ; Add the sorted root files at the top
                 For $i = 1 To $asRootFileMatchList[0]
                     $asReturnList[$i] = $asRootFileMatchList[$i]
                 Next
                 ; Set next insertion index
                 Local $iNextInsertionIndex = $asRootFileMatchList[0] + 1
                 ; Sort folder list
                 _RFLTA_ArraySort($asFolderMatchList, 1, $asFolderMatchList[0])
                 ; Work through folder list
                 For $i = 1 To $asFolderMatchList[0]
                     ; Format folder name for search
                     If $sFolderSlash Then
                         $sFolderToFind = $asFolderMatchList[$i]
                     Else
                         $sFolderToFind = $asFolderMatchList[$i] & ""
                     EndIf
                     ; Find folder in FolderFileSectionList
                     For $j = 1 To $asFolderFileSectionList[0][0]
                         If $sFolderToFind = $asFolderFileSectionList[$j][0] Then ExitLoop
                     Next
                     ; Set file list indexes
                     $iFileSectionStartIndex = $asFolderFileSectionList[$j][1]
                     If $j = $asFolderFileSectionList[0][0] Then
                         $iFileSectionEndIndex = $asFileMatchList[0]
                     Else
                         $iFileSectionEndIndex = $asFolderFileSectionList[$j + 1][1] - 1
                     EndIf
                     ; Sort files if required
                     ;If $iSort = 1 Then
                         _RFLTA_ArraySort($asFileMatchList, $iFileSectionStartIndex, $iFileSectionEndIndex)
                     ;EndIf
                     ; Add folder to return list
                     $asReturnList[$iNextInsertionIndex] = $asFolderMatchList[$i]
                     $iNextInsertionIndex += 1
                     ; Add files to return list
                     For $j = $iFileSectionStartIndex To $iFileSectionEndIndex
                         $asReturnList[$iNextInsertionIndex] = $asFileMatchList[$j]
                         $iNextInsertionIndex += 1
                     Next
                 Next
             EndIf
     EndSwitch
Else ; No sort
     ; Check if any file/folders have been added
     If $asReturnList[0] = 0 Then Return SetError(1, 9, "")
     ; Remove any unused return list elements from last ReDim
     ReDim $asReturnList[$asReturnList[0] + 1]
EndIf
Return $asReturnList

EndFunc ;==>_RecFileListToArray
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _RFLTA_ListToMask
; Description ...: Convert include/exclude lists to SRE format
; Syntax ........: _RFLTA_ListToMask(ByRef $sMask, $sList)
; Parameters ....: $asMask - Include/Exclude mask to create
;                $asList - Include/Exclude list to convert
; Return values .: Success: 1
;                Failure: 0
; Author ........: SRE patterns developed from those posted by various forum members and Spiff59 in particular
; Remarks .......: This function is used internally by _RecFileListToArray
; ===============================================================================================================================
Func _RFLTA_ListToMask(ByRef $sMask, $sList)
; Check for invalid characters within list
If StringRegExp($sList, "|/|:|<|>||") Then Return 0
; Strip WS and insert | for ;
$sList = StringReplace(StringStripWS(StringRegExpReplace($sList, "s*;s*", ";"), 3), ";", "|")
; Convert to SRE pattern
$sList = StringReplace(StringReplace(StringRegExpReplace($sList, "[][$^.{}()+-]", "$0"), "?", "."), "*", ".*?")
; Add prefix and suffix
$sMask = "(?i)^(" & $sList & ")z"
Return 1
EndFunc ;==>_RFLTA_ListToMask
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _RFLTA_AddToList
; Description ...: Add element to [?] or [?][2] list which is resized if necessary
; Syntax ........: _RFLTA_AddToList(ByRef $asList, $vValue_0, [$vValue_1])
; Parameters ....: $aList - List to be added to
;                $vValue_0 - Value to add (to [0] element in [?][2] array if $vValue_1 exists)
;                $vValue_1 - Value to add to [1] element in [?][2] array (optional)
; Return values .: None - array modified ByRef
; Author ........: Melba23
; Remarks .......: This function is used internally by _RecFileListToArray
; ===============================================================================================================================
Func _RFLTA_AddToList(ByRef $aList, $vValue_0, $vValue_1 = -1)
If $vValue_1 = -1 Then ; [?] array
     ; Increase list count
     $aList[0] += 1
     ; Double list size if too small (fewer ReDim needed)
     If UBound($aList) <= $aList[0] Then ReDim $aList[UBound($aList) * 2]
     ; Add value
     $aList[$aList[0]] = $vValue_0
Else ; [?][2] array
     $aList[0][0] += 1
     If UBound($aList) <= $aList[0][0] Then ReDim $aList[UBound($aList) * 2][2]
     $aList[$aList[0][0]][0] = $vValue_0
     $aList[$aList[0][0]][1] = $vValue_1
EndIf
EndFunc ;==>_RFLTA_AddToList
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _RFLTA_AddFileLists
; Description ...: Add internal lists after resizing and optional sorting
; Syntax ........: _RFLTA_AddFileLists(ByRef $asTarget, $asSource_1, $asSource_2[, $iSort = 0])
; Parameters ....: $asReturnList - Base list
;                $asRootFileMatchList - First list to add
;                $asFileMatchList - Second list to add
;                $iSort - (Optional) Whether to sort lists before adding
;                |$iSort = 0 (Default) No sort
;                |$iSort = 1 Sort in descending alphabetical order
; Return values .: None - array modified ByRef
; Author ........: Melba23
; Remarks .......: This function is used internally by _RecFileListToArray
; ===============================================================================================================================
Func _RFLTA_AddFileLists(ByRef $asTarget, $asSource_1, $asSource_2, $iSort = 0)
; Correctly size root file match array
ReDim $asSource_1[$asSource_1[0] + 1]
; Simple sort root file match array if required
If $iSort = 1 Then _RFLTA_ArraySort($asSource_1)
; Copy root file match array
$asTarget = $asSource_1
; Add file match count
$asTarget[0] += $asSource_2[0]
; Correctly size file match array
ReDim $asSource_2[$asSource_2[0] + 1]
; Simple sort file match array if required
If $iSort = 1 Then _RFLTA_ArraySort($asSource_2)
; Add file match array
_RFLTA_ArrayConcatenate($asTarget, $asSource_2)
EndFunc ;==>_RFLTA_AddFileLists
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _RFLTA_FileListSearch
; Description ...: Search file array for beginning and end indices of folder associated files
; Syntax ........: _RFLTA_FileListSearch(Const ByRef $avArray, $vValue)
; Parameters ....: $avArray - Array to search ($asFileMatchList)
;                $vValue - Value to search for (Folder name from $asFolderMatchList)
;                $iIndex - Index to begin search (search down from here - and then from here to top if not found)
;                $sSlash -  if folder names end in  - else empty string
; Return values .: Success: Array holding top and bottom indices of folder associated files
;                Failure: Returns -1
; Author ........: Melba23
; Modified.......:
; Remarks .......: This function is used internally by _RecFileListToArray
; ===============================================================================================================================
Func _RFLTA_FileListSearch(Const ByRef $avArray, $vValue, $iIndex, $sSlash)
Local $aRet[2]
; Add final  if required
If Not $sSlash Then $vValue &= ""
; Start by getting top match - search down from start index
For $i = $iIndex To $avArray[0]
     ; SRE gives path less filename
     If StringRegExpReplace($avArray[$i], "(^.*)(.*)", "1") = $vValue Then ExitLoop
Next
If $i > $avArray[0] Then
     ; No match found so look from start index upwards
     If $iIndex = $avArray[0] Then $iIndex -= 1
     For $i = $iIndex + 1 To 1 Step -1
         If StringRegExpReplace($avArray[$i], "(^.*)(.*)", "1") = $vValue Then ExitLoop
     Next
     ; If still no match - return " nothing found" for empty folder
     If $i = 0 Then Return SetError(1, 0, "")
     ; Set index of bottom file
     $aRet[1] = $i
     ; Now look for top match
     For $i = $aRet[1] To 1 Step -1
         If StringRegExpReplace($avArray[$i], "(^.*)(.*)", "1") <> $vValue Then ExitLoop
     Next
     ; Set top match
     $aRet[0] = $i + 1
Else
     ; Set index of top associated file
     $aRet[0] = $i
     ; Now look for bottom match - find first file which does not match
     For $i = $aRet[0] To $avArray[0]
         If StringRegExpReplace($avArray[$i], "(^.*)(.*)", "1") <> $vValue Then ExitLoop
     Next
     ; Set bottom match
     $aRet[1] = $i - 1
EndIf
Return $aRet
EndFunc ;==>_RFLTA_FileListSearch
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _RFLTA_ArraySort
; Description ...: Wrapper for QuickSort function
; Syntax ........: _RFLTA_ArraySort(ByRef $avArray)
; Parameters ....: $avArray - Array to sort
;                $iStart - Index to start sort
;                $iEnd - Index to end sort
; Return values .: None - array modified ByRef
; Author ........: Jos van der Zande, LazyCoder, Tylo, Ultima
; Modified.......: Melba23
; Remarks .......: This function is used internally by _RecFileListToArray
; ===============================================================================================================================
Func _RFLTA_ArraySort(ByRef $avArray, $iStart = 1, $iEnd = -99)
If $iEnd = -99 Then $iEnd = UBound($avArray) - 1
_RFLTA_QuickSort($avArray, $iStart, $iEnd)
EndFunc ;==>_RFLTA_ArraySort
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _RFLTA_QuickSort
; Description ...: Recursive array sort
; Syntax ........: _RFLTA_QuickSort(ByRef $avArray, ByRef $iStart, ByRef $iEnd)
; Parameters ....: $avArray - Array to sort in descending alphabetical order
;                $iStart - Start index
;                $iEnd - End index
; Return values .: None - array modified ByRef
; Author ........: Jos van der Zande, LazyCoder, Tylo, Ultima
; Modified.......: Melba23
; Remarks .......: This function is used internally by _RFLTA_ArraySort
; ===============================================================================================================================
Func _RFLTA_QuickSort(ByRef $avArray, ByRef $iStart, ByRef $iEnd)
Local $vTmp
If ($iEnd - $iStart) < 15 Then
     Local $i, $j, $vCur
     For $i = $iStart + 1 To $iEnd
         $vTmp = $avArray[$i]
         If IsNumber($vTmp) Then
             For $j = $i - 1 To $iStart Step -1
                 $vCur = $avArray[$j]
                 If ($vTmp >= $vCur And IsNumber($vCur)) Or (Not IsNumber($vCur) And StringCompare($vTmp, $vCur) >= 0) Then ExitLoop
                 $avArray[$j + 1] = $vCur
             Next
         Else
             For $j = $i - 1 To $iStart Step -1
                 If (StringCompare($vTmp, $avArray[$j]) >= 0) Then ExitLoop
                 $avArray[$j + 1] = $avArray[$j]
             Next
         EndIf
         $avArray[$j + 1] = $vTmp
     Next
     Return
EndIf
Local $L = $iStart, $R = $iEnd, $vPivot = $avArray[Int(($iStart + $iEnd) / 2)], $fNum = IsNumber($vPivot)
Do
     If $fNum Then
         While ($avArray[$L] < $vPivot And IsNumber($avArray[$L])) Or (Not IsNumber($avArray[$L]) And StringCompare($avArray[$L], $vPivot) < 0)
             $L += 1
         WEnd
         While ($avArray[$R] > $vPivot And IsNumber($avArray[$R])) Or (Not IsNumber($avArray[$R]) And StringCompare($avArray[$R], $vPivot) > 0)
             $R -= 1
         WEnd
     Else
         While (StringCompare($avArray[$L], $vPivot) < 0)
             $L += 1
         WEnd
         While (StringCompare($avArray[$R], $vPivot) > 0)
             $R -= 1
         WEnd
     EndIf
     If $L <= $R Then
         $vTmp = $avArray[$L]
         $avArray[$L] = $avArray[$R]
         $avArray[$R] = $vTmp
         $L += 1
         $R -= 1
     EndIf
Until $L > $R
_RFLTA_QuickSort($avArray, $iStart, $R)
_RFLTA_QuickSort($avArray, $L, $iEnd)
EndFunc ;==>_RFLTA_QuickSort
; #INTERNAL_USE_ONLY#============================================================================================================
; Name...........: _RFLTA_ArrayConcatenate
; Description ...: Joins 2 arrays
; Syntax ........: _RFLTA_ArrayConcatenate(ByRef $avArrayTarget, Const ByRef $avArraySource)
; Parameters ....: $avArrayTarget - Base array
;                $avArraySource - Array to add from element 1 onwards
; Return values .: None - array modified ByRef
; Author ........: Ultima
; Modified.......: Melba23
; Remarks .......: This function is used internally by _RecFileListToArray
; ===============================================================================================================================
Func _RFLTA_ArrayConcatenate(ByRef $avArrayTarget, Const ByRef $avArraySource)
Local $iUBoundTarget = UBound($avArrayTarget) - 1, $iUBoundSource = UBound($avArraySource)
ReDim $avArrayTarget[$iUBoundTarget + $iUBoundSource]
For $i = 1 To $iUBoundSource - 1
     $avArrayTarget[$iUBoundTarget + $i] = $avArraySource[$i]
Next
EndFunc ;==>_RFLTA_ArrayConcatenate

It appears the DOS method is both way smaller, and way faster.

Edited November 1, 2012 by Spiff59

[kylomas]

@BrewmanNH

The array display stops at around 65000 items, but the array should still hold them all.

Of course!

With the code spiff59 posted, there's no need for an output file which I believe the OP was trying to avoid.

The OP does NOT make clear what he wants to do.

I aggree that using a UDF would be simpler given the OP's relative inexperience, but he already started down the path of using a DOS command. There may be some, as yet, undisclosed reason for this.

kylomas

Edited October 31, 2012 by kylomas

[Javik]

Oh, well thanks for the really active discussion. Wasn't expecting more than one reply, if that.

I want to "unravel" a bunch of directories that contain one or two photos, because it is easier to look through the Windows thumbnail preview of hundreds of photos all in one huge folder, than digging through fifty folders each containing one or two photos.

Folder to unravel: PhotoCollectionFlickr

Input:

PhotoCollectionFlickrSomebodyDating343742874273.jpg

PhotoCollectionFlickrSomebodyHoneymoon4574388457845.jpg

PhotoCollectionFlickrSomebodyWedding534624575743346.jpg

PhotoCollectionFlickrSomebodyWedding56798689353w254.jpg

(The output of "/b /s /on" looks exactly like this, so can do the work by scanning for slashes.)

Output:

PhotoCollectionFlickrSomebody - Dating - 343742874273.jpg

PhotoCollectionFlickrSomebody - Honeymoon - 4574388457845.jpg

PhotoCollectionFlickrSomebody - Wedding - 534624575743346.jpg

PhotoCollectionFlickrSomebody - Wedding - 56798689353w254.jpg

[Javik]

Test code for this without file operations:

$Sourcepath = "C:images"
$Imagepath = "C:imageslolcatsinvisible-itemsandwich.jpg"

$SourcePath_Len = StringLen ($SourcePath)
$Unravel_name = StringRight ($Imagepath, StringLen($Imagepath) -$SourcePath_Len)
ConsoleWrite("Original: " & $Unravel_name & @CRLF)
$Unravel_name_noslash = StringReplace($Unravel_name,""," - ")
ConsoleWrite("Rename to: " & $Unravel_name_noslash & @CRLF)

$TargetImage_len = StringInStr($Imagepath,"",2,-1)
$TargetImage = stringright($Imagepath, stringlen($imagepath) - $TargetImage_len)
ConsoleWrite("Target image: " & $TargetImage & @CRLF)

$TargetPath = stringleft($Imagepath, $TargetImage_len)
ConsoleWrite("Path to target: " & $TargetPath & @CRLF & @CRLF)

ConsoleWrite("Operations:" & @CRLF)
ConsoleWrite("1. Rename '" & $TargetImage & "' in '" & $Targetpath & "'" & @CRLF)
ConsoleWrite(" to '" & $Unravel_name_noslash & "'" & @CRLF)
ConsoleWrite("2. Move '" & $Unravel_name_noslash & "' in '" & $Targetpath & "'" & @CRLF)
ConsoleWrite(" to '" & $Sourcepath & "'" & @CRLF)

Results:

Original: lolcatsinvisible-itemsandwich.jpg

Rename to: lolcats - invisible-item - sandwich.jpg

Target image: sandwich.jpg

Path to target: C:imageslolcatsinvisible-item

Operations:

1. Rename 'sandwich.jpg' in 'C:imageslolcatsinvisible-item'

to 'lolcats - invisible-item - sandwich.jpg'

2. Move 'lolcats - invisible-item - sandwich.jpg' in 'C:imageslolcatsinvisible-item'

to 'C:images'

[Melba23]

Javik,

As suggested, my RecFileListToArray UDF will list all the files in all the folders under the base path into an array. You can then very easily rename and move each file as you wish.

This code does what you requested perfectly when I tested it:

#include <RecFileListToArray.au3>

$sPath = "C:Images"

$aList = _RecFileListToArray($sPath, "*.jpg", 1, 1)

For $i = 1 To $aList[0]
    ; Rename and move each file
    FileMove($sPath & "" & $aList[$i], $sPath & "" & StringReplace($aList[$i], "", " - "))
        ;         current path and name     same path......but name changed  
Next

I hope that helps.

M23

Edit: Having now seen Spiff59's earlier comment about adding "a big 400-line+ 8-function UDF" can I just point out that you only need add that single #include line to your script and that the compiled script size is only increased by about 4.5k when you do so. As even the smallest Autoit script when compiled and compressed comes out at about 350k, I do not see this as a major problem.

Edited November 2, 2012 by Melba23

[Spiff59]

This code does what you requested perfectly when I tested it:

Well, actually the OP had requested a DOS solution.

But there is always another way to accomplish something with 4000% more code and in 1400% more time.

[AZJIO]

Spiff59

Supports Unicode : Run(@ComSpec & ' /U /C DIR

The problem with the mask, which does not correspond to the normal view. You can expect the results do not match what you have ordered..