Walk a directory/Non-recursively: Difference between revisions

*   [[Walk Directory Tree]]   (read entire directory tree).

<br><br>

 

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

;

 

patternParsed

 

=={{header|8th}}==

"*.c" f:glob \ puts an array of strings with the file names on the top of the stack

 

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

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 sharp|C#}}==

using System.IO;

 

}

}

 

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

import std.stdio, std.file;

 

dirEntries(".", "*.*", SpanMode.shallow).writeln;

 

=={{header|DCL}}==

<pre>* matches any number of characters

& matches exactly any one character</pre>

$ f = f$search( p1 )

$ if f .eqs. "" then $ exit

$ write sys$output f

{{out}}

<pre>$ @walk_a_directory *.*

USERS:[DAVID]WALK_A_DIRECTORY.COM;1

$ </pre>

 

=={{header|E}}==

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

println(name)

}

Example:

.bash_history

.bash_profile

 

=={{header|Elixir}}==

IO.inspect File.ls!

 

dir = "/users/public"

 

{{out}}

directory, optionally restricted to those matching a regexp.

 

nil ;; just the filenames, not full paths

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

t) ;; don't sort the filenames

 

=={{header|Erlang}}==

 

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

(IDL is an array language - very few things are ever done in 'loops'.)

 

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

 

dir('.') -> foreach => {#1 >> 'string' ? #matchingfilenames -> insert(#1)}

 

-> array(mystrings.html, a_string_file.txt)

 

=={{header|LiveCode}}==

put the files into docfiles

filter docfiles with "*.txt"

 

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

using System.IO;

 

foreach (file in files) WriteLine(file);

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

return

{{out}}

<pre>

 

=={{header|Nim}}==

 

for file in walkFiles "/foo/bar/*.mp3":

 

=={{header|Objeck}}==

 

bundle Default {

}

}

 

=={{header|Objective-C}}==

 

// Pre-OS X 10.5

for (NSString *file in contents)

if ([[file pathExtension] isEqualToString:@"mp3"])

 

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

{{works with|Free Pascal}}

 

program Walk;

end;

FindClose(Res);

 

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

The dir function accepts a DOS pattern, with some minor variations (eg "*" gets all files with no extension).

{{out}}

<pre>

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

 

-> (for ([f (directory-list "/tmp")] #:when (regexp-match? "\\.rkt$" f))

(displayln f))

... *.rkt files ...

 

=={{header|Rascal}}==

public void Walk(loc a, str pattern){

for (entry <- listEntries(a))

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

 

=={{header|Raven}}==

 

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

do j=1 for #; say @.j; end /*show files that met criteria. */

 

 

=={{header|Ruby}}==

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

 

puts file if file =~ pattern

end

=={{header|Run BASIC}}==

if #g HASANSWER() then

next

end if

FILE ACCESSOR methods

 

 

=={{header|Rust}}==

extern crate regex;

extern crate rustc_serialize;

}

}

 

=={{header|Scala}}==

 

val dir = new File("/foo/bar").list()

 

=={{header|Seed7}}==

include "osfiles.s7i";

 

end if;

end for;

 

=={{header|Sidef}}==

{{out}}

<pre>

</pre>

 

dir_h.entries.each { |entry|

if (entry.basename ~~ pattern) {

}

}

}

file_match(

path: %d'/tmp',

say file;

}

{{out}}

<pre>

 

=={{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|UNIX Shell}}==

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

 

=={{header|UnixPipes}}==

Here using grep for regexp.

 

=={{header|VBScript}}==

Sub show_files(folder_path,pattern)

Set objfso = CreateObject("Scripting.FileSystemObject")

 

Call show_files("C:\Windows",".exe")

 

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

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