Walk a directory/Non-recursively: Difference between revisions

{{task|File System Operations}}

 

 

'''Note:''' Please be careful when running any code presented here.

 

=={{header|Ada}}==

{{works with|GCC|4.12}}

with Ada.Text_IO; use Ada.Text_IO;

 

 

End_Search (Search);

 

=={{header|ALGOL 68}}==

{{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(".");

print((file, new line))

FI

{{out|Sample output}}

<pre>

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:

To list all pdf files in user's home directory:

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:

The Finder also supports the <code>entire contents</code> modifier keyword, which effectively performs a recursive directory scan without recursion.

 

=={{header|AutoHotkey}}==

Display all INI files in Windows directory.

out .= A_LoopFileName "`n"

 

=={{header|BASIC}}==

 

DOS wildcards are rather underpowered when compared to... well... anything else.

 

show "*.*"

f = DIR$

LOOP

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

pattern$ = "*.ini"

PROClistdir(directory$ + pattern$)

SYS "FindClose", sh%

ENDIF

 

=={{header|C}}==

{{works with|POSIX|.1-2001}}

In this example, the pattern is a [[POSIX]] extended regular expression.

#include <dirent.h>

#include <regex.h>

walker(".", ".\\.c$");

return 0;

 

=={{header|C++}}==

{{libheader|boost|1.50.0}}

#include "boost/regex.hpp"

#include <iostream>

}

}

 

 

 

=={{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>

 

=={{header|Common Lisp}}==

Uses the filename pattern syntax provided by the CL implementation.

 

=={{header|D}}==

 

 

 

=={{header|E}}==

for name => file ? (name =~ rx`.*$pattern.*`) in directory {

println(name)

}

Example:

.bash_history

.bash_profile

 

=={{header|Emacs Lisp}}==

directory, optionally restricted to those matching a regexp.

 

nil ;; just the filenames, not full paths

"\\.c\\'" ;; regexp

t) ;; don't sort the filenames

 

=={{header|Euphoria}}==

 

procedure show(sequence pattern)

end procedure

 

 

=={{header|F_Sharp|F#}}==

 

=={{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

Ex:

( scratchpad ) "." "*.txt" print-files

{{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] . <> ;

' c-file? is ls-filter

 

 

=={{header|Go}}==

 

import (

func main() {

fmt.Println(filepath.Glob("*.go"))

 

=={{header|Groovy}}==

new File('.').eachFileMatch(~/.*\.txt/) {

println it

new File('/foo/bar').eachFileMatch(~/.*\.txt/) {

println it

 

=={{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

mapM_ putStrLn $ filter (isJust.(matchRegex $ mkRegex pattern)) filenames

 

 

=={{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

! 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

 

=={{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

close(d)

}

 

=={{header|J}}==

0 dir '*.png'

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"))

 

=={{header|JavaScript}}==

{{works with|JScript}}

var dir = fso.GetFolder('test_folder');

 

}

 

 

=={{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

print(filename)

end

 

The built-in function <code>FileNames</code> does exactly this:

:<code>FileNames[]</code> lists all files in the current working directory.

:<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):

the result can be printed with Print /@ FileNames[....].

 

=={{header|MAXScript}}==

 

 

 

 

=={{header|Objeck}}==

 

bundle Default {

}

}

 

=={{header|OCaml}}==

let contents = Array.to_list (Sys.readdir ".") in

let select pat str = Str.string_match (Str.regexp pat) str 0 in

 

=={{header|Oz}}==

[Path] = {Module.link ['x-oz://system/os/Path.ozf']}

[Regex] = {Module.link ['x-oz://contrib/regex']}

MatchingFiles = {Filter Files fun {$ File} {Regex.search Pattern File} \= false end}

in

 

=={{header|Perl}}==

Or using globbing, with the <code>&lt;&gt;</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>&lt;&gt;</code> is only for a literal.

 

 

=={{header|PHP}}==

{{works with|PHP|5.2.0}}

$dh = opendir('c:/foo/bar'); // Or '/home/foo/bar' for Linux

while (false !== ($file = readdir($dh)))

}

}

Or:

foreach (scandir('/home/foo/bar') as $file)

{

}

}

{{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'?

{{out}}

<pre>"start.c"

 

=={{header|Pike}}==

foreach(files, string file)

 

=={{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;

;;; print the file

printf(fil, '%s\n');

 

=={{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":

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

Input()

CloseConsole()

 

=={{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'):

Or manually:

for filename in os.listdir('/foo/bar'):

if filename.endswith('.mp3'):

 

=={{header|R}}==

 

 

=={{header|Rascal}}==

public void Walk(loc a, str pattern){

for (entry <- listEntries(a))

endsWith(entry, pattern) ? println(entry);

 

=={{header|Ruby}}==

Dir.glob('*') { |file| puts file }

 

puts file if file =~ pattern

end

 

=={{header|Seed7}}==

include "osfiles.s7i";

 

end if;

end for;

 

=={{header|Smalltalk}}==

 

=={{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.

 

=={{header|TUSCRIPT}}==

files=FILE_NAMES (+,-std-)

fileswtxt= FILTER_INDEX (files,":*.txt:",-)

{{out}}

<pre>

txtfiles ROSETTA.TXT

</pre>

 

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0+}}

For Each file In IO.Directory.GetFiles("\temp", "*.txt")

Console.WriteLine(file)

For Each file In IO.Directory.GetFiles("\temp").Where(Function(f) f Like "*.txt")

Console.WriteLine(file)

 

 

 

 

=={{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")}}

{{omit from|PARI/GP}}

{{omit from|Retro}}

{{omit from|TI-89 BASIC|Does not have a filesystem, just namespaced variables, which can't be listed from a program.}}

{{omit from|Unlambda|Does not have file system support.}}