Walk a directory/Non-recursively: Difference between revisions

{{trans|Python}}

 

I filename.ends_with(‘.mp3’)

 

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

the filename, the extension, and an optional drive letter.

 

puts: equ 9 ; CP/M syscall to print a string

sfirst: equ 17 ; 'Find First' CP/M syscall

ret

emsg: db 'Not Found$'

 

{{out}}

 

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

----

Nowadays, it's more usual to use macOS's System Events application for this kind of task as it's very much faster than the Finder, especially with 'whose' filters. However, its results, unlike the Finder's, aren't sorted by the items' names and it includes results for hidden items too if these match the criteria.

 

 

Intermediate in speed between the Finder and System Events are shell scripts, which are handy if you're more comfortable with shell scripts than with AppleScript.

 

-- By default, "ls" returns file names sorted by character code, so save the sorting until the end and do it case-insensitively.

set shellCommandText to "ls -f " & quoted form of docsFolderPath & " | grep -i '\\.pdf$' | sort -f"

return paragraphs of (do shell script shellCommandText)

 

Best of all for speed and sorting, although requiring somewhat more code, are the Foundation methods available through AppleScriptObjC.

 

use framework "Foundation"

use scripting additions

-- Return the result as an AppleScript list of text.

return pdfNames as list

 

=={{header|Arturo}}==

 

print list "."

 

; just select the files that contain "test"

select list "some/path"

 

=={{header|AutoHotkey}}==

Display all INI files in Windows directory.

out .= A_LoopFileName "`n"

 

=={{header|BaCon}}==

This code will print all files in the current directory ".", separated by a newline symbol:

 

=={{header|BASIC}}==

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

{{works with|FreeBASIC}}

 

show "*.*"

f = DIR$

LOOP

 

=={{header|BASIC256}}==

end

 

f$ = dir

end while

 

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

}

}

 

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

#include <filesystem>

#include <iostream>

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

}

 

=={{header|Clojure}}==

Using Java 8's [https://docs.oracle.com/javase/8/docs/api/java/nio/file/FileSystem.html#getPathMatcher-java.lang.String- PathMatcher] patterns.

 

 

(defn match-files [f pattern]

(let [directory (clojure.java.io/file dir)]

(map #(.getPath %) (filter #(match-files % pattern) (.listFiles directory)))))

 

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

 

{{libheader| System.IOUtils}}

program Walk_a_directory;

 

end.

 

 

{{out}}

 

=={{header|E}}==

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

println(name)

}

Example:

.bash_history

.bash_profile

 

=={{header|Elena}}==

import system'routines;

import extensions'routines;

var dir := Directory.assign("c:\MyDir");

 

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

{{trans|BASIC}}

Sub show (pattern As String)

Dim As String f = Dir$(pattern)

show "*.*"

Sleep

 

=={{header|Frink}}==

This prints the names of all of the files in the current directory that end with <CODE>.frink</CODE> using a regular expression.

 

 

{{out}}

graphicalSieve.frink

...

</pre>

 

=={{header|Gambas}}==

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

Dim sTemp As String

Next

 

Output:

<pre>

 

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

{{works with|Julia|0.6}}

 

if endswith(filename, ".mp3")

print(filename)

end

 

=={{header|Kotlin}}==

 

import java.io.File

val files = walkDirectory("/usr/include", r)

for (file in files) println(file)

Sample output (Ubuntu v14.04):

{{out}}

 

=={{header|Lasso}}==

 

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

 

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

 

=={{header|Lingo}}==

on printFiles (dir, fileType)

i = 1

if fn.char[fn.length-sub..fn.length]=fileType then put fn

end repeat

 

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

Although Lua is spartanic, it still 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

 

=={{header|M2000 Interpreter}}==

There is a second optional parameter which examine all files founded from first filter for included letters. We can add using | as seperator, a list of strings included in same line. Files examine all files, opened one by one, using an automatic way to find what kind of text file is, an Ansi, a Utf8, a Utf-16LE, or a Utf-16BE. Also automatic find the line breaks. All files converted at open as utf-16LE and then searched. For Ansi files, Locale used to make the right conversion.

Module Show_Files_Standard {

\\ we get more (include hidden too)

}

Show_Files_Standard

 

Like VbScript using external help, from a COM object.

Stack New {} make a block of a fresh stack of values, and at the exit attach the old stack (which for this block detached from execute object at the begin of block).

 

Module Show_Files {

Function get_files$ (folder_path$) {

}

Show_Files

 

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

 

for fname in new(File).listDir("/foo/bar")

println filename

end

 

=={{header|Nemerle}}==

using System.IO;

 

foreach (file in files) WriteLine(file);

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

return

{{out}}

<pre>

Here is an example with <code>walkFiles</code> and a pattern:

 

 

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

opendir my $dh, '/home/foo/bar';

say for grep { /php$/ } readdir $dh;

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

{{libheader|Phix/basics}}

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

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">dir</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"*.txt"</span><span style="color: #0000FF;">))[</span><span style="color: #000000;">D_NAME</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">))</span>

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

(formerly Perl 6)

The <code>dir</code> function takes the directory to traverse, and optionally a named parameter <code>test</code>, which is [https://docs.raku.org/routine/$TILDE$TILDE smart-matched] against the basename of each file (so for example we can use a regex):

 

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

 

###---------------------------------------

###===============================================

 

 

OUTPUT:

Finished

 

</pre>

 

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

 

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

dir_h.entries.each { |entry|

say file;

}

{{out}}

<pre>

 

=={{header|Smalltalk}}==

 

=={{header|Standard ML}}==

let

fun loop strm =

in

loop strm before OS.FileSys.closeDir strm

List all "hidden" files (starting with a dot in Unix) in the current directory:

 

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

==== Using <code>glob</code> ====

 

 

{{out}}

 

"/etc/ca-certificates.conf" "/etc/colord.conf" "/etc/ddclient.conf"

"/etc/debconf.conf" "/etc/deluser.conf" "/etc/dnsmasq.conf" "/etc/ffserver.conf"

"/etc/pnm2ppa.conf" "/etc/popularity-contest.conf" "/etc/resolv.conf"

"/etc/rsyslog.conf" "/etc/sensors3.conf" "/etc/sysctl.conf" "/etc/ucf.conf"

 

==== Using <code>open-directory</code> and <code>get-lines</code> ====

 

 

{{out}}

 

"debconf.conf" "apg.conf" "adduser.conf" "mke2fs.conf" "colord.conf"

"kerneloops.conf" "fuse.conf" "hdparm.conf" "irssi.conf" "host.conf"

"knockd.conf" "ntp.conf" "sensors3.conf" "resolv.conf" "blkid.conf"

"lftp.conf" "ca-certificates.conf" "usb_modeswitch.conf" "logrotate.conf"

 

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

{{libheader|Wren-pattern}}

 

var walk = Fn.new { |dir, pattern|

// get all C header files beginning with 'a' or 'b'

var p = Pattern.new("[a|b]+0^..h", Pattern.whole)

 

{{out}}

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