Walk a directory/Recursively: Difference between revisions

Walk a given directory ''tree'' and print files matching a given pattern.

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

=={{header|Ada}}==

<lang ada>with Ada.Directories; use Ada.Directories;

walk tree(".", match sort a68 and print)</lang>

<pre>

./Shell_sort_c.a68

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

<lang dos>dir /a-d %1</lang>

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

<lang dos>FOR /R C:\Windows\System32 %%F IN (*.DLL) DO ECHO "%%F"</lang>

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

<lang dos>FOR /R C:\Windows\System32 %F IN (*.DLL) DO ECHO "%F"</lang>

return 0;

}</lang>

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

<lang c>#include <sys/types.h>

return 0;

}</lang>

=== [[Windows]] ===

{{libheader|Win32}}

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

<lang lisp>(defun mapc-directory-tree (fn directory)

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

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

namespace ConsoleApplication1

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

{{libheader|boost}}

<lang cpp>#include "boost/filesystem.hpp"

#include "boost/regex.hpp"

=={{header|D}}==

This one recursively walks the directory, which can either match by regular expression or unix shell style pattern.

<lang d>import std.stdio;

listdir(path, &matchNPrint) ;

=={{header|E}}==

<lang e>def walkTree(directory, pattern) {

for name => file in directory {

}

}</lang>

<lang e>? walkTree(<file:/usr/share/man>, "rmdir")

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

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

This code is tail-recursive and lazy.

let rec getAllFiles dir pattern =

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

=={{header|Factor}}==

=={{header|Forth}}==

{{works with|gforth|0.6.2}}

''Todo: track the full path and print it on matching files.''

<lang forth>defer ls-filter

=={{header|Groovy}}==

Print all text files in the current directory tree

<lang groovy>new File('.').eachFileRecurse {

=={{header|GUISS}}==

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

<lang guiss>Start,Find,Files and Folders,Dropdown: Look in>My Documents,

Inputbox: filename>m*.txt,Button:Search</lang>

=={{header|Haskell}}==

<lang haskell>import System.Environment

import System.Directory

=={{header|IDL}}==

<lang idl>result = file_search( directory, '*.txt', count=cc )</lang>

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>

== Icon and Unicon ==

==={{header|Icon}}===

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

<lang Unicon>procedure main()

=={{header|J}}==

<lang j>require 'dir'

>{."1 dirtree '*.html'</lang>

=={{header|Java}}==

{{works with|Java|1.4+}}

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

public class MainEntry {

public static void main(String[] args) {

File listFile[] = dir.listFiles();

walkin(listFile[i]);

} else {

System.out.println(listFile[i].getPath());

}

import java.nio.file.attribute.BasicFileAttributes;

Path start = FileSystems.getDefault().getPath("/path/to/file");

@Override

public FileVisitResult visitFile(Path file,

System.out.println(file);

}

=={{header|Mathematica}}==

Examples (find all files in current directory, find all png files in root directory, find all files on the hard drive):

<lang Mathematica>FileNames["*"]

=={{header|Perl 6}}==

Uses File::Find from [http://github.com/tadzik/perl6-File-Tools File-Tools]

<lang perl6>use File::Find;

}

findFiles('./foo', '/\.bar$/');</lang>

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

Released as open license for any use.

*/

, $_SERVER['argv'][0]);

}

}

=={{header|PicoLisp}}==

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

(println Path) ) ) ) ) ) ) # Yes: Print it</lang>

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

"./src64/subr.l"

=={{header|Pop11}}==

<lang pop11>lvars repp, fil;

;;; create path repeater

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

<lang python>import fnmatch

import os

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

print( os.path.join(root, filename))</lang>

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

<lang python>from fnmatch import fnmatch

import os, os.path

os.path.walk('/', print_fnmatches, '*.mp3')</lang>

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.

Of course the function being passed down through ''os.path.walk()'' can also be an instance of an object which maintains it's own data collections. Any matching criteria can be set as attributes of that object in advance and methods of that object can be called upon for later processing as well. That would the an object oriented approach which would obviate the need for the "arguments" to be passed through ''os.path.walk()'' at all.

{{works with|Python|2.5}}

{{libheader|Path}}

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

<lang python>from path import path

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

<lang vb>

=={{header|Ruby}}==

Using the Find core Module

<lang ruby>require 'find'

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

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

=={{header|Scala}}==

@SEE: http://stackoverflow.com/questions/3444748/porting-new-iterable-code-from-scala-2-7-7-to-2-8

<lang scala>package io.utils

implicit def toRichFile(file: File) = new RichFile(file)

}</lang>

Class ''RichFile'' gets a ''java.io.File'' in constructor. Its two methods return ''Iterable''s on items of type File. ''children'' allow iterations on the direct children (empty if file is not a directory). ''andTree'' contains a file and all files below, as a concatenation (''++'') of a sequence which contains only a file (''Seq.single'') and actual descendants. The method ''flatMap'' in Iterable takes a function argument which associates each item (''child'') to another Iterable (''andTree'' called recursively on that child) and returns the concatenation of those iterables.

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

/home/user/one.scm

/home/user/lang/two.scm

[...]

=={{header|Smalltalk}}==

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

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

This uses the OS pattern matching

<lang vbnet>Sub walkTree(ByVal directory As IO.DirectoryInfo, ByVal pattern As String)

For Each file In directory.GetFiles(pattern)

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

{{works with|Bourne Again SHell}}

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

<lang bash>find . -name '*.txt' -type f </lang>

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

<lang bash>#! /bin/bash

# Warning: globstar excludes hidden directories.

echo "$f"

fi

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

<lang bash>#! /bin/bash

walk_tree "$1" "\.sh$"</lang>

A simplified version that gives the same output:

<lang bash>#! /usr/bin/env bash

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

<lang bash>find . -type f | egrep '\.txt$|\.TXT$'</lang>

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:

<lang bash> find . -type f -name "*.txt" -print0 | xargs -0 fgrep sometext</lang>

{{omit from|Befunge}} <!-- No filesystem support -->

{{omit from|M4}}

{{omit from|PARI/GP}}

{{omit from|Retro}}