Walk a directory/Recursively: Difference between revisions

*   [[Walk a directory/Non-recursively]]   (read a ''single directory'').

<br><br>

 

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

"*.c" f:rglob \ top of stack now has list of all "*.c" files, recursively

 

=={{header|Ada}}==

with Ada.Text_IO;

 

begin

Walk (".", "*.adb");

The solution first enumerates files in a directory, that includes the subdirectories, if their names match the pattern. Then it steps down into each of the subdirectories. The pseudo directories . and .. are excluded. The behavior upon symbolic links depends on the [[OS]] and the implementation of the Ada.Directories package.

 

{{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 slash = "/", pwd=".", parent="..";

FI;

 

{{out|Sample output}}

<pre>

=={{header|Arturo}}==

 

print list.recursive "."

 

; just select the files that contain "test"

select list.recursive "some/path"

 

=={{header|AutoHotkey}}==

Display all TMP files in Temp directory and its subdirectories.

out .= A_LoopFileName "`n"

 

=={{header|BaCon}}==

This line will recursively walk though all directories starting from the current directory ".":

 

=={{header|Batch File}}==

A sample code that displays all the EXE files in System32 directory recursively.

----

If you wanted to apply some command to each item in a directory tree, then use <code>FOR</code> with the switch <code>/R</code>. For example, to apply the ECHO command to every DLL file in C:\Windows\System32:

{{works with|Windows NT|4 or later (includes Windows XP and onward)}}

This can be done from outside a batch file (entered directly at the command prompt) by changing the double percent signs (%%) to single percents (%):

 

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

{{works with|BBC BASIC for Windows}}

pattern$ = "*.chm"

PROClisttree(directory$, pattern$)

SYS "FindClose", sh%

ENDIF

 

=={{header|C}}==

==={{libheader|POSIX}}===

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

#include <sys/stat.h>

#include <unistd.h>

}

return 0;

==={{libheader|BSD libc}}===

With the [http://www.openbsd.org/cgi-bin/man.cgi?query=fts&apropos=0&sektion=3&manpath=OpenBSD+Current&arch=i386&format=html fts(3)] functions from 4.4BSD, this program can sort the files, and can also detect cycles (when a link puts a directory inside itself). This program makes a ''logical traversal'' that follows symbolic links to directories.

{{works with|OpenBSD|4.9}}

#include <err.h>

#include <errno.h>

pmatch(".", "*.c");

return 0;

=== [[Windows]] ===

{{libheader|Win32}}

{{works with|MinGW}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

 

=={{header|C sharp|C#}}==

using System.Collections.Generic;

using System.IO;

}

}

 

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

{{libheader|boost}}

#include "boost/regex.hpp"

#include <iostream>

std::cout << iter->path() << "\n";

}

 

{{libheader|std|C++17}}

#include <filesystem>

#include <iostream>

std::cout << file.path().filename().string() << std::endl;

}

 

=={{header|Caché ObjectScript}}==

 

Class Utils.File [ Abstract ]

{

 

}

 

{{out|Example}}

=={{header|Clojure}}==

The standard function ''file-seq'' does a tree walk.

 

(defn walk [dirpath pattern]

 

(map #(println (.getPath %)) (walk "src" #".*\.clj"))

 

=={{header|CoffeeScript}}==

{{works with|node.js}}

 

walk = (dir, f_match, f_visit) ->

matcher = (fn) -> fn.match /\.coffee/

action = console.log

 

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

{{libheader|CL-FAD}}

This example uses the <code>CL-FAD</code> library to achieve compatibility where the ANSI CL standard leaves ambiguities about pathnames. Quicklisp is used to ensure it is loaded. Traversal is depth-first unless <code>:depth-first-p nil</code> is passed.

(defun mapc-directory-tree (fn directory &key (depth-first-p t))

(dolist (entry (cl-fad:list-directory directory))

(when depth-first-p

(funcall fn entry))))

 

(when (equal (pathname-type x) "lisp")

(write-line (namestring x))))

/home/sthalik/lang/lisp/box-muller.lisp

/home/sthalik/lang/lisp/displaced-subseq.lisp

 

=={{header|D}}==

import std.stdio, std.file;

 

// a depth-first scan):

dirEntries("", "*.d", SpanMode.breadth).writeln;

=={{header|Delphi}}==

{{libheader| System.IOUtils}}

program Walk_a_directory;

 

end.

 

=={{header|E}}==

for name => file in directory {

if (name =~ rx`.*$pattern.*`) {

}

}

{{out|Example}}

/usr/share/man/man1/rmdir.1

 

=={{header|Elixir}}==

def recursive(dir \\ ".") do

Enum.each(File.ls!(dir), fn file ->

end

 

 

{{out}}

 

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

 

=={{header|Erlang}}==

 

{{out}}

walk_dir(Path, Pattern) ->

filelib:fold_files(

[]

)

 

% Collect every file in the current directory

walkdir:walk_dir(".", ".*").

% Collect every file my .config folder that ends with `rc`

walkdir:walk_dir("/home/me/.config/", ".*rc$").

 

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

This code is tail-recursive and lazy.

 

let rec getAllFiles dir pattern =

 

getAllFiles "c:\\temp" "*.xml"

 

=={{header|Factor}}==

 

"." t [

dup ".factor" tail? [ print ] [ drop ] if

 

=={{header|Forth}}==

{{works with|gforth|0.7.9}}

require unix/filestat.fs

require unix/libc.fs

 

s" ." ls-r cr

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=f48f8d5c2e2e85a8f80bcdc0124a35a5 Click this link to run this code]'''

Dim sTemp As String

Next

 

Output:

<pre>

 

=={{header|GAP}}==

local dir, file, e;

dir := Directory(name);

 

# This will print filenames

 

=={{header|Go}}==

 

import (

func main() {

filepath.Walk("/", VisitFile)

 

=={{header|Groovy}}==

Search text files in current directory tree in a depth-first fashion:

 

if (it.name =~ /.*\.txt/) println it;

 

Shorter variant:

 

Variant processing only files:

 

Flexible search, traversal can be adapted by providing various options in the options Map, see documentation of method:

[http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/File.html#traverse(java.util.Map,%20groovy.lang.Closure) traverse(Map options, Closure closure)]

type : FILES,

nameFilter : ~/.*\.txt/,

preDir : { if (it.name == '.svn') return SKIP_SUBTREE },

) { println it }

 

=={{header|GUISS}}==

Here we list all files that match the pattern m*.txt in "My Documents" and all of its subfolders:

 

=={{header|Haskell}}==

Using the packages [http://hackage.haskell.org/package/directory-1.2.5.0/docs/System-Directory.html#v:getCurrentDirectory directory] and [https://hackage.haskell.org/package/filemanip-0.3.6.3/docs/System-FilePath-Find.html#v:find filemanip]

 

import System.Directory

import System.FilePath.Find

dir <- getCurrentDirectory

files <- search pat dir

or more classic way:

import System.Directory

import System.IO

| takeExtension fname == ".hs" = putStrLn fname

| otherwise = return ()

 

== Icon and Unicon ==

Icon doesn't support 'stat' or 'open' of a directory; however, information can be obtained by use of the <code>system</code> function to access command line.

==={{header|Unicon}}===

###########################

# A sequential solution #

return D

}

 

=={{header|IDL}}==

This will descend down the directory/ies in the variable <tt>"directory"</tt> (which can be an array) returning an array of strings with the names of the files matching "*.txt" and placing the total number of matches into the variable <tt>"cc"</tt>

 

=={{header|J}}==

 

The verb <tt>dirtree</tt> returns a file listing of a directory tree as a boxed matrix with file names in the first column. The primitives <tt>>{."1</tt> will return the unboxed contents of the first column.

{{works with|Java|1.4+}}

Done using no pattern. But with end string comparison which gave better results.

 

public class MainEntry {

}

}

{{works with|Java|7+}}

Luckily, <code>java.nio.file.Files</code> gives us a <code>walkFileTree</code> method that does exactly what this task calls for.

import java.nio.file.*;

import java.nio.file.attribute.BasicFileAttributes;

});

}

{{works with|Java|8+}}

import java.nio.file.*;

 

}

}

 

=={{header|JavaScript}}==

{{works with|JScript}}

 

function walkDirectoryTree(folder, folder_name, re_pattern) {

}

 

 

=={{header|Julia}}==

{{works with|Julia|1.2}}

 

pattern = r".mp3$"

 

if occursin(pattern, file) println(file) end

end

 

=={{header|Kotlin}}==

 

import java.io.File

for (file in files) println(file)

}

 

Output (Ubuntu 14.04):

 

=={{header|Lasso}}==

define dir -> eachVisibleFilePath() => {

return with name in self -> eachEntry where #name -> second != io_dir_dt_dir where not(#name -> first -> beginswith('.')) select .makeFullPath(#name -> first)

do #matchingfilenames -> insert(#filename)

 

-> array(myfile.lasso, test.lasso, rosetta.lasso)

 

=={{header|LiveCode}}==

 

Example

Output

 

=={{header|Lua}}==

Lua itself is extremely spartanic as it is meant for embedding. As lfs (LuaFileSystem) is about as standard an extension as it gets, we use that.

 

-- This function takes two arguments:

for f in find("directory", function(self) return "directory" == lfs.attributes(self, "mode") end) do

print(f)

 

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

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, find all files on the hard drive):

FileNames["*.png", $RootDirectory]

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

 

=={{header|MATLAB}} / {{header|Octave}}==

f = dir(fullfile(d,pattern));

for k = 1:length(f)

end;

end;

 

=={{header|MAXScript}}==

(

dirArr = GetDirectories (dir + "\\*")

)

 

 

=={{header|MoonScript}}==

MoonScript compiles to Lua, which itself is extremely spartanic as it is meant for embedding. As lfs (LuaFileSystem) is about as standard an extension as it gets, we use that.

 

 

-- This function takes two arguments:

 

-- List directories

 

=={{header|Nanoquery}}==

 

def get_files(dirname)

println file

end

 

=={{header|Nim}}==

The “os” standard module provides an iterator to walk recursively a directory. The iterator allows some filtering about the kind of entry to consider: real files (default), symbolic links to files, directories, symbolic links to directories. It doesn’t allow to specify a pattern, so filtering on name should be done using another mechanism (for instance, regular expressions).

 

 

for file in walkDirRec "/":

if file.match re".*\.mp3":

 

=={{header|Objeck}}==

 

class Test {

};

}

 

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

NSDirectoryEnumerator *de = [[NSFileManager defaultManager] enumeratorAtPath:dir];

 

for (NSString *file in de)

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

 

=={{header|OCaml}}==

#load "unix.cma"

#load "str.cma"

let results = walk_directory_tree "/usr/local/lib/ocaml" ".*\\.cma" in

List.iter print_endline results;

 

=={{header|ooRexx}}==

===version 1===

* List all file names on my disk D: that contain the string TTTT

*--------------------------------------------------------------------*/

If pos('TTTT',translate(file.i))>0 Then

say file.i

{{out}}

<pre>1127869 files on disk

===version 2===

Get only files matching the file-spec.

* List all file names on my disk D: that contain the string TTTT

*--------------------------------------------------------------------*/

If pos('TTTT',translate(file.i))>0 Then

say file.i

{{out}}

<pre>3 files found

 

=={{header|Oz}}==

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

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

end

in

 

=={{header|Perl}}==

 

{{works with|Perl|5.x}}

my $dir = '.';

my $pattern = 'foo';

my $callback = sub { print $File::Find::name, "\n" if /$pattern/ };

 

Or if you need maximum performance and are on a 'nix system, open a pipe to the GNU <tt>find</tt> program:

 

 

sub find_files {

}

 

 

=={{header|Phix}}==

There is a builtin routine for this, walk_dir() - if interested you can find the full implementation in builtins\file.e (an autoinclude).

 

<span style="color: #008080;">function</span> <span style="color: #000000;">find_pfile</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">pathname</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">dirent</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">if</span> <span style="color: #7060A8;">match</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"pfile.e"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">dirent</span><span style="color: #0000FF;">[</span><span style="color: #000000;">D_NAME</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">then</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">walk_dir</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"C:\\Program Files (x86)\\Phix"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">find_pfile</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>

 

Passing 1 as the third parameter makes it scan recursively.

 

=={{header|PHP}}==

$prefix = $dir . '/';

$dir = dir($dir);

}

}

This implementation uses Perl compatible regular expressions to match the whole path of the file

 

===PHP BFS (Breadth First Search)===

This script performs a BFS search with recursion protection

it is often faster to search using this method across a

}

closedir($dh);

 

=={{header|PicoLisp}}==

(recur (Dir)

(for F (dir Dir)

(recurse Path) ) # Yes: Recurse

((match '`(chop "s@.l") (chop F)) # Matches 's*.l'?

{{out}}

<pre>"./src64/sym.l"

=={{header|Pop11}}==

Built-in procedure <code>sys_file_match</code> searches directories or directory trees using shell-like patterns (three dots indicate search for subdirectory tree).

;;; create path repeater

sys_file_match('.../*.p', '', false, 0) -> repp;

;;; print the path

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

 

=={{header|PowerShell}}==

In PowerShell the <code>Get-ChildItem</code> cmdlet allows for recursive filtering on file names with simple wildcards:

For more complex filtering criteria the result of <code>Get-ChildItem</code> can be piped into the <code>Where-Object</code> cmdlet:

To perform an action on every matching file the results can be piped into the <code>ForEach-Object</code> cmdlet:

Where-Object { $_.Name -match 'foo[0-9]' } |

''Note:'' To include only ''files'' instead of directories too each of the above needs an additional<code>Where-Object</code> filter:

 

 

=={{header|Prolog}}==

{{works with|Swi-Prolog|8.3}}

% submitted by Aykayayciti (Earl Lamont Montgomery)

% altered from fsaenzperez April 2019

;

format('Unknown: ~w~n',[File])

 

output :

File: GMFBridge.ax

File: libeay32.dll

File: MS-PL.txt

File: MSR-SSLA.txt

 

 

 

=={{header|PureBasic}}==

Static RegularExpression

If Not RegularExpression

EndIf

Wend

ExamineDirectory(1,"C:\WINDOWS\","")

WalkRecursive(1,"C:\WINDOWS\","\.log$")

 

 

=={{header|Prolog}}==

{{works with|Swi-Prolog|8.3}}

% altered from fsaenzperez April 2019

% (swi-prolog.discourse-group)

;

format('Unknown: ~w~n',[File])

 

output :

File: GMFBridge.ax

File: libeay32.dll

File: MS-PL-Eula.rtf

File: MS-PL.txt

 

=={{header|Python}}==

{{works with|Python|3.x}}

Use the standard [https://docs.python.org/3/library/pathlib.html#pathlib.Path.rglob pathlib.Path.rglob()] module to recursively walk a directory with optional filter.

from pathlib import Path

 

for path in Path('.').rglob('*.*'):

print(path)

 

{{works with|Python|3.x}}

{{works with|Python|2.3+}}

This uses the standard [http://docs.python.org/py3k/library/os.html?highlight=os.walk#os.walk os.walk()] module function to walk a directory tree, and the [http://docs.python.org/py3k/library/fnmatch.html fnmatch] module for matching file names.

import os

 

for root, dirs, files in os.walk(rootPath):

for filename in fnmatch.filter(files, pattern):

{{works with|Python|<nowiki>2.x</nowiki>}}

{{works with|Python|<nowiki>3.x</nowiki>}}

A more strictly comparable port of this 2.3+ code to earlier versions of Python would be:

import os, os.path

 

print os.path.join(dir, filename)

 

The old ''os.path.walk'' function was a challenge for many to use because of the need to pass a function into the walk, and any arguments to that function through to it ... as shown. It's sometimes useful to pass mutable objects (lists, dictionaries, or instances of user-defined classes) to the inner function ... for example, to collect all the matching files for later processing.

 

{{libheader|Path}}

(''Note:'' This uses a non-standard replacement to the '''os.path''' module)

 

rootPath = '/'

d = path(rootPath)

for f in d.walkfiles(pattern):

 

=={{header|R}}==

 

=={{header|Racket}}==

 

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

(displayln f))

... *.rkt files including in nested directories ...

 

=={{header|Raku}}==

 

Using the [https://github.com/tadzik/File-Find/ File::Find] module:

 

 

Alternatively, a custom solution that provides the same interface as the built-in (non-recursive) <tt>dir</tt> function, and uses <tt>gather</tt>/<tt>take</tt> to return a lazy sequence:

 

gather for dir $dir -> $path {

if $path.basename ~~ $test { take $path }

}

 

Or if you value performance over portability, here's a function that runs the GNU <tt>find</tt> program and returns a lazy sequence of the files it finds. Parameters are not subjected to shell expansion, and the null-byte (which cannot be present in file paths) is used as the path delimiter, so it should be pretty safe.

 

run('find', $dir, '-iname', $pattern, '-print0', :out, :nl«\0»).out.lines;

}

 

 

=={{header|Rascal}}==

module Walk

import String;

elseif (isDirectory(a+entry))

Walk(a+entry, pattern);

 

=={{header|REALbasic}}==

For i As Integer = 1 To parentDir.Count

If parentDir.Item(i).Directory Then

End If

Next

Accepts a FolderItem object and a Regex pattern as a string:

Dim f As FolderItem = GetFolderItem("C:\Windows\system32")

Dim pattern As String = "((?:[a-z][a-z]+))(\.)(dll)" //all file names ending in .dll

 

=={{header|Red}}==

 

walk: func [

]

 

 

=={{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 specified? Then use default.*/

@.=0 /*default result in case ADDRESS fails.*/

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

end /*j*/

'''output''' &nbsp; when the following was used: &nbsp; <tt> I:\firefox*.exe </tt>

<pre>

{{trans|BATCH-file}}

Works on Windows with ooRexx and Regina (not much REXX code in it)

 

=={{header|Ring}}==

see "Testing DIR() " + nl

mylist = dir("C:\Ring")

next

see "Files count : " + len(mylist)

Output:

<pre>

Using the Find core Module:

 

 

Find.find('/your/path') do |f|

# print file and path to screen if filename ends in ".mp3"

puts f if f.match(/\.mp3\Z/)

 

A little less verbose example using a shortcut for the glob method of Dir:

 

 

=={{header|Rust}}==

Using std::fs::walk_dir (unstable as of Rust 1.1) with imperative for-loop:

 

 

use std::fs;

}

}

 

=={{header|Scala}}==

This is not implemented in the Scala library. Here is a simple solution, building on [[Java]] class ''<code>java.io.File</code>'':

 

 

object `package` {

for(f <- walkTree(dir)) println(f)

for(f <- walkTree(dir) if f.getName.endsWith(".mp3")) println(f)

 

=={{header|Scheme}}==

Varies slightly depending on the implementation of scheme.

{{works with|Chicken Scheme}}

(use files)

(use srfi-13)

(FN MYPATH) )))) (directory PATH #t) ))

 

See also: '''(find-files ...)''' function in the '''posix''' module.

{{works with|Gauche}}

(use srfi-13)

 

(FN MYPATH) )))) (directory-list PATH :add-path? #t :children? #t ) ))

 

See also: '''(find-file-in-paths ...)''' function in the '''file.util''' module.

{{works with|PLT Scheme}}

 

(require srfi/13)

(FN MYPATH) )))) (directory-list PATH)))

 

See also: '''(find-files ...)''' function in the '''file''' module.

{{out|Sample output}}

[http://seed7.sourceforge.net/libraries/osfiles.htm#fileType%28in_string%29 fileType].

 

include "osfiles.s7i";

 

begin

walkDir(".", ".sd7");

 

=={{header|Sidef}}==

dir.open(\var dir_h) || return nil

 

}

} => dir

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

wholeContent: aPattern do: twoBlock [

self wholeContent: aPattern withLevel: 0 do: twoBlock.

]

]

 

d := Directory name: '.'.

d wholeContent: '\.st$' do: [ :f :l |

0 to: l do: [ :i | (Character tab) display ].

f displayNl

 

=={{header|Swift}}==

{{works with|Swift|3.0}}

 

let fileSystem = FileManager.default

}

}

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

package require fileutil

proc walkin {path cmd} {

}

}}}

 

=={{header|TXR}}==

There is more than one way to do this in TXR. A recursive walk could be coded using <code>open-directory</code> and <code>getline</code>. Or FFI could be used to gain access to some platform-specific functions like Microsoft's <code>FindFirstFile</code> and so forth.

 

TXR wraps and exposes the POSIX <code>nftw</code> function, which is demonstrated here. This function encapsulates a tree walk, and uses callbacks to inform the program of visited filesystem tree nodes, and of error situations. We can use a <code>lambda</code> for the code walk, or wrap the invocation of <code>ftw</code> with a macro which hides the <code>lambda</code> syntax.

 

Here we use the <code>build</code> macro for procedural list building to gather all of the found paths into a list, which is implicitly returned. The callback is an explicit <code>lambda</code>:

 

(if (ends-with ".tl" path)

 

{{out}}

 

"./tests/sock-common.tl" "./tests/012/ifa.tl" "./tests/012/except.tl"

"./tests/012/fini.tl" "./tests/012/oop.tl" "./tests/012/circ.tl"

"./share/txr/stdlib/struct.tl" "./share/txr/stdlib/getput.tl"

"./share/txr/stdlib/path-test.tl" "./share/txr/stdlib/with-resources.tl"

 

For a regex pattern we can replace <code>(endswith ".tl" path)</code> with something like <code>(m$ path #/\.tl/)</code>.

 

A nice approach would be to capture a continuation in the callback, and then obtain the walk elements lazily; alas, capturing a continuation from a C library function's callback is not permitted, because the capture would span foreign stack frames.

 

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

The "find" command gives a one-line solution for simple patterns:

"find" can also be used to find files matching more complex patterns as illustrated in the section on [[#UnixPipes|Unix Pipes]] below.

 

Using "bash" version 4 or later, you can use "globstar" or "dotglob", depending on whether you want hidden directories to be searched:

# Warning: globstar excludes hidden directories.

# Turn on recursive globbing (in this script) or exit if the option is not supported:

echo "$f"

fi

Here is a solution that does not use "find".

 

indent_print()

}

 

A simplified version that gives the same output:

walk_tree() {

}

 

=={{header|UnixPipes}}==

As illustrated [[#UNIX Shell|above]], the "find" command can be used with the -name option to match simple patterns. To find files matching more complex patterns, the results of "find" can be piped, e.g.

One way to run a command against each file that is found is to use "xargs", but if there is any possibility that a filename contains a space or tab character, then the following model should be used:

 

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

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

This uses the OS pattern matching

For Each file In directory.GetFiles(pattern)

Console.WriteLine(file.FullName)

walkTree(subDir, pattern)

Next

 

=={{header|zkl}}==

Lots of options, here I'm using the defaults: recurse, just file matches (not directory names) and return a bit bucket of ASCIIZ strings.

{{out}}

</pre>

globular will write to a object that has a write method or just call a method or function, which is nice for sending data to other threads (eg multi-threaded find/grep). To do the above example in one shot (without saving the results):

 

=={{header|Zsh}}==

Zsh has recursive globbing. The GLOB_DOTS option allows files beginning with a period to be matched.

GLOB_DOTS can be set temporarily with the 'D' modifier.

 

{{omit from|ACL2|Very limited filesystem support.}}