Walk a directory/Recursively: Difference between revisions

[[Category:Recursion]]

 

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

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.

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

<!-- {{does not work with|ALGOL 68|Standard - extensions to language used}} -->

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

 

<pre>

./Shell_sort_c.a68

./Permutation_Sort.a68

</pre>

 

=={{header|AutoHotkey}}==

Display all TMP files in Temp directory and its subdirectories.

out .= A_LoopFileName "`n"

 

 

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

 

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

* "." and ".." because we never use FTS_SEEDOT.

*/

switch (f->fts_info) {

case FTS_DNR: /* Cannot read directory */

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

return 0;

=== [[Windows]] ===

{{libheader|Win32}}

{{works with|MinGW}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

 

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

using System.IO;

 

{

class Program

{

{

{

{

}

}

}

}

}

 

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

{{libheader|boost}}

#include "boost/regex.hpp"

#include <iostream>

++iter)

{

if (regex_match(name, pattern))

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

}

 

=={{header|Clojure}}==

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

 

(defn walk [dirpath pattern]

 

 

=={{header|D}}==

 

 

 

 

 

 

for name => file in directory {

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

}

}

 

 

 

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

 

 

 

 

begin

while

else drop then

else drop then

repeat

 

dup 3 < if 2drop false exit then

+ 1- dup c@ 32 or

1- dup c@ [char] . <> if drop false exit then

drop true ;

 

 

=={{header|GAP}}==

local dir, file, e;

dir := Directory(name);

 

# This will print filenames

 

=={{header|Go}}==

 

import (

"fmt"

"os"

)

 

fmt.Println(fp)

}

}

 

func main() {

 

=={{header|Groovy}}==

 

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

 

 

 

 

=={{header|Haskell}}==

 

import System.Directory

import System.FilePath.Find

 

 

 

 

 

== Icon and Unicon ==

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

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

every write(!getdirs(".")) # writes out all directories from the current directory down

end

return D

}

 

 

 

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.

 

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

}

}

}

 

=={{header|JavaScript}}==

{{works with|JScript}}

 

function walkDirectoryTree(folder, folder_name, re_pattern) {

}

 

 

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

(

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

)

 

 

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

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

 

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

 

=={{header|OCaml}}==

#load "unix.cma"

#load "str.cma"

 

let walk_directory_tree dir pattern =

let rec walk acc = function

| [] -> (acc)

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

List.iter print_endline results;

 

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

 

 

 

 

=={{header|PHP}}==

$prefix = $dir . '/';

$dir = dir($dir);

}

}

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

 

This script performs a BFS search with recursion protection

it is often faster to search using this method across a

Released as open license for any use.

*/

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

 

 

 

 

 

 

 

 

 

 

}

}

 

=={{header|PicoLisp}}==

(recur (Dir)

(for F (dir Dir)

(recurse Path) ) # Yes: Recurse

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

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

"./src64/subr.l"

 

=={{header|Pop11}}==

;;; 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|PureBasic}}==

Static RegularExpression

If Not RegularExpression

EndIf

Wend

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

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

 

=={{header|Python}}==

 

 

import os

 

rootPath = '/'

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

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

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.

 

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)

 

rootPath = '/'

d = path(rootPath)

for f in d.walkfiles(pattern):

 

=={{header|R}}==

 

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

 

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

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

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

 

 

 

 

 

 

 

 

 

 

 

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

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

}

}

}

 

 

 

 

 

 

 

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

 

 

 

indent_print()

}

 

A simplified version that gives the same output:

walk_tree() {

}

 

=={{header|UnixPipes}}==

 

=={{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|Befunge}} <!-- No filesystem support -->

{{omit from|M4}}

{{omit from|PARI/GP}}

{{omit from|Retro}}

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

{{omit from|ZX Spectrum Basic|Does not have subdirectories}}