Empty directory: Difference between revisions

=={{header|11l}}==

print(‘empty’)

E

=={{header|8086 Assembly}}==

{{trans|MS-DOS}}

mov ax,seg dirname ;load into AX the segment where dirname is stored.

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

=={{header|Arturo}}==

{{out}}

=={{header|AutoHotkey}}==

isDir_empty(p) {

return 0

return 1

{{out}}

<pre>false</pre>

=={{header|AWK}}==

# syntax: GAWK -f EMPTY_DIRECTORY.AWK

BEGIN {

return(msg)

}

{{out}}

<pre>

=={{header|BaCon}}==

IF FILEEXISTS(dir$) THEN

dir$ = "."

{{out}}

*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

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

using System.IO;

}

}

Running it:<pre>

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

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

{{libheader|Boost}}

#include <iostream>

#include <boost/filesystem.hpp>

}

}

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

{{libheader| System.IOUtils}}

{{Trans|C#}}

program Empty_directory;

Writeln(ParamStr(i), CHECK[IsDirectoryEmpty(ParamStr(i))], ' empty');

Readln;

{{out}}

The same of c#.

=={{header|Elixir}}==

=={{header|Erlang}}==

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

=={{header|Factor}}==

=={{header|FreeBASIC}}==

#Include "dir.bi"

Print

Print "Press any key to quit"

{{out}}

=={{header|Gambas}}==

Dim sFolder As String = User.home &/ "Rosetta"

Dim sDir As String[] = Dir(sFolder)

Print sOutput

Output:

<pre>

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

The ECMAScript standard itself defines no IO interface – the following example makes use of the Node.js file IO library.

{{Works with|Node.js}}

const { readdirSync } = require("fs");

const emptydir = (path) => readdirSync(path).length == 0;

let dir = process.argv[i];

console.log(`${dir}: ${emptydir(dir) ? "" : "not "}empty`)

=={{header|Julia}}==

isemptydir(dir::AbstractString) = isempty(readdir(dir))

@show isemptydir(".")

@show isemptydir("/home")

{{out}}

=={{header|Kotlin}}==

import java.io.File

val isEmpty = (File(dirPath).list().isEmpty())

println("$dirPath is ${if (isEmpty) "empty" else "not empty"}")

=={{header|Lasso}}==

'<br />'

{{out}}

<pre>false

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

dim info$(10, 10)

files "c:\", info$()

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

end if

=={{header|Lingo}}==

return getNthFileNameInFolder(dir, 1) = EMPTY

=={{header|Lua}}==

Pure Lua function based on snipplet from Stack Overflow[http://stackoverflow.com/questions/5303174/how-to-get-list-of-directories-in-lua#11130774].

function scandir(directory)

local i, t, popen = 0, {}, io.popen

return #scandir(directory) == 0

end

Using lfs[https://keplerproject.github.io/luafilesystem/] library.

function isemptydir(directory,nospecial)

for filename in require('lfs').dir(directory) do

return true

end

=={{header|Maple}}==

emptydirectory := proc (dir)

is(listdir(dir) = [".", ".."]);

end proc;

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

{{works with|min|0.19.3}}

=={{header|MS-DOS}}==

Since you cannot remove a directory that isn't empty, one way to check is to attempt to remove it.

Unable to remove: GAMES.

=={{header|Nanoquery}}==

return len(new(Nanoquery.IO.File).listDir(dirname)) = 0

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

Alternatively:

proc isEmptyDir(dir: string): bool =

echo isEmptyDir("/tmp") # false - there is always something in "/tmp"

=={{header|Objeck}}==

return Directory->List(dir)->Size() = 0;

=={{header|OCaml}}==

=={{header|ooRexx}}==

Call test 'D:\edir' /* an empty directory */

Call test 'D:\somedir' /* directory with 2 files */

End

End

{{out}}

<pre>Directory D:\nodir not found

Define a function ''chkdir(<path>)'' that returns count of entries in a directory (without . and .. ):

On error ''chkdir(...)'' returns -1 else count of entries. If ''chkdir() == 0'' then directory is empty. So define an additional function:

Output:<pre>chkdir("/tmp"): 52

However, ''GNU Pascal'' provides certain extensions to [[Extended Pascal]] (ISO 10206) so it is possible nonetheless.

Note, the following solution works only on ''strictly hierarchical'' file systems.

type

readLn(s);

writeLn(isEmptyDirectory(s))

Note, symbolic links’ targets are resolved, so <tt>accessVia</tt> could in fact be a symbolic link ''to'' an empty directory.

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

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- file i/o</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">filename</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

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

{{works with|PowerShell|4.0}}

$path = "C:\Users"

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

"$path is not empty"

}

<b>Output:</b>

<pre>

=={{header|Prolog}}==

non_empty_file('..').

empty_dir(Dir) :-

directory_files(Dir, Files),

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

is_dir_empty <- function(path){

if(length(list.files(path)) == 0)

is_dir_empty(path)

=={{header|Racket}}==

#lang racket

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

=={{header|Raku}}==

(formerly Perl 6)

The <tt>dir</tt> function returns a lazy list of filenames, excluding "<tt>.</tt>" and "<tt>..</tt>" automatically. Any boolean context (in this case the <tt>not</tt> function) will do just enough work on the lazy list to determine whether there are any elements, so we don't have to count the directory entries, or even read them all into memory, if there are more than one buffer's worth.

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

use std::error::Error;

}

}

=={{header|Scala}}==

def isDirEmpty(file:File) : Boolean =

=={{header|Seed7}}==

include "osfiles.s7i";

begin

writeln(dirEmpty("somedir"));

=={{header|SenseTalk}}==

The filesAndFolders function returns an empty list if a directory is empty (and does not return '.' or '..').

make folder newFolderPath -- create a new empty directory

put "Something is present in " & newFolderPath

end if

{{out}}

<pre>

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

Debug.Print IsEmptyDirectory("C:\Temp")

Debug.Print IsEmptyDirectory("C:\Temp\")

D = IIf(Right(D, 1) <> Sep, D & Sep, D)

IsEmptyDirectory = (Dir(D & "*.*") = "")

=={{header|VBScript}}==

Function IsDirEmpty(path)

IsDirEmpty = False

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

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

{{Out}}

=={{header|Vlang}}==

fn main() {

return 'Directory not empty!'

}

=={{header|Wren}}==

var isEmptyDir = Fn.new { |path|

var path = "test"

var empty = isEmptyDir.call(path)

{{out}}

=={{header|zkl}}==

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

{{out}}

<pre>