Walk a directory/Non-recursively: Difference between revisions
Walk a directory/Non-recursively (view source)
Revision as of 11:31, 16 February 2024
, 3 months ago→{{header|Wren}}: Minor tidy
(Added BaCon code.) |
m (→{{header|Wren}}: Minor tidy) |
||
(28 intermediate revisions by 24 users not shown) | |||
Line 15:
* [[Walk Directory Tree]] (read entire directory tree).
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">L(filename) fs:list_dir(‘/foo/bar’)
I filename.ends_with(‘.mp3’)
print(filename)</syntaxhighlight>
=={{header|68000 Assembly}}==
Non-recursive directory walk in Motorola 68000 assembly language under AmigaOs 2.04+ by Thorham. Uses regular Amiga dos pattern matching.
<
; Non-recursive directory walk for Motorola 68000 under AmigaOs 2.04+ by Thorham
;
Line 196 ⟶ 203:
patternParsed
dcb.b sizeof_patternString*2+2</
=={{header|8080 Assembly}}==
This program runs under CP/M, which was the commonly used OS on 8080 (and Z80)-based
machines. The pattern used is the CP/M file pattern, which is the same as a DOS pattern:
the filename, the extension, and an optional drive letter.
<syntaxhighlight lang="text">exit: equ 0 ; CP/M syscall to exit
puts: equ 9 ; CP/M syscall to print a string
sfirst: equ 17 ; 'Find First' CP/M syscall
snext: equ 18 ; 'Find Next' CP/M syscall
FCB: equ 5Ch ; Location of FCB for file given on command line
org 100h
lxi d,FCB ; CP/M parses the command line for us automatically
mvi c,sfirst; and prepares an FCB which we can pass to SFIRST
call 5 ; immediately.
lxi d,emsg ; If SFIRST returns an error, there is no file,
mvi c,puts ; so we should print an error message.
loop: inr a ; A=FF = error
jz 5
dcr a ; If we _do_ have a file, the directory entry
rrc ; is located at DTA (80h) + A * 32. 0<=A<=3.
rrc ; Rotate right twice, moving low bits into high bits,
stc ; then finally rotate a 1 bit into the top bit.
rar ; The effect is 000000AB -> 1AB00000.
inr a ; Finally the filename is at offset 1 in the dirent.
mvi h,0 ; Set HL = pointer to the filename
mov l,a
lxi d,fname ; The filename is stored as 'FILENAMEEXT', but let's
mvi b,8 ; be nice and print 'FILENAME.EXT\r\n'.
call memcpy ; Copy filename (wihtout extension) into placeholder
inx d ; Skip the '.' in the placeholder
mvi b,3 ; Then copy the extension
call memcpy
lxi d,fname ; Then print the formatted filename
mvi c,puts
call 5
lxi d,FCB ; Find the next file matching the pattern in the FCB
mvi c,snext ; The result is the same as for SFIRST, so we can
call 5 ; loop back here, except FF means no more files.
mvi c,exit ; Arrange for the error routine to instead exit cleanly
jmp loop
memcpy: mov a,m ; Copy B bytes from HL to DE
stax d
inx h
inx d
dcr b
jnz memcpy
ret
emsg: db 'Not Found$'
fname: db 'XXXXXXXX.XXX',13,10,'$' ; Filename placeholder</syntaxhighlight>
{{out}}
<pre style='height: 50ex;'>I>dir
I: TINST COM : TINST DTA : TINST MSG : TURBO COM
I: TURBO MSG : TURBO OVR : WALKDIR ASM : WALKDIR PRN
I: WALKDIR HEX : WALKDIR COM
I>walkdir walkdir.*
WALKDIR .ASM
WALKDIR .PRN
WALKDIR .HEX
WALKDIR .COM
I>walkdir *.com
TINST .COM
TURBO .COM
WALKDIR .COM
I>walkdir foobar.baz
Not Found
I>dir a:*.asm
A: COUNT ASM : DETECT ASM : SUBLEQ ASM : LUHN ASM
I>walkdir a:*.asm
COUNT .ASM
DETECT .ASM
SUBLEQ .ASM
LUHN .ASM
</pre>
=={{header|8th}}==
<
"*.c" f:glob \ puts an array of strings with the file names on the top of the stack
</syntaxhighlight>
=={{header|Action!}}==
The attached result has been obtained under DOS 2.5.
<syntaxhighlight lang="action!">PROC GetFileName(CHAR ARRAY line,fname)
BYTE i,len
len=0
i=3
FOR i=3 TO 10
DO
IF line(i)=32 THEN EXIT FI
len==+1
fname(len)=line(i)
OD
len==+1
fname(len)='.
FOR i=11 TO 13
DO
IF line(i)=32 THEN EXIT FI
len==+1
fname(len)=line(i)
OD
fname(0)=len
RETURN
PROC Dir(CHAR ARRAY filter)
CHAR ARRAY line(255),fname(255)
BYTE dev=[1]
PrintE(filter)
Close(dev)
Open(dev,filter,6)
DO
InputSD(dev,line)
IF line(0)=0 OR line(0)>0 AND line(1)#32 THEN
EXIT
FI
GetFileName(line,fname)
Put(32) PrintE(fname)
OD
Close(dev)
PutE()
RETURN
PROC Main()
Dir("D:*.*")
Dir("H1:X*.*")
Dir("H1:?????.ACT")
Dir("H1:??F*.*")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Walk_a_directory_non-recursively.png Screenshot from Atari 8-bit computer]
<pre>
D:*.*
DOS.SYS
DUP.SYS
INPUT.TXT
H1:X*.*
XIAOL_24.ACT
XML_O_CU.ACT
H1:?????.ACT
AB_3D.ACT
BREAK.ACT
CUSIP.ACT
SIEVE.ACT
SLEEP.ACT
WHILE.ACT
H1:??F*.*
HOFST_34.ACT
INFINITE.ACT
UTF8__P2.ACT
</pre>
=={{header|Ada}}==
{{works with|GCC|4.12}}
<
with Ada.Text_IO; use Ada.Text_IO;
Line 223 ⟶ 384:
End_Search (Search);
end Walk_Directory;</
=={{header|ALGOL 68}}==
Line 229 ⟶ 390:
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386 - uses non-standard library routines ''get directory'' and'' grep in string''.}}
<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - ''get directory'' and'' grep in string'' not available in any library ... yet}} -->
<
[]STRING directory = get directory(".");
Line 237 ⟶ 398:
print((file, new line))
FI
OD</
{{out|Sample output}}
<pre>
Line 253 ⟶ 414:
AppleScript itself has limited built-in file system access. Typically, the Mac OS Finder is used to gather such information.
To list all file/folders in the root directory:
<
--> EXAMPLE RESULT: {"Applications", "Developer", "Library", "System", "Users"}</
To list all pdf files in user's home directory:
<
--> EXAMPLE RESULT: {"About Stacks.pdf", "Test.pdf"}</
The key clause is the <code>whose</code> modifier keyword. The Finder can interpret many variations, including such terms as <code>whose name begins with</code>, <code>whose name contains</code>, etc. As well as boolean combinations:
<
--> RETURNS: {"Test.pdf"}</
The Finder also supports the <code>entire contents</code> modifier keyword, which effectively performs a recursive directory scan without recursion.
<
----
Nowadays, it's more usual to use macOS's System Events application for this kind of task as it's very much faster than the Finder, especially with 'whose' filters. However, its results, unlike the Finder's, aren't sorted by the items' names and it includes results for hidden items too if these match the criteria.
<syntaxhighlight lang="applescript">tell application "System Events" to return name of every item in documents folder whose name extension is "pdf"
--> EXAMPLE RESULT: {"ShellScripting.pdf", "RFC 4180 (CSV spec).pdf", "About Stacks.pdf", "AppleScriptLanguageGuide.pdf", "robinson_jeffers_2004_9.pdf", "DiskWarrior Manual.pdf", "RFC 2445 (iCalendar spec).pdf", "Artistic Orchestration.pdf"}</syntaxhighlight>
Intermediate in speed between the Finder and System Events are shell scripts, which are handy if you're more comfortable with shell scripts than with AppleScript.
<syntaxhighlight lang="applescript">set docsFolderPath to POSIX path of (path to documents folder)
-- By default, "ls" returns file names sorted by character code, so save the sorting until the end and do it case-insensitively.
set shellCommandText to "ls -f " & quoted form of docsFolderPath & " | grep -i '\\.pdf$' | sort -f"
return paragraphs of (do shell script shellCommandText)
--> EXAMPLE RESULT: {"About Stacks.pdf", "AppleScriptLanguageGuide.pdf", "Artistic Orchestration.pdf", "DiskWarrior Manual.pdf", "RFC 2445 (iCalendar spec).pdf", "RFC 4180 (CSV spec).pdf", "robinson_jeffers_2004_9.pdf", "ShellScripting.pdf"}</syntaxhighlight>
Best of all for speed and sorting, although requiring somewhat more code, are the Foundation methods available through AppleScriptObjC.
<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
use scripting additions
set docsFolderURL to current application's class "NSURL"'s fileURLWithPath:(POSIX path of (path to documents folder))
-- Get NSURLs for the folder's visible contents.
tell current application's class "NSFileManager"'s defaultManager() to ¬
set visibleItems to its contentsOfDirectoryAtURL:(docsFolderURL) includingPropertiesForKeys:({}) ¬
options:(current application's NSDirectoryEnumerationSkipsHiddenFiles) |error|:(missing value)
-- Filter case-insensitively for those whose names have ".pdf" extensions.
set filter to current application's class "NSPredicate"'s predicateWithFormat:("pathExtension ==[c] 'pdf'")
set PDFs to visibleItems's filteredArrayUsingPredicate:(filter)
-- Get the names of any matching items.
set pdfNames to PDFs's valueForKey:("lastPathComponent")
-- Sort these case-insensitively and considering numerics.
set pdfNames to pdfNames's sortedArrayUsingSelector:("localizedStandardCompare:")
-- Return the result as an AppleScript list of text.
return pdfNames as list
--> EXAMPLE RESULT: {"About Stacks.pdf", "AppleScriptLanguageGuide.pdf", "Artistic Orchestration.pdf", "DiskWarrior Manual.pdf", "RFC 2445 (iCalendar spec).pdf", "RFC 4180 (CSV spec).pdf", "robinson_jeffers_2004_9.pdf", "ShellScripting.pdf"}</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">; list all files at current path
print list "."
; get all files at given path
; and select only the ones we want
; just select the files with .md extension
select list "some/path"
=> [".md" = extract.extension]
; just select the files that contain "test"
select list "some/path"
=> [in? "test"]</syntaxhighlight>
=={{header|AutoHotkey}}==
Display all INI files in Windows directory.
<
out .= A_LoopFileName "`n"
MsgBox,% out</
=={{header|BaCon}}==
This code will print all files in the current directory ".", separated by a newline symbol:
<
=={{header|BASIC}}==
Line 279 ⟶ 490:
DOS wildcards are rather underpowered when compared to... well... anything else.
{{works with|FreeBASIC}}
<
show "*.*"
Line 291 ⟶ 502:
f = DIR$
LOOP
END SUB</
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">call show ("c:\")
end
subroutine show (pattern$)
f$ = dir(pattern$)
while length(f$)
print f$
f$ = dir
end while
end subroutine</syntaxhighlight>
=={{header|Batch File}}==
A simple command that displays all EXE files in System32 directory non-recursively.
<
The same command inside FOR loop:
*Inside a Batch File:
<
*Command-line:
<
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
pattern$ = "*.ini"
PROClistdir(directory$ + pattern$)
Line 320 ⟶ 543:
SYS "FindClose", sh%
ENDIF
ENDPROC</
=={{header|C}}==
Line 326 ⟶ 549:
{{works with|POSIX|.1-2001}}
In this example, the pattern is a [[POSIX]] extended regular expression.
<
#include <dirent.h>
#include <regex.h>
Line 359 ⟶ 582:
walker(".", ".\\.c$");
return 0;
}</
=={{header|C sharp|C#}}==
<
using System.IO;
Line 377 ⟶ 600:
}
}
</syntaxhighlight>
=={{header|C++}}==
{{libheader|boost|1.50.0}}
<
#include "boost/regex.hpp"
#include <iostream>
Line 403 ⟶ 626:
}
}
}</
{{libheader|std|C++17}}
<
#include <filesystem>
#include <iostream>
Line 419 ⟶ 642:
std::cout << file.path().filename().string() << std::endl;
}
}</
=={{header|Clojure}}==
Using Java 8's [https://docs.oracle.com/javase/8/docs/api/java/nio/file/FileSystem.html#getPathMatcher-java.lang.String- PathMatcher] patterns.
<
(defn match-files [f pattern]
Line 432 ⟶ 655:
(let [directory (clojure.java.io/file dir)]
(map #(.getPath %) (filter #(match-files % pattern) (.listFiles directory)))))
</syntaxhighlight>
=={{header|ColdFusion}}==
This example display all files and directories directly under '''C:\temp''' that end with ''.html''
<
<cfoutput query="dirListing">
#dirListing.name# (#dirListing.type#)<br>
</cfoutput></
=={{header|Common Lisp}}==
<
(directory (merge-pathnames pattern directory)))</
Uses the filename pattern syntax provided by the CL implementation.
=={{header|D}}==
<
import std.stdio, std.file;
dirEntries(".", "*.*", SpanMode.shallow).writeln;
}</
=={{header|DCL}}==
<pre>* matches any number of characters
& matches exactly any one character</pre>
<syntaxhighlight lang="text">$ loop:
$ f = f$search( p1 )
$ if f .eqs. "" then $ exit
$ write sys$output f
$ goto loop</
{{out}}
<pre>$ @walk_a_directory *.*
Line 474 ⟶ 697:
USERS:[DAVID]WALK_A_DIRECTORY.COM;1
$ </pre>
=={{header|Delphi}}==
=== Hand-coded ===
See: [[Pascal]]
=== Using System.IOUtils ===
{{libheader| System.IOUtils}}
<syntaxhighlight lang="delphi">
program Walk_a_directory;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.IOUtils;
var
Files: TArray<string>;
FileName, Directory: string;
begin
Directory := TDirectory.GetCurrentDirectory; // dir = '.', work to
Files := TDirectory.GetFiles(Directory, '*.*');
for FileName in Files do
begin
Writeln(FileName);
end;
Readln;
end.
</syntaxhighlight>
{{out}}
<pre>
D:\Rosettacode\Walk_a_directory\Win32\Debug\Walk_a_directory.exe
</pre>
=={{header|E}}==
<
for name => file ? (name =~ rx`.*$pattern.*`) in directory {
println(name)
}
}</
Example:
<
.bash_history
.bash_profile
.bash_profile~</
=={{header|Elena}}==
ELENA
<
import system'routines;
import extensions'routines;
Line 496 ⟶ 759:
var dir := Directory.assign("c:\MyDir");
dir.getFiles("a.*").forEach
}</
=={{header|Elixir}}==
<
IO.inspect File.ls!
dir = "/users/public"
IO.inspect File.ls!(dir)</
{{out}}
Line 517 ⟶ 780:
directory, optionally restricted to those matching a regexp.
<
nil ;; just the filenames, not full paths
"\\.c\\'" ;; regexp
t) ;; don't sort the filenames
;;=> ("foo.c" "bar.c" ...)</syntaxhighlight>
=={{header|Erlang}}==
Line 537 ⟶ 799:
=={{header|Euphoria}}==
<
procedure show(sequence pattern)
Line 548 ⟶ 810:
end procedure
show("*.*")</
=={{header|F_Sharp|F#}}==
<
|> Array.iter (printfn "%s")</
=={{header|Factor}}==
Using unix globs. Also see the "directory." in basis/tools/files.factor.
<
IN: walk-directory-non-recursively
: print-files ( path pattern -- )
[ directory-files ] [ <glob> ] bi* [ matches? ] curry filter
[ print ] each ;</
Ex:
( scratchpad ) "." "*.txt" print-files
Line 569 ⟶ 831:
{{works with|gforth|0.6.2}}
Gforth's directory walking functions are tied to the POSIX ''dirent'' functions, used by the C langauge entry above. Forth doesn't have regex support, so a simple filter function is used instead.
<
: ls-all 2drop true ;
: ls-visible drop c@ [char] . <> ;
Line 593 ⟶ 855:
' c-file? is ls-filter
s" ." ls</
=={{header|FreeBASIC}}==
{{trans|BASIC}}
<syntaxhighlight lang="freebasic">
Sub show (pattern As String)
Dim As String f = Dir$(pattern)
While Len(f)
Print f
f = Dir$
Wend
End Sub
show "*.*"
Sleep
</syntaxhighlight>
=={{header|Frink}}==
This prints the names of all of the files in the current directory that end with <CODE>.frink</CODE> using a regular expression.
<syntaxhighlight lang="frink">for f = select[files["."], {|f1| f1.getName[] =~ %r/\.frink$/}]
println[f.getName[]]</syntaxhighlight>
{{out}}
<pre>UTMtest.frink
mersennetest.frink
piChudnovskyNew.frink
showFonts.frink
graphicalSieve.frink
...
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
void local fn EnumerateDirectoryAtURL( dirURL as CFURLRef )
NSDirectoryEnumerationOptions options = NSDirectoryEnumerationSkipsPackageDescendants + ¬
NSDirectoryEnumerationSkipsHiddenFiles + ¬
NSDirectoryEnumerationSkipsSubdirectoryDescendants
DirectoryEnumeratorRef enumerator = fn FileManagerEnumeratorAtURL( dirURL, NULL, options, NULL, NULL )
CFURLRef url = fn EnumeratorNextObject( enumerator )
while ( url )
if ( fn StringIsEqual( fn URLPathExtension( url ), @"fb" ) )
NSLog(@"%@",fn URLLastPathComponent( url ))
end if
url = fn EnumeratorNextObject( enumerator )
wend
end fn
fn EnumerateDirectoryAtURL( fn FileManagerURLForDirectory( NSDesktopDirectory, NSUserDomainMask ) )
HandleEvents
</syntaxhighlight>
{{out}}
<pre>
ListFormatter.fb
ObjectProperty1.fb
Archimedean Spiral with Bezier Curve.fb
FB3D.fb
lenArray.fb
Rosettacode Random Noise v04.fb
AssociatedObject.fb
</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=c5fde952fecd1d7052101b1e2287f2ff Click this link to run this code]'''
<
Dim sTemp As String
Line 604 ⟶ 931:
Next
End</
Output:
<pre>
Line 618 ⟶ 945:
=={{header|Go}}==
<
import (
Line 627 ⟶ 954:
func main() {
fmt.Println(filepath.Glob("*.go"))
}</
=={{header|Groovy}}==
<
new File('.').eachFileMatch(~/.*\.txt/) {
println it
Line 638 ⟶ 965:
new File('/foo/bar').eachFileMatch(~/.*\.txt/) {
println it
}</
=={{header|Hare}}==
<syntaxhighlight lang="hare">use fmt;
use glob;
export fn main() void = {
ls("/etc/*.conf");
};
fn ls(pattern: str) void = {
let gen = glob::glob(pattern, glob::flags::NONE);
defer glob::finish(&gen);
for (true) match (glob::next(&gen)) {
case void =>
break;
case glob::failure =>
continue;
case let s: str =>
fmt::printfln("{}", s)!;
};
};</syntaxhighlight>
=={{header|Haskell}}==
{{works with|GHC|GHCi|6.6}}
In this example, the pattern is a POSIX extended regular expression.
<
import Text.Regex
import Data.Maybe
Line 652 ⟶ 1,000:
mapM_ putStrLn $ filter (isJust.(matchRegex $ mkRegex pattern)) filenames
main = walk "." ".\\.hs$"</
=={{header|HicEst}}==
More on [http://www.HicEst.com/SYSTEM.htm SYSTEM], [http://www.HicEst.com/OPEN.htm OPEN], [http://www.HicEst.com/indexfnc.htm INDEX]
<
SYSTEM(DIR='*.*', FIle=dirtxt) ! "file names", length, attrib, Created, LastWrite, LastAccess
Line 665 ⟶ 1,013:
! write file names with extensions "txt", or "hic", or "jpg" (case insensitive) using RegEx option =128:
IF( INDEX(filename, "\.txt|\.hic|\.jpg", 128) ) WRITE() filename
ENDDO</
=={{header|Icon}} and {{header|Unicon}}==
This uses Unicon extensions for ''stat'' and to read directories. Icon can uses ''system'' to accomplish the same objective.
<
every write(getdirs(".","icn")) # writes out all directories from the current directory down
end
Line 682 ⟶ 1,030:
close(d)
}
end</
=={{header|IDL}}==
<
if cc gt 0 then print,f</
(IDL is an array language - very few things are ever done in 'loops'.)
=={{header|J}}==
<
0 dir '*.png'
0 dir '/mydir/*.txt'</
The verb <tt>dir</tt> supports a number of reporting options determined by its left argument. A left argument of <tt>0</tt> reports just the file names.
=={{header|Java}}==
<
String[] contents = dir.list();
for (String file : contents)
if (file.endsWith(".mp3"))
System.out.println(file);</
=={{header|JavaScript}}==
{{works with|JScript}}
<
var dir = fso.GetFolder('test_folder');
Line 726 ⟶ 1,074:
}
walkDirectory(dir, '\\.txt$');</
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
if endswith(filename, ".mp3")
print(filename)
end
end</
=={{header|Kotlin}}==
<
import java.io.File
Line 752 ⟶ 1,100:
val files = walkDirectory("/usr/include", r)
for (file in files) println(file)
}</
Sample output (Ubuntu v14.04):
{{out}}
Line 767 ⟶ 1,115:
=={{header|Lasso}}==
<
dir('.') -> foreach => {#1 >> 'string' ? #matchingfilenames -> insert(#1)}
#matchingfilenames</
-> array(mystrings.html, a_string_file.txt)
=={{header|Lingo}}==
<
on printFiles (dir, fileType)
i = 1
Line 786 ⟶ 1,134:
if fn.char[fn.length-sub..fn.length]=fileType then put fn
end repeat
end</
=={{header|LiveCode}}==
<
put the files into docfiles
filter docfiles with "*.txt"
put docfiles</
=={{header|Lua}}==
Lua itself is extremely spartanic as it is meant for embedding. Reading out a directory is not something that a minimal standard C library can do, and so minimal Lua without native extension libraries can't do it either. But lfs (LuaFileSystem) is about as standard an extension as it gets, so we use that.
<
directorypath = "." -- current working directory
for filename in lfs.dir(directorypath) do
Line 802 ⟶ 1,150:
print(filename)
end
end</
Although Lua is spartanic, it still provides functions such as os.execute([command]) and io.popen(prog [, mode]). Below an example for Windows users having io.popen at their disposal. Mind you, it may pop-up a command window.
<
-- Note that io.popen is not available on all platforms
local function getOutput(prog)
Line 834 ⟶ 1,182:
print(filename)
end
end</
=={{header|M2000 Interpreter}}==
Line 842 ⟶ 1,190:
There is a second optional parameter which examine all files founded from first filter for included letters. We can add using | as seperator, a list of strings included in same line. Files examine all files, opened one by one, using an automatic way to find what kind of text file is, an Ansi, a Utf8, a Utf-16LE, or a Utf-16BE. Also automatic find the line breaks. All files converted at open as utf-16LE and then searched. For Ansi files, Locale used to make the right conversion.
<syntaxhighlight lang="m2000 interpreter">
Module Show_Files_Standard {
\\ we get more (include hidden too)
Line 863 ⟶ 1,211:
}
Show_Files_Standard
</syntaxhighlight>
Like VbScript using external help, from a COM object.
Line 873 ⟶ 1,221:
Stack New {} make a block of a fresh stack of values, and at the exit attach the old stack (which for this block detached from execute object at the begin of block).
<syntaxhighlight lang="m2000 interpreter">
Module Show_Files {
Function get_files$ (folder_path$) {
Line 902 ⟶ 1,250:
}
Show_Files
</syntaxhighlight>
=={{header|
<syntaxhighlight lang="macro-10">
TITLE DIRWLK - Directory Walker
SUBTTL PDP-10 Assembly Language (MACRO-10 @ TOPS-20). KJX 2022.
SEARCH MONSYM,MACSYM ;Get system-call names.
.REQUIRE SYS:MACREL ;Macros: TMSG, EJSHLT, etc.
STDAC. ;Define standard register names.
JFN: BLOCK 1 ;Space for JFN (file-handle)
FSPEC: BLOCK 20 ;Space for file specification.
FSPECL= <.-FSPEC>*5 ;Length in chars of file-spec.
GO:: RESET% ;Initialize process.
TMSG <Please enter filespec, wildcards are allowed: >
HRROI T1,FSPEC ;Read into FSPEC.
MOVEI T2,FSPECL ;Maximum allowed characters.
SETZ T3, ;No Ctrl-R prompting.
RDTTY% ;Read string from terminal.
EJSHLT ; Print error-msg on errors.
MOVX T1,GJ%OLD!GJ%IFG!GJ%FLG!GJ%SHT ;Various flags.
HRROI T2,FSPEC ;File specification from above.
GTJFN% ;Get JFN for first matching file.
EJSHLT ; Print error-msg on errors.
MOVEM T1,JFN ;Save JFN.
DO.
MOVEI T1,.PRIOU ;Write to standard-output.
HRRZ T2,JFN ;JFN from above to decode.
SETZ T3, ;No flags.
JFNS% ;Decode filename and print it.
EJSHLT ; Print error-msg on errors.
TMSG <
> ;Print newline.
MOVE T1,JFN ;Get JFN into T1.
GNJFN% ;Get next matching file.
JRST [ HALTF% ; Halt program on failure.
JRST GO ]
LOOP. ;No error: Do it again.
ENDDO.
END GO
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
The built-in function <code>FileNames</code> does exactly this:
:<code>FileNames[]</code> lists all files in the current working directory.
Line 912 ⟶ 1,306:
:<code>FileNames[forms,dirs,n]</code> includes files that are in subdirectories up to n levels down.
Examples (find all files in current directory, find all png files in root directory):
<
FileNames["*.png", $RootDirectory]</
the result can be printed with Print /@ FileNames[....].
=={{header|MAXScript}}==
<
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">import Nanoquery.IO
for fname in new(File).listDir("/foo/bar")
if lower(new(File, fname).getExtension()) = ".mp3"
println filename
end
end</syntaxhighlight>
=={{header|Nemerle}}==
<
using System.IO;
Line 932 ⟶ 1,335:
foreach (file in files) WriteLine(file);
}
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 969 ⟶ 1,372:
return
</syntaxhighlight>
{{out}}
<pre>
Line 981 ⟶ 1,384:
=={{header|Nim}}==
The “os” standard module provides several iterators to retrieve files or directories matching a pattern: <code>walkPattern</code> to retrieve files and directories, <code>walkFiles</code> to retrieve only files and <code>walkDirs</code> to retrieve only directories. The pattern is OS dependent but at least the <code>*.ext</code> notation is supported.
And there is the powerful <code>walkDir</code> to list the content of a directory specified by its name (without pattern).
Here is an example with <code>walkFiles</code> and a pattern:
<syntaxhighlight lang="nim">import os
for file in walkFiles "/foo/bar/*.mp3":
echo file</
=={{header|Objeck}}==
<
bundle Default {
Line 1,000 ⟶ 1,408:
}
}
}</
=={{header|Objective-C}}==
<
// Pre-OS X 10.5
Line 1,012 ⟶ 1,420:
for (NSString *file in contents)
if ([[file pathExtension] isEqualToString:@"mp3"])
NSLog(@"%@", file);</
=={{header|OCaml}}==
<
let contents = Array.to_list (Sys.readdir ".") in
let select pat str = Str.string_match (Str.regexp pat) str 0 in
List.filter (select ".*\\.jpg") contents</
=={{header|Odin}}==
<syntaxhighlight lang="odin">package main
import "core:fmt"
import "core:path/filepath"
main :: proc() {
matches, _err := filepath.glob("*.odin")
for match in matches do fmt.println(match)
}</syntaxhighlight>
=={{header|Oz}}==
<
[Path] = {Module.link ['x-oz://system/os/Path.ozf']}
[Regex] = {Module.link ['x-oz://contrib/regex']}
Line 1,029 ⟶ 1,448:
MatchingFiles = {Filter Files fun {$ File} {Regex.search Pattern File} \= false end}
in
{ForAll MatchingFiles System.showInfo}</
=={{header|Pascal}}==
{{works with|Free Pascal}}
<
program Walk;
Line 1,063 ⟶ 1,482:
end;
FindClose(Res);
end.</
=={{header|Perl}}==
<
opendir my $dh, '/home/foo/bar';
say for grep { /php$/ } readdir $dh;
closedir $dh;</
Or using globbing, with the <code><></code> operator,
<
Or the same with the builtin <code>glob()</code> function,
<
The <code>glob()</code> function takes any expression for its pattern, whereas <code><></code> is only for a literal.
<
my @filenames = glob($pattern);</
=={{header|Phix}}==
{{libheader|Phix/basics}}
The dir function accepts a DOS pattern, with some minor variations (eg "*" gets all files with no extension).
<!--<syntaxhighlight lang="phix">-->
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">dir</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"*.txt"</span><span style="color: #0000FF;">))[</span><span style="color: #000000;">D_NAME</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,097 ⟶ 1,515:
=={{header|PHP}}==
{{works with|PHP|5.2.0}}
<
$dh = opendir('c:/foo/bar'); // Or '/home/foo/bar' for Linux
while (false !== ($file = readdir($dh)))
Line 1,109 ⟶ 1,527:
}
}
closedir($dh);</
Or:
<
foreach (scandir('/home/foo/bar') as $file)
{
Line 1,121 ⟶ 1,539:
}
}
}</
{{works with|PHP|<nowiki>4 >= 4.3.0 or 5</nowiki>}}
<
echo "$file\n";
}</
=={{header|PicoLisp}}==
<
(when (match '`(chop "s@.c") (chop F)) # Matches 's*.c'?
(println F) ) ) # Yes: Print it</
{{out}}
<pre>"start.c"
Line 1,139 ⟶ 1,557:
=={{header|Pike}}==
<
foreach(files, string file)
write(file + "\n");</
=={{header|Pop11}}==
Built-in procedure sys_file_match searches directories (or directory trees) using shell-like patterns:
<
;;; create path repeater
sys_file_match('*.p', '', false, 0) -> repp;
Line 1,152 ⟶ 1,570:
;;; print the file
printf(fil, '%s\n');
endwhile;</
=={{header|PowerShell}}==
Since PowerShell is also a shell it should come as no surprise that this task is very simple. Listing the names of all text files, or the names of all files, starting with "f":
<
Get-ChildItem f* -Name</
The <code>-Name</code> parameter tells the <code>Get-ChildItem</code> to return only the file names as string, otherwise a complete <code>FileInfo</code> or <code>DirectoryInfo</code> object would be returned, containing much more information than only the file name.
More complex matching can be accomplished by filtering the complete list of files using the <code>Where-Object</code> cmdlet. The following will output all file names that contain at least one vowel:
<
=={{header|PureBasic}}==
The match is made using DOS wildcards. It could easily be modified to match based on a regular expression if desired (i.e. using the PCRE library).
<
Protected directoryID
Line 1,183 ⟶ 1,601:
Input()
CloseConsole()
EndIf</
=={{header|Python}}==
The [http://python.org/doc/lib/module-glob.html glob] library included with Python lists files matching shell-like patterns:
<
for filename in glob.glob('/foo/bar/*.mp3'):
print(filename)</
Or manually:
<
for filename in os.listdir('/foo/bar'):
if filename.endswith('.mp3'):
print(filename)</
=={{header|R}}==
<
=={{header|Racket}}==
<syntaxhighlight lang="racket">
-> (for ([f (directory-list "/tmp")] #:when (regexp-match? "\\.rkt$" f))
(displayln f))
... *.rkt files ...
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
The <code>dir</code> function takes the directory to traverse, and optionally a named parameter <code>test</code>, which is [https://docs.raku.org/routine/$TILDE$TILDE smart-matched] against the basename of each file (so for example we can use a regex):
<syntaxhighlight lang="raku" line>.say for dir ".", :test(/foo/);</syntaxhighlight>
=={{header|Rascal}}==
<
public void Walk(loc a, str pattern){
for (entry <- listEntries(a))
endsWith(entry, pattern) ? println(entry);
}</
=={{header|Raven}}==
<
item m/\.txt$/ if "%(item)s\n" print</
=={{header|REXX}}==
{{works with|Regina}}
The following program was tested in a DOS window under Windows/XP and should work for all Microsoft Windows.
<
parse arg xdir; if xdir='' then xdir='\' /*Any DIR? Use default.*/
@.=0 /*default in case ADDRESS fails. */
Line 1,237 ⟶ 1,660:
do j=1 for #; say @.j; end /*show files that met criteria. */
exit @.0+rc /*stick a fork in it, we're done.*/</
=={{header|Ring}}==
<
###---------------------------------------
Line 1,332 ⟶ 1,754:
###===============================================
</syntaxhighlight>
OUTPUT:
Line 1,392 ⟶ 1,814:
Finished
</pre>
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
The very first instruction of this program <code>VARS</code> returns the list of all current files and subdirectories. The rest of the code retains the names that comply with the pattern given in input, and which are not directories. To do so, the program attempts to recall the contents of each object on the stack through <code>RCL</code>: if an error occurs, the object is then a directory and shall not be processed further.
≪ VARS → filter list
≪ { } 1 list SIZE '''FOR''' j
list j GET
'''IFERR''' DUP RCL '''THEN''' DROP2
'''ELSE'''
DROP →STR 2 OVER SIZE 1 - SUB
'''IF''' DUP filter POS '''THEN''' + ELSE DROP '''END'''
'''END'''
'''NEXT'''
≫ ≫
'WKDIR' STO
"T" WKDIR
{{out}}
<pre>
1: { "T" "TESTPGM" "FACTN" }
</pre>
=={{header|Ruby}}==
<
Dir.glob('*') { |file| puts file }
Line 1,406 ⟶ 1,849:
puts file if file =~ pattern
end
end</
=={{header|Run BASIC}}==
<
if #g HASANSWER() then
Line 1,419 ⟶ 1,863:
next
end if
wait</
FILE ACCESSOR methods
Line 1,447 ⟶ 1,891:
=={{header|Rust}}==
<
extern crate regex;
extern crate rustc_serialize;
Line 1,482 ⟶ 1,926:
}
}
}</
=={{header|Scala}}==
<
val dir = new File("/foo/bar").list()
dir.filter(file => file.endsWith(".mp3")).foreach(println)</
=={{header|Seed7}}==
<
include "osfiles.s7i";
Line 1,503 ⟶ 1,947:
end if;
end for;
end func;</
=={{header|Sidef}}==
<
{{out}}
<pre>
Line 1,513 ⟶ 1,957:
</pre>
<
path.open(\var dir_h) || return nil
dir_h.entries.each { |entry|
Line 1,528 ⟶ 1,972:
say file;
}
)</
{{out}}
<pre>
Line 1,536 ⟶ 1,980:
=={{header|Smalltalk}}==
<
allFilesMatching: '*.st' do: [ :f | (f name) displayNl ]</
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">fun dirEntries path =
let
fun loop strm =
case OS.FileSys.readDir strm of
SOME name => name :: loop strm
| NONE => []
val strm = OS.FileSys.openDir path
in
loop strm before OS.FileSys.closeDir strm
end</syntaxhighlight>
List all "hidden" files (starting with a dot in Unix) in the current directory:
<syntaxhighlight lang="sml">(print o concat o map (fn s => s ^ "\n") o List.filter (String.isPrefix ".") o dirEntries) "."</syntaxhighlight>
=={{header|Tcl}}==
For the current directory:
<
puts $filename
}</
For an arbitrary directory:
<
foreach filename [glob -directory $dir *.txt] {
puts $filename
### Or, if you only want the local filename part...
# puts [file tail $filename]
}</
=={{header|Toka}}==
As with the C example, this uses a a POSIX extended regular expression as the pattern. The '''dir.listByPattern''' function used here was introduced in library revision 1.3.
<
" ." " .\\.txt$" dir.listByPattern</
=={{header|TUSCRIPT}}==
<
files=FILE_NAMES (+,-std-)
fileswtxt= FILTER_INDEX (files,":*.txt:",-)
txtfiles= SELECT (files,#fileswtxt)</
{{out}}
<pre>
Line 1,573 ⟶ 2,031:
==== Using <code>glob</code> ====
<
{{out}}
<
"/etc/ca-certificates.conf" "/etc/colord.conf" "/etc/ddclient.conf"
"/etc/debconf.conf" "/etc/deluser.conf" "/etc/dnsmasq.conf" "/etc/ffserver.conf"
Line 1,587 ⟶ 2,045:
"/etc/pnm2ppa.conf" "/etc/popularity-contest.conf" "/etc/resolv.conf"
"/etc/rsyslog.conf" "/etc/sensors3.conf" "/etc/sysctl.conf" "/etc/ucf.conf"
"/etc/updatedb.conf" "/etc/usb_modeswitch.conf" "/etc/wodim.conf")</
==== Using <code>open-directory</code> and <code>get-lines</code> ====
<
{{out}}
<
"debconf.conf" "apg.conf" "adduser.conf" "mke2fs.conf" "colord.conf"
"kerneloops.conf" "fuse.conf" "hdparm.conf" "irssi.conf" "host.conf"
Line 1,603 ⟶ 2,061:
"knockd.conf" "ntp.conf" "sensors3.conf" "resolv.conf" "blkid.conf"
"lftp.conf" "ca-certificates.conf" "usb_modeswitch.conf" "logrotate.conf"
"rsyslog.conf" "pnm2ppa.conf")</
=={{header|UNIX Shell}}==
<
(cd mydir && ls -d *.c) # *.c files in mydir</
<code>*.c</code> is a ''file name pattern'', also known as a ''glob pattern''. The shell expands each pattern to a sorted list of matching files. Details are in your shell's manual.
Line 1,614 ⟶ 2,072:
=={{header|UnixPipes}}==
Here using grep for regexp.
<
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Sub show_files(folder_path,pattern)
Set objfso = CreateObject("Scripting.FileSystemObject")
Line 1,628 ⟶ 2,086:
Call show_files("C:\Windows",".exe")
</syntaxhighlight>
=={{header|Visual Basic .NET}}==
{{works with|Visual Basic .NET|9.0+}}
<
For Each file In IO.Directory.GetFiles("\temp", "*.txt")
Console.WriteLine(file)
Line 1,645 ⟶ 2,103:
For Each file In IO.Directory.GetFiles("\temp").Where(Function(f) f Like "*.txt")
Console.WriteLine(file)
Next</
=={{header|Wren}}==
{{libheader|Wren-pattern}}
<syntaxhighlight lang="wren">import "io" for Directory
import "./pattern" for Pattern
var walk = Fn.new { |dir, pattern|
if (!Directory.exists(dir)) Fiber.abort("Directory does not exist.")
var files = Directory.list(dir)
return files.where { |f| pattern.isMatch(f) }
}
// get all C header files beginning with 'a' or 'b'
var p = Pattern.new("[a|b]+0^..h", Pattern.whole)
for (f in walk.call("/usr/include", p)) System.print(f)</syntaxhighlight>
{{out}}
<pre>
aio.h
aliases.h
alloca.h
ar.h
argp.h
argz.h
asoundlib.h
assert.h
byteswap.h
</pre>
=={{header|zkl}}==
Unix glob, with wildcarding and options on file type, case folding and a few others.
<
=={{header|Zsh}}==
Zsh has powerful filename generation features, which can filter by file names, permissions, size, type, etc.
<
{{omit from|AWK|Use a shell command: system("ls *.awk")}}
|