Walk a directory/Non-recursively: Difference between revisions
Line 16: | Line 16: | ||
; Non-recursive directory walk for Motorola 68000 under AmigaOs 2.04+ by Thorham |
; Non-recursive directory walk for Motorola 68000 under AmigaOs 2.04+ by Thorham |
||
; |
; |
||
⚫ | |||
; |
; |
||
; from exec includes |
; from exec includes |
||
; |
; |
||
⚫ | |||
_LVOOpenLibrary equ -552 |
_LVOOpenLibrary equ -552 |
||
_LVOCloseLibrary equ -414 |
_LVOCloseLibrary equ -414 |
Revision as of 17:48, 3 September 2015
You are encouraged to solve this task according to the task description, using any language you may know.
Walk a given directory and print the names of files matching a given pattern. (How is "pattern" defined? substring match? DOS pattern? BASH pattern? ZSH pattern? Perl regular expression?)
Note: This task is for non-recursive methods. These tasks should read a single directory, not an entire directory tree. For code examples that read entire directory trees, see Walk Directory Tree
Note: Please be careful when running any code presented here.
8th
<lang forth> "*.c" f:glob \ puts an array of strings with the file names on the top of the stack </lang>
68000 Assembly
Non-recursive directory walk in Motorola 68000 assembly language under AmigaOs 2.04+ by Thorham. Uses regular Amiga dos pattern matching. <lang 68000devpac>;
- Non-recursive directory walk for Motorola 68000 under AmigaOs 2.04+ by Thorham
execBase equ 4
- from exec includes
_LVOOpenLibrary equ -552 _LVOCloseLibrary equ -414 _LVOAllocVec equ -684 _LVOFreeVec equ -690
MEMF_ANY equ 0
- from dos includes
_LVOVPrintf equ -954 _LVOExamine equ -102 _LVOExNext equ -108 _LVOLock equ -84 _LVOUnLock equ -90 _LVOParsePatternNoCase equ -966 _LVOMatchPatternNoCase equ -972
ACCESS_READ equ -2
rsset 0
fib_DiskKey rs.l 1 fib_DirEntryType rs.l 1 fib_FileName rs.b 108 fib_Protection rs.l 1 fib_EntryType rs.l 1 fib_Size rs.l 1 fib_NumBlocks rs.l 1 fib_DateStamp rs.b 12 fib_Comment rs.b 80 fib_OwnerUID rs.w 1 fib_OwnerGID rs.w 1 fib_Reserved rs.b 32 fib_SIZEOF rs.b 0
- main
start
move.l execBase,a6
- open dos.library
lea dosName,a1 moveq #37,d0 jsr _LVOOpenLibrary(a6) move.l d0,dosBase beq exit
- allocate memory for file info block
move.l #fib_SIZEOF,d0 move.l #MEMF_ANY,d1 jsr _LVOAllocVec(a6) move.l d0,fib beq exit
- get directory lock
move.l dosBase,a6
move.l #pathString,d1 move.l #ACCESS_READ,d2 jsr _LVOLock(a6) move.l d0,lock beq exit
- examine directory for ExNext
move.l lock,d1 move.l fib,d2 jsr _LVOExamine(a6) tst.w d0 beq exit
- parse pattern string
move.l #patternString,d1 move.l #patternParsed,d2 move.l #sizeof_patternString*2+2,d3 jsr _LVOParsePatternNoCase(a6) tst.l d0 blt exit
- get some pointers for use in the loop
lea printfArgs,a2 move.l fib,a3 lea fib_FileName(a3),a3
.loop
- get next directory entry
move.l lock,d1 move.l fib,d2 jsr _LVOExNext(a6) tst.w d0 beq exit
- match pattern
move.l #patternParsed,d1 move.l a3,d2 jsr _LVOMatchPatternNoCase(a6)
- if match then print file name
tst.l d0 beq .nomatch
move.l a3,(a2) move.l #formatString,d1 move.l #printfArgs,d2 jsr _LVOVPrintf(a6)
.nomatch
bra .loop
- cleanup and exit
exit
move.l dosBase,a6 move.l lock,d1 jsr _LVOUnLock(a6)
move.l execBase,a6 move.l fib,a1 tst.l a1 beq .l1 jsr _LVOFreeVec(a6)
.l1
move.l dosBase,a1 jsr _LVOCloseLibrary(a6) rts
section data,data_p
- variables
dosBase
dc.l 0
lock
dc.l 0
fib
dc.l 0
printfArgs
dc.l 0
- strings
dosName
dc.b "dos.library",0
pathString
dc.b "ram:",0
formatString
dc.b "%s",10,0
patternString
dc.b "#?",0
patternString_end sizeof_patternString=patternString_end-patternString
patternParsed
dcb.b sizeof_patternString*2+2</lang>
Ada
<lang ada>with Ada.Directories; use Ada.Directories; with Ada.Text_IO; use Ada.Text_IO;
procedure Walk_Directory
(Directory : in String := "."; Pattern : in String := "") -- empty pattern = all file names/subdirectory names
is
Search : Search_Type; Dir_Ent : Directory_Entry_Type;
begin
Start_Search (Search, Directory, Pattern);
while More_Entries (Search) loop Get_Next_Entry (Search, Dir_Ent); Put_Line (Simple_Name (Dir_Ent)); end loop;
End_Search (Search);
end Walk_Directory;</lang>
ALGOL 68
<lang algol68>INT match=0, no match=1, out of memory error=2, other error=3;
[]STRING directory = get directory("."); FOR file index TO UPB directory DO
STRING file = directory[file index]; IF grep in string("[Ss]ort*.[.]a68$", file, NIL, NIL) = match THEN print((file, new line)) FI
OD</lang>
- Sample output:
Quick_sort.a68 Shell_sort.a68 Cocktail_Sort.a68 Selection_Sort.a68 Merge_sort.a68 Bobosort.a68 Insertion_Sort.a68 Permutation_Sort.a68
AppleScript
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:
<lang AppleScript>tell application "Finder" to return name of every item in (startup disk)
--> EXAMPLE RESULT: {"Applications", "Developer", "Library", "System", "Users"}</lang>
To list all pdf files in user's home directory:
<lang AppleScript>tell application "Finder" to return name of every item in (path to documents folder from user domain) whose name ends with "pdf"
--> EXAMPLE RESULT: {"About Stacks.pdf", "Test.pdf"}</lang>
The key clause is the whose
modifier keyword. The Finder can interpret many variations, including such terms as whose name begins with
, whose name contains
, etc. As well as boolean combinations:
<lang AppleScript>tell application "Finder" to return name of every item in (path to documents folder from user domain) whose name does not contain "about" and name ends with "pdf"
--> RETURNS: {"Test.pdf"}</lang>
The Finder also supports the entire contents
modifier keyword, which effectively performs a recursive directory scan without recursion.
<lang AppleScript>tell application "Finder" to return name of every item in entire contents of (path to documents folder from user domain) whose name ends with "pdf"</lang>
AutoHotkey
Display all INI files in Windows directory. <lang autohotkey>Loop, %A_WinDir%\*.ini
out .= A_LoopFileName "`n"
MsgBox,% out</lang>
BASIC
(older versions don't have DIR$
)
DOS wildcards are rather underpowered when compared to... well... anything else.
<lang qbasic>DECLARE SUB show (pattern AS STRING)
show "*.*"
SUB show (pattern AS STRING)
DIM f AS STRING f = DIR$(pattern) DO WHILE LEN(f) PRINT f f = DIR$ LOOP
END SUB</lang>
Batch File
A simple command that displays all EXE files in System32 directory non-recursively. <lang dos>dir /b "%windir%\system32\*.exe"</lang> The same command inside FOR loop:
- Inside a Batch File:
<lang dos>@for /F "tokens=*" %%F in ('dir /b "%windir%\system32\*.exe"') do echo %%F</lang>
- Command-line:
<lang dos>for /F "tokens=*" %F in ('dir /b "%windir%\system32\*.exe"') do echo %F</lang>
BBC BASIC
<lang bbcbasic> directory$ = "C:\Windows\"
pattern$ = "*.ini" PROClistdir(directory$ + pattern$) END DEF PROClistdir(afsp$) LOCAL dir%, sh%, res% DIM dir% LOCAL 317 SYS "FindFirstFile", afsp$, dir% TO sh% IF sh% <> -1 THEN REPEAT PRINT $$(dir%+44) SYS "FindNextFile", sh%, dir% TO res% UNTIL res% = 0 SYS "FindClose", sh% ENDIF ENDPROC</lang>
C
In this example, the pattern is a POSIX extended regular expression. <lang c>#include <sys/types.h>
- include <dirent.h>
- include <regex.h>
- include <stdio.h>
enum {
WALK_OK = 0, WALK_BADPATTERN, WALK_BADOPEN,
};
int walker(const char *dir, const char *pattern) {
struct dirent *entry; regex_t reg; DIR *d;
if (regcomp(®, pattern, REG_EXTENDED | REG_NOSUB)) return WALK_BADPATTERN; if (!(d = opendir(dir))) return WALK_BADOPEN; while (entry = readdir(d)) if (!regexec(®, entry->d_name, 0, NULL, 0)) puts(entry->d_name); closedir(d); regfree(®); return WALK_OK;
}
int main() {
walker(".", ".\\.c$"); return 0;
}</lang>
C++
<lang cpp>#include "boost/filesystem.hpp"
- include "boost/regex.hpp"
- include <iostream>
using namespace boost::filesystem;
int main() {
path current_dir("."); // list all files starting with a boost::regex pattern("a.*"); for (directory_iterator iter(current_dir), end; iter != end; ++iter) { boost::smatch match; std::string fn = iter->path().filename().string(); // must make local variable if (boost::regex_match( fn, match, pattern)) { std::cout << match[0] << "\n"; } }
}</lang>
C#
<lang csharp>using System; using System.IO;
namespace DirectoryWalk {
class Program { static void Main(string[] args) { string[] filePaths = Directory.GetFiles(@"c:\MyDir", "a*"); foreach (string filename in filePaths) Console.WriteLine(filename); } }
} </lang>
ColdFusion
This example display all files and directories directly under C:\temp that end with .html <lang cfm><cfdirectory action="list" directory="C:\temp" filter="*.html" name="dirListing"> <cfoutput query="dirListing">
#dirListing.name# (#dirListing.type#)
</cfoutput></lang>
Common Lisp
<lang lisp>(defun walk-directory (directory pattern)
(directory (merge-pathnames pattern directory)))</lang>
Uses the filename pattern syntax provided by the CL implementation.
D
<lang d>void main() {
import std.stdio, std.file;
dirEntries(".", "*.*", SpanMode.shallow).writeln;
}</lang>
DCL
* matches any number of characters & matches exactly any one character
<lang>$ loop: $ f = f$search( p1 ) $ if f .eqs. "" then $ exit $ write sys$output f $ goto loop</lang>
- Output:
$ @walk_a_directory *.* USERS:[DAVID]A.A;1 USERS:[DAVID]B.B;1 USERS:[DAVID]GG.GG;1 USERS:[DAVID]WALK_A_DIRECTORY.COM;1 $ @walk_a_directory *.% USERS:[DAVID]A.A;1 USERS:[DAVID]B.B;1 $ @walk_a_directory *a*.* USERS:[DAVID]A.A;1 USERS:[DAVID]WALK_A_DIRECTORY.COM;1 $
E
<lang e>def walkDirectory(directory, pattern) {
for name => file ? (name =~ rx`.*$pattern.*`) in directory { println(name) }
}</lang> Example: <lang e>? walkDirectory(<file:~>, "bash_") .bash_history .bash_profile .bash_profile~</lang>
Emacs Lisp
directory-files
gives filenames in a given
directory, optionally restricted to those matching a regexp.
<lang lisp>(directory-files "/some/dir/name"
nil ;; just the filenames, not full paths "\\.c\\'" ;; regexp t) ;; don't sort the filenames
=> ("foo.c" "bar.c" ...)</lang>
Erlang
Use builtin function filelib:fold_files/5
- Output:
8> filelib:fold_files( "/tmp", ".*", false, fun(File, Acc) -> [File|Acc] end, []). ["/tmp/.X0-lock","/tmp/.cron-check-4000-was-here", "/tmp/kerneloops.XyN0SP","/tmp/npicagwD7tf"] 9> filelib:fold_files( "/tmp", "k.*P", false, fun(File, Acc) -> [File|Acc] end, []). ["/tmp/kerneloops.XyN0SP"]
Euphoria
<lang euphoria>include file.e
procedure show(sequence pattern)
sequence f f = dir(pattern) for i = 1 to length(f) do puts(1,f[i][D_NAME]) puts(1,'\n') end for
end procedure
show("*.*")</lang>
F#
<lang fsharp>System.IO.Directory.GetFiles("c:\\temp", "*.xml") |> Array.iter (printfn "%s")</lang>
Factor
Using unix globs. Also see the "directory." in basis/tools/files.factor. <lang factor>USING: globs io io.directories kernel regexp sequences ; IN: walk-directory-non-recursively
- print-files ( path pattern -- )
[ directory-files ] [ <glob> ] bi* [ matches? ] curry filter [ print ] each ;</lang>
Ex:
( scratchpad ) "." "*.txt" print-files license.txt
Forth
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. <lang forth>defer ls-filter ( name len -- ? )
- ls-all 2drop true ;
- ls-visible drop c@ [char] . <> ;
- ls ( dir len -- )
open-dir throw ( dirid ) begin dup pad 256 rot read-dir throw while pad over ls-filter if cr pad swap type else drop then repeat drop close-dir throw ;
\ only show C language source and header files (*.c *.h)
- c-file? ( str len -- ? )
dup 3 < if 2drop false exit then + 1- dup c@ dup [char] c <> swap [char] h <> and if drop false exit then 1- dup c@ [char] . <> if drop false exit then drop true ;
' c-file? is ls-filter
s" ." ls</lang>
Go
<lang go>package main
import (
"fmt" "path/filepath"
)
func main() {
fmt.Println(filepath.Glob("*.go"))
}</lang>
Groovy
<lang groovy>// *** print *.txt files in current directory
new File('.').eachFileMatch(~/.*\.txt/) { println it }
// *** print *.txt files in /foo/bar new File('/foo/bar').eachFileMatch(~/.*\.txt/) { println it }</lang>
Haskell
In this example, the pattern is a POSIX extended regular expression. <lang haskell>import System.Directory import Text.Regex import Data.Maybe
walk :: FilePath -> String -> IO () walk dir pattern = do
filenames <- getDirectoryContents dir mapM_ putStrLn $ filter (isJust.(matchRegex $ mkRegex pattern)) filenames
main = walk "." ".\\.hs$"</lang>
HicEst
More on SYSTEM, OPEN, INDEX <lang hicest>CHARACTER dirtxt='dir.txt', filename*80
SYSTEM(DIR='*.*', FIle=dirtxt) ! "file names", length, attrib, Created, LastWrite, LastAccess OPEN(FIle=dirtxt, Format='"",', LENgth=files) ! parses column 1 ("file names")
DO nr = 1, files
filename = dirtxt(nr,1) ! reads dirtxt row = nr, column = 1 to filename ! 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</lang>
IDL
<lang idl>f = file_search('*.txt', count=cc) if cc gt 0 then print,f</lang> (IDL is an array language - very few things are ever done in 'loops'.)
Icon and Unicon
This uses Unicon extensions for stat and to read directories. Icon can uses system to accomplish the same objective. <lang Icon>procedure main() every write(getdirs(".","icn")) # writes out all directories from the current directory down end
procedure getdirs(s,pat) #: return a list of directories beneath the directory 's' local d,f
if ( stat(s).mode ? ="d" ) & ( d := open(s) ) then {
while f := read(d) do if find(pat,f) then suspend f close(d) }
end</lang>
J
<lang j>require 'dir' 0 dir '*.png' 0 dir '/mydir/*.txt'</lang> The verb dir supports a number of reporting options determined by its left argument. A left argument of 0 reports just the file names.
Java
<lang java>File dir = new File("/foo/bar");
String[] contents = dir.list(); for (String file : contents)
if (file.endsWith(".mp3")) System.out.println(file);</lang>
JavaScript
<lang javascript>var fso = new ActiveXObject("Scripting.FileSystemObject"); var dir = fso.GetFolder('test_folder');
function walkDirectory(dir, re_pattern) {
WScript.Echo("Files in " + dir.name + " matching '" + re_pattern +"':"); walkDirectoryFilter(dir.Files, re_pattern);
WScript.Echo("Folders in " + dir.name + " matching '" + re_pattern +"':"); walkDirectoryFilter(dir.Subfolders, re_pattern);
}
function walkDirectoryFilter(items, re_pattern) {
var e = new Enumerator(items); while (! e.atEnd()) { var item = e.item(); if (item.name.match(re_pattern)) WScript.Echo(item.name); e.moveNext(); }
}
walkDirectory(dir, '\\.txt$');</lang>
Lasso
<lang Lasso>local(matchingfilenames = array)
dir('.') -> foreach => {#1 >> 'string' ? #matchingfilenames -> insert(#1)}
- matchingfilenames</lang>
-> array(mystrings.html, a_string_file.txt)
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. <lang Lua>require "lfs" directorypath = "." -- current working directory for filename in lfs.dir(directorypath) do
if filename:match("%.lua$") then -- "%." is an escaped ".", "$" is end of string print(filename) end
end</lang>
Mathematica
The built-in function FileNames
does exactly this:
FileNames[]
lists all files in the current working directory.FileNames[form]
lists all files in the current working directory whose names match the string pattern form.FileNames[{form1,form2,...}]
lists all files whose names match any of the form_i.FileNames[forms,{dir1,dir2,...}]
lists files with names matching forms in any of the directories dir_i.FileNames[forms,dirs,n]
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): <lang Mathematica>FileNames["*"] FileNames["*.png", $RootDirectory]</lang> the result can be printed with Print /@ FileNames[....].
MAXScript
<lang maxscript>getFiles "C:\\*.txt"</lang>
Nemerle
<lang Nemerle>using System.Console; using System.IO;
module DirWalk {
Main() : void { def files = Directory.GetFiles(@"C:\MyDir"); // retrieves only files def files_subs = Directory.GetFileSystemEntries(@"C:\MyDir"); // also retrieves (but does not enter) sub-directories // (like ls command) foreach (file in files) WriteLine(file); }
}</lang>
NetRexx
<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary
import java.util.List
runSample(arg) return
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method getFileNames(dirname, pattern) public static returns List
dir = File(dirname) contents = dir.list() fileNames = ArrayList() loop fname over contents if fname.matches(pattern) then do fileNames.add(fname) end end fname Collections.sort(fileNames) return fileNames
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method runSample(arg) private static
parse arg dirname pattern if dirname = then dirname = System.getProperty('user.dir') if pattern = then pattern = '^RW.*\\.nrx$'
fileNames = getFileNames(dirname, pattern) say 'Search of' dirname 'for files matching pattern "'pattern'" found' fileNames.size() 'files.' loop fn = 0 while fn < fileNames.size() say (fn + 1).right(5)':' fileNames.get(fn) end fn return
</lang>
- Output:
Search of /Users/projects/RosettaCode/netrexx for files matching pattern "^RW.*\.nrx$" found 5 files. 1: RWalkDir_Iter.nrx 2: RWebScraping.nrx 3: RWindowCreate.nrx 4: RWriteFloatArray.nrx 5: RWriteName3D01.nrx
Nim
<lang nim>import os
for file in walkFiles "/foo/bar/*.mp3":
echo file</lang>
Objective-C
<lang objc>NSString *dir = @"/foo/bar";
// Pre-OS X 10.5 NSArray *contents = [[NSFileManager defaultManager] directoryContentsAtPath:dir]; // OS X 10.5+ NSArray *contents = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:dir error:NULL];
for (NSString *file in contents)
if ([[file pathExtension] isEqualToString:@"mp3"]) NSLog(@"%@", file);</lang>
Objeck
<lang objeck>use IO;
bundle Default {
class Test { function : Main(args : System.String[]) ~ Nil { dir := Directory->List("/src/code"); for(i := 0; i < dir->Size(); i += 1;) { if(dir[i]->EndsWith(".obs")) { dir[i]->PrintLine(); }; }; } }
}</lang>
OCaml
<lang ocaml>#load "str.cma" 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</lang>
Oz
<lang oz>declare
[Path] = {Module.link ['x-oz://system/os/Path.ozf']} [Regex] = {Module.link ['x-oz://contrib/regex']}
Files = {Filter {Path.readdir "."} Path.isFile} Pattern = ".*\\.oz$" MatchingFiles = {Filter Files fun {$ File} {Regex.search Pattern File} \= false end}
in
{ForAll MatchingFiles System.showInfo}</lang>
Pascal
<lang pascal>{$H+}
program Walk;
uses SysUtils;
var Res: TSearchRec;
Pattern, Path, Name: String; FileAttr: LongInt; Attr: Integer;
begin
Write('File pattern: '); ReadLn(Pattern); { For example .\*.pas } Attr := faAnyFile; if FindFirst(Pattern, Attr, Res) = 0 then begin Path := ExtractFileDir(Pattern); repeat Name := ConcatPaths([Path, Res.Name]); FileAttr := FileGetAttr(Name); if FileAttr and faDirectory = 0 then begin { Do something with file name } WriteLn(Name); end until FindNext(Res) <> 0; end; FindClose(Res);
end.</lang>
Perl
<lang perl>use 5.010;
my $pattern = qr{ \A a }xmso; # match files whose first character is 'a'
opendir my $dh, 'the_directory';
say for grep { $pattern } readdir $dh;
closedir $dh;</lang>
Or using globbing, with the <>
operator,
<lang perl>use 5.010; say while </home/foo/bar/*.php>;</lang>
Or the same with the builtin glob()
function,
<lang perl>my @filenames = glob('/home/foo/bar/*.php');</lang>
The glob()
function takes any expression for its pattern, whereas <>
is only for a literal.
<lang perl>my $pattern = '*.c';
my @filenames = glob($pattern);</lang>
Perl 6
The dir
function takes the directory to traverse, and optionally a named parameter test
, which can for example be a regex:
<lang perl6>.say for dir(".", :test(/foo/))</lang>
PHP
<lang php>$pattern = 'php'; $dh = opendir('c:/foo/bar'); // Or '/home/foo/bar' for Linux while (false !== ($file = readdir($dh))) {
if ($file != '.' and $file != '..') { if (preg_match("/$pattern/", $file)) { echo "$file matches $pattern\n"; } }
} closedir($dh);</lang> Or: <lang php>$pattern = 'php'; foreach (scandir('/home/foo/bar') as $file) {
if ($file != '.' and $file != '..') { if (preg_match("/$pattern/", $file)) { echo "$file matches $pattern\n"; } }
}</lang>
<lang php>foreach (glob('/home/foo/bar/*.php') as $file){
echo "$file\n";
}</lang>
PicoLisp
<lang PicoLisp>(for F (dir "@src/") # Iterate directory
(when (match '`(chop "s@.c") (chop F)) # Matches 's*.c'? (println F) ) ) # Yes: Print it</lang>
- Output:
"start.c" "ssl.c" "subr.c" "sym.c" ...
Pike
<lang pike>array(string) files = get_dir("/home/foo/bar"); foreach(files, string file)
write(file + "\n");</lang>
Pop11
Built-in procedure sys_file_match searches directories (or directory trees) using shell-like patterns: <lang pop11>lvars repp, fil;
- create path repeater
sys_file_match('*.p', , false, 0) -> repp;
- iterate over files
while (repp() ->> fil) /= termin do
;;; print the file printf(fil, '%s\n');
endwhile;</lang>
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":
<lang powershell>Get-ChildItem *.txt -Name
Get-ChildItem f* -Name</lang>
The -Name
parameter tells the Get-ChildItem
to return only the file names as string, otherwise a complete FileInfo
or DirectoryInfo
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 Where-Object
cmdlet. The following will output all file names that contain at least one vowel:
<lang powershell>Get-ChildItem -Name | Where-Object { $_ -match '[aeiou]' }</lang>
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). <lang PureBasic>Procedure walkDirectory(directory.s = "", pattern.s = "")
Protected directoryID directoryID = ExamineDirectory(#PB_Any,directory,pattern) If directoryID While NextDirectoryEntry(directoryID) PrintN(DirectoryEntryName(directoryID)) Wend FinishDirectory(directoryID) EndIf
EndProcedure
If OpenConsole()
walkDirectory() Print(#CRLF$ + #CRLF$ + "Press ENTER to exit") Input() CloseConsole()
EndIf</lang>
Python
The glob library included with Python lists files matching shell-like patterns: <lang python>import glob for filename in glob.glob('/foo/bar/*.mp3'):
print filename</lang>
Or manually: <lang python>import os for filename in os.listdir('/foo/bar'):
if filename.endswith('.mp3'): print filename</lang>
R
<lang R>dir("/foo/bar", "mp3")</lang>
Racket
<lang Racket> -> (for ([f (directory-list "/tmp")] #:when (regexp-match? "\\.rkt$" f))
(displayln f))
... *.rkt files ... </lang>
Raven
<lang raven>'dir://.' open each as item
item m/\.txt$/ if "%(item)s\n" print</lang>
Rascal
<lang rascal>import IO; public void Walk(loc a, str pattern){ for (entry <- listEntries(a)) endsWith(entry, pattern) ? println(entry); }</lang>
REXX
The following program was tested in a DOS window under Windows/XP and should work for all Microsoft Windows. <lang rexx>/*REXX program shows files in directory tree that match a given criteria*/ parse arg xdir; if xdir= then xdir='\' /*Any DIR? Use default.*/ @.=0 /*default in case ADDRESS fails. */ trace off /*suppress REXX err msg for fails*/ address system 'DIR' xdir '/b /s' with output stem @. /*issue DIR cmd.*/ if rc\==0 then do /*an error happened?*/
say '***error!*** from DIR' xDIR /*indicate que pasa.*/ say 'return code=' rc /*show the Ret Code.*/ exit rc /*exit with the RC.*/ end /* [↑] bad address.*/
- =@.rc /*number of entries.*/
if #==0 then #=' no ' /*use a word, ¬zero.*/ say center('directory ' xdir " has " # ' matching entries.',79,'─')
do j=1 for #; say @.j; end /*show files that met criteria. */
exit @.0+rc /*stick a fork in it, we're done.*/</lang>
Ruby
<lang ruby># Files under this directory: Dir.glob('*') { |file| puts file }
- Files under path '/foo/bar':
Dir.glob( File.join('/foo/bar', '*') ) { |file| puts file }
- As a method
def file_match(pattern=/\.txt/, path='.')
Dir[File.join(path,'*')].each do |file| puts file if file =~ pattern end
end</lang>
Scala
<lang Scala>import java.io.File
val dir = new File("/foo/bar").list() dir.filter(file => file.endsWith(".mp3")).foreach(println)</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
include "osfiles.s7i";
const proc: main is func
local var string: fileName is ""; begin for fileName range readDir(".") do if endsWith(fileName, ".sd7") then writeln(fileName); end if; end for; end func;</lang>
Sidef
<lang ruby>'*.p[lm]'.glob.each { |file| say file }; # Perl files under this directory</lang>
- Output:
x.pl x.pm
<lang ruby>func file_match(callback is Block, pattern=/\.txt\z/, path=Dir.cwd) {
path.open(\var dir_h) || return; dir_h.entries.each { |entry| if (entry.basename ~~ pattern) { callback(entry); } }
}
file_match(
path: %d'/tmp', pattern: /\.p[lm]\z/i, callback: { |file| say file; }
);</lang>
- Output:
/tmp/x.pl /tmp/x.pm
Smalltalk
<lang smalltalk>(Directory name: 'a_directory')
allFilesMatching: '*.st' do: [ :f | (f name) displayNl ]</lang>
Tcl
For the current directory: <lang tcl>foreach filename [glob *.txt] {
puts $filename
}</lang> For an arbitrary directory: <lang tcl>set dir /foo/bar foreach filename [glob -directory $dir *.txt] {
puts $filename ### Or, if you only want the local filename part... # puts [file tail $filename]
}</lang>
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. <lang toka>needs shell " ." " .\\.txt$" dir.listByPattern</lang>
TUSCRIPT
<lang tuscript>$$ MODE TUSCRIPT files=FILE_NAMES (+,-std-) fileswtxt= FILTER_INDEX (files,":*.txt:",-) txtfiles= SELECT (files,#fileswtxt)</lang>
- Output:
files DEST'MAKROS'ROSETTA.TXT'SKRIPTE'STUDENTS.XML'TUSTEP.INI fileswtxt 3 txtfiles ROSETTA.TXT
Visual Basic .NET
<lang vbnet>'Using the OS pattern matching For Each file In IO.Directory.GetFiles("\temp", "*.txt")
Console.WriteLine(file)
Next
'Using VB's pattern matching and LINQ For Each file In (From name In IO.Directory.GetFiles("\temp") Where name Like "*.txt")
Console.WriteLine(file)
Next
'Using VB's pattern matching and dot-notation For Each file In IO.Directory.GetFiles("\temp").Where(Function(f) f Like "*.txt")
Console.WriteLine(file)
Next</lang>
UNIX Shell
<lang bash>ls -d *.c # *.c files in current directory
(cd mydir && ls -d *.c) # *.c files in mydir</lang>
*.c
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.
If there are no *.c files, ls
fails with an error message.
UnixPipes
Here using grep for regexp. <lang bash>ls | grep '\.c$'</lang>
zkl
Unix glob, with wildcarding and options on file type, case folding and a few others. <lang zkl>File.glob("*.zkl") //--> list of matches</lang>
Zsh
Zsh has powerful filename generation features, which can filter by file names, permissions, size, type, etc. <lang bash>print -l -- *.c</lang>
- Programming Tasks
- File System Operations
- 8th
- 68000 Assembly
- Ada
- ALGOL 68
- AppleScript
- AutoHotkey
- BASIC
- Batch File
- BBC BASIC
- C
- POSIX
- C++
- Boost
- C sharp
- ColdFusion
- Common Lisp
- D
- DCL
- E
- Emacs Lisp
- Erlang
- Euphoria
- F Sharp
- Factor
- Forth
- Go
- Groovy
- Haskell
- HicEst
- IDL
- Icon
- Unicon
- J
- Java
- JavaScript
- Lasso
- Lua
- Mathematica
- MAXScript
- Nemerle
- NetRexx
- Nim
- Objective-C
- Objeck
- OCaml
- Oz
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- Pike
- Pop11
- PowerShell
- PureBasic
- Python
- R
- Racket
- Raven
- Rascal
- REXX
- Ruby
- Scala
- Seed7
- Sidef
- Smalltalk
- Tcl
- Toka
- TUSCRIPT
- Visual Basic .NET
- UNIX Shell
- UnixPipes
- Zkl
- Zsh
- AWK/Omit
- Bc/Omit
- Befunge/Omit
- Dc/Omit
- GUISS/Omit
- M4/Omit
- Make/Omit
- PARI/GP/Omit
- Retro/Omit
- TI-89 BASIC/Omit
- Unlambda/Omit
- Axe/Omit