Empty directory: Difference between revisions

An empty directory contains no files nor subdirectories.

With [[Unix]] or [[Windows]] systems, every directory contains an entry for “<code>.</code>” and almost every directory contains “<code>..</code>” (except for a root directory); an empty directory contains no other entries.

 

=={{header|Ada}}==

with Ada.Directories;

procedure EmptyDir is

Put_Line (Empty ("./emptydir.adb"));

Put_Line (Empty ("./foobar"));

{{out}}

<pre>Not empty

This uses the "argc", "argv", "file is directory" and "get directory" procedures specific to Algol 68 G.

<br>Note the Algol 68 G interpreter processes the command line parameters before "-" so this example expects the directory names to follow "-".

PROC is empty directory = ( STRING directory )BOOL:

IF NOT file is directory( directory )

print( ( argv( i ), " is ", IF is empty directory( argv( i ) ) THEN "empty" ELSE "not empty" FI, newline ) )

FI

{{out}}

<pre>

\zz is empty

</pre>

 

=={{header|AutoHotkey}}==

 

isDir_empty(p) {

return 0

return 1

{{out}}

<pre>false</pre>

 

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

*2 - input directory does not exist.

*3 - input not found.

if "%~1"=="" exit /b 3

set "samp_path=%~1"

:folder_not_found

echo Folder not found.

{{Out|Sample Session}}

(Saved the Batch File as IsEmpty.Bat in C:\)

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

{{works with|BBC BASIC for Windows}}

IF FNisdirectoryempty("C:\temp") PRINT "C:\temp is empty" ELSE PRINT "C:\temp is not empty"

END

UNTIL res% == 0

SYS "FindClose", sh%

 

=={{header|C}}==

#include <dirent.h>

#include <string.h>

 

return 0;

% mkdir stuff; ./a.out /usr/ ./stuff /etc/passwd

/usr/: not empty

</pre>

 

using System.IO;

 

}

}

Running it:<pre>

Assume c:\temp exists and is not empty, c:\temp\empty exists and is empty

'c:\temp\empty' is empty

</pre>

 

=={{header|Clojure}}==

(defn empty-dir? [path]

(let [file (io/file path)]

(assert (.exists file))

(assert (.isDirectory file))

 

=={{header|CoffeeScript}}==

fs = require 'fs'

 

fns = fs.readdirSync dir

fns.length == 0

 

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

Will also return <code>T</code> if <code>path</code> doesn't exist.

(defun empty-directory-p (path)

(and (null (directory (concatenate 'string path "/*")))

(null (directory (concatenate 'string path "/*/")))))

 

=={{header|D}}==

 

 

void main() {

throw new Exception("dir not found: " ~ dirname);

return dirEntries(dirname, SpanMode.shallow).empty;

<pre>somedir is empty: false</pre>

 

=={{header|Elixir}}==

 

=={{header|Erlang}}==

 

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

 

=={{header|Go}}==

 

import (

return len(entries) == 0, nil

}

=={{header|Groovy}}==

Solution:

def dir = new File(dirName)

dir.exists() && dir.directory && (dir.list() as List).empty

 

Test:

def random = new Random()

def subDirName = "dir${random.nextInt(100000)}"

 

assert ! isDirEmpty('.')

 

=={{header|Haskell}}==

import System.Environment (getArgs)

 

f False = "Directory is not empty"

 

Test:

$ ./isempty 1

Directory is empty

$ ./isempty /usr/

 

 

==Icon and {{header|Unicon}}==

This example uses Unicon extensions. The 'empty' sub-directory was manually setup for this test.

every dir := "." | "./empty" do

write(dir, if isdirempty(dir) then " is empty" else " is not empty")

}

else stop(s," is not a directory or will not open")

 

{{out}}

=={{header|J}}==

 

 

In other words, list the contents of the directory, count how many items are in it, and test if that count was zero.

Example, under windows, create some directories using cygwin:

 

$ touch /tmp/a/...

$ mkdir /tmp/b

$ mkdir /tmp/c

 

Then, testing these directories, in J:

 

0

empty_dir 'c:/cygwin/tmp/b'

1

empty_dir 'c:/cygwin/tmp/c'

 

=={{header|Java}}==

{{works with|Java|7+}}

This method does not check that the path given is actually a directory. If a path to a normal file is given, it will throw a <code>NullPointerException</code>. <code>File.listFiles()</code> does not count the "." and ".." entries.

//... other class code here

public static boolean isEmptyDir(String dirName){

return Paths.get(dirName).toFile().listFiles().length == 0;

 

 

=={{header|Lasso}}==

'<br />'

{{out}}

<pre>false

 

=={{header|Liberty BASIC}}==

dim info$(10, 10)

files "c:\", info$()

print "Folder ";folder$;" is empty."

end if

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

Example use:

EmptyDirectoryQ["C:\\Program Files\\Wolfram Research\\Mathematica\\9"]

 

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

function x = isEmptyDirectory(p)

if isdir(p)

end;

end;

 

 

=={{header|Nemerle}}==

using System.Console;

 

}

}

 

=={{header|NewLISP}}==

(define (empty-dir? path-to-check)

(empty? (clean (lambda (x) (or (= "." x) (= ".." x))) (directory path-to-check)))

)

 

=={{header|Nim}}==

 

var empty = true

empty = false

break

 

=={{header|OCaml}}==

 

 

=={{header|PARI/GP}}==

 

 

 

=={{header|Perl}}==

===Simple version===

This version however doesn't catch 'hidden' files that start with a dot.

 

Unfortunalety, BSD glob() doesn't handle inverted character class. If it did, this pattern could be used: <tt>{.[^.],}*</tt> (this works well in bash). But it doesn't, so there's a

===Thorough version===

 

 

=={{header|PHP}}==

Any improvements welcome but here is a starting point for PHP

 

$dir = 'path_here';

}

 

 

=={{header|PicoLisp}}==

{{out}}

<pre>myDir is not empty</pre>

 

=={{header|PowerShell}}==

 

{{works with|PowerShell|4.0}}

$path = "C:\Users"

if((Dir $path).Count -eq 0) {

"$path is not empty"

}

<b>Output:</b>

<pre>

C:\Users is not empty

</pre>

 

=={{header|PureBasic}}==

If Right(path$, 1) <> "\": path$ + "\": EndIf

Protected dirID = ExamineDirectory(#PB_Any, path$, "*.*")

EndIf

MessageRequester("Empty directory test", #DQUOTE$ + path$ + #DQUOTE$ + result$)

{{out}} when selecting directories "L:\vv\6\" and "L:\vv\" :

<pre>"L:\vv\6\" is empty.

=={{header|Python}}==

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

if os.listdir(raw_input("directory")):

print "not empty"

else:

print "empty"

 

=={{header|Racket}}==

 

#lang racket

(empty? (directory-list "some-directory"))

 

=={{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='\someDir' /*Any DIR? Use default.*/

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

if #==0 then #=' no ' /*use a word, ¬zero.*/

say center('directory ' xdir " has " # ' entries.',79,'─')

{{out}} when the following input was used: &nbsp; <tt> temp </tt>

<pre>

 

=={{header|Ring}}==

myList = dir("C:\Ring\bin")

if len(myList) > 0 see "C:\Ring\bin is not empty" + nl

else see "C:\Ring\bin is empty" + nl ok

 

=={{header|Ruby}}==

Raises a SystemCallError if the named directory doesn’t exist.

 

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

print "hasanswer: ";#f HASANSWER() ' if it has an answer it is not MT

 

=={{header|Scala}}==

 

def isDirEmpty(file:File) : Boolean =

 

=={{header|Seed7}}==

include "osfiles.s7i";

 

begin

writeln(dirEmpty("somedir"));

 

=={{header|Sidef}}==

Built-in method:

 

User-defined function:

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

dir_h.each { |file|

};

return true;

 

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

let

val dir = OS.FileSys.openDir path

| _ => false

)

 

=={{header|Tcl}}==

# Get list of _all_ files in directory

set filenames [glob -nocomplain -tails -directory $dir * .*]

# Check whether list is empty (after filtering specials)

expr {![llength [lsearch -all -not -regexp $filenames {^\.\.?$}]]}

 

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

#!/bin/sh

DIR=/tmp/foo

[ `ls -a $DIR|wc -l` -gt 2 ] && echo $DIR is NOT empty || echo $DIR is empty

 

=={{header|VBScript}}==

Function IsDirEmpty(path)

IsDirEmpty = False

WScript.StdOut.WriteLine IsDirEmpty("C:\Temp")

WScript.StdOut.WriteLine IsDirEmpty("C:\Temp\test")

 

{{Out}}

False

True

</pre>

 

=={{header|zkl}}==

File.mkdir(path); File.isDir(path).println();

{{out}}

<pre>

 

{{omit from|ACL2}}