Check that file exists

From Rosetta Code
(Redirected from Ensure that a file exists)
Jump to: navigation, search
Task
Check that file exists
You are encouraged to solve this task according to the task description, using any language you may know.

In this task, the job is to verify that a file called "input.txt" and the directory called "docs" exist. This should be done twice: once for the current working directory and once for a file and a directory in the filesystem root.

Contents

[edit] Ada

This example should work with any Ada 95 compiler.

with Ada.Text_IO; use Ada.Text_IO;
 
procedure File_Exists is
function Does_File_Exist (Name : String) return Boolean is
The_File : Ada.Text_IO.File_Type;
begin
Open (The_File, In_File, Name);
Close (The_File);
return True;
exception
when Name_Error =>
return False;
end Does_File_Exist;
begin
Put_Line (Boolean'Image (Does_File_Exist ("input.txt" )));
Put_Line (Boolean'Image (Does_File_Exist ("\input.txt")));
end File_Exists;

This example should work with any Ada 2005 compiler.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Directories; use Ada.Directories;
 
procedure File_Exists is
procedure Print_File_Exist (Name : String) is
begin
Put_Line ("Does " & Name & " exist? " &
Boolean'Image (Exists (Name)));
end Print_File_Exist;
procedure Print_Dir_Exist (Name : String) is
begin
Put_Line ("Does directory " & Name & " exist? " &
Boolean'Image (Exists (Name) and then Kind (Name) = Directory));
end Print_Dir_Exist;
begin
Print_File_Exist ("input.txt" );
Print_File_Exist ("/input.txt");
Print_Dir_Exist ("docs");
Print_Dir_Exist ("/docs");
end File_Exists;

[edit] Aikido

The stat function returns a System.Stat object for an existing file or directory, or null if it can't be found.

 
function exists (filename) {
return stat (filename) != null
}
 
exists ("input.txt")
exists ("/input.txt")
exists ("docs")
exists ("/docs")
 
 

[edit] Applesoft BASIC

The error code for FILE NOT FOUND is 6.

100 F$ = "THAT FILE"
110 T$(0) = "DOES NOT EXIST."
120 T$(1) = "EXISTS."
130 GOSUB 200"FILE EXISTS?
140 PRINT F$; " "; T$(E)
150 END
 
200 REM FILE EXISTS?
210 REM TRY
220 ON ERR GOTO 300"CATCH
230 PRINT CHR$(4); "VERIFY "; F$
240 POKE 216, 0 : REM ONERR OFF
250 E = 1
260 GOTO 350"END TRY
300 REM CATCH
310 E = PEEK(222) <> 6
320 POKE 216, 0 : REM ONERR OFF
330 IF E THEN RESUME : REM THROW
340 CALL - 3288 : REM RECOVER
350 REM END TRY
360 RETURN
 

[edit] AutoHotkey

AutoHotkey’s FileExist() function returns an attribute string (a subset of "RASHNDOCT") if a matching file or directory is found. The attribute string must be parsed for the letter D to determine whether the match is a directory or file.

Another option is AutoHotkey's IfExist/IfNotExist command

; FileExist() function examples
ShowFileExist("input.txt")
ShowFileExist("\input.txt")
ShowFolderExist("docs")
ShowFolderExist("\docs")
 
; IfExist/IfNotExist command examples (from documentation)
IfExist, D:\
MsgBox, The drive exists.
IfExist, D:\Docs\*.txt
MsgBox, At least one .txt file exists.
IfNotExist, C:\Temp\FlagFile.txt
MsgBox, The target file does not exist.
 
Return
 
ShowFileExist(file)
{
If (FileExist(file) && !InStr(FileExist(file), "D"))
MsgBox, file: %file% exists.
Else
MsgBox, file: %file% does NOT exist.
Return
}
 
ShowFolderExist(folder)
{
If InStr(FileExist(folder), "D")
MsgBox, folder: %folder% exists.
Else
MsgBox, folder: %folder% does NOT exist.
Return
}

[edit] AWK

 
# syntax: GAWK -f CHECK_THAT_FILE_EXISTS.AWK
BEGIN {
check_exists("input.txt")
check_exists("\\input.txt")
check_exists("docs")
check_exists("\\docs")
exit(0)
}
function check_exists(name, fnr,msg,rec) {
while (getline rec <name > 0) {
fnr++
break
}
# "Permission denied" is for MS-Windows
msg = (ERRNO == 0 || ERRNO ~ /Permission denied/ || fnr > 0) ? "exists" : "does not exist"
printf("%s - %s\n",name,msg)
close(name)
}
 

example:

ECHO Microsoft Windows example >input.txt
MKDIR docs
MKDIR \docs
GAWK -f CHECK_THAT_FILE_EXISTS.AWK
input.txt - exists
\input.txt - does not exist
docs - exists
\docs - exists
DEL input.txt
RMDIR docs
RMDIR \docs
GAWK -f CHECK_THAT_FILE_EXISTS.AWK
input.txt - does not exist
\input.txt - does not exist
docs - does not exist
\docs - does not exist

[edit] BASIC

Works with: QBasic
 
ON ERROR GOTO ohNo
f$ = "input.txt"
GOSUB opener
f$ = "\input.txt"
GOSUB opener
 
'can't directly check for directories,
'but can check for the NUL device in the desired dir
f$ = "docs\nul"
GOSUB opener
f$ = "\docs\nul"
GOSUB opener
END
 
opener:
e$ = " found"
OPEN f$ FOR INPUT AS 1
PRINT f$; e$
CLOSE
RETURN
 
ohNo:
IF (53 = ERR) OR (76 = ERR) THEN
e$ = " not" + e$
ELSE
e$ = "Unknown error"
END IF
RESUME NEXT
 

You can also check for a directory by trying to enter it.

 
ON ERROR GOTO ohNo
d$ = "docs"
CHDIR d$
d$ = "\docs"
CHDIR d$
END
 
ohNo:
IF 76 = ERR THEN
PRINT d$; " not found"
ELSE
PRINT "Unknown error"
END IF
RESUME NEXT
 
Works with: QuickBasic version 7.1
Works with: PowerBASIC for DOS

Later versions of MS-compatible BASICs include the DIR$ keyword, which makes this pretty trivial.

 
f$ = "input.txt"
GOSUB opener
f$ = "\input.txt"
GOSUB opener
 
'can't directly check for directories,
'but can check for the NUL device in the desired dir
f$ = "docs\nul"
GOSUB opener
f$ = "\docs\nul"
GOSUB opener
END
 
opener:
d$ = DIR$(f$)
IF LEN(d$) THEN
PRINT f$; " found"
ELSE
PRINT f$; " not found"
END IF
RETURN
 

[edit] Batch File

if exist input.txt echo The following file called input.txt exists.
if exist \input.txt echo The following file called \input.txt exists.
if exist docs echo The following directory called docs exists.
if exist \docs\ echo The following directory called \docs\ exists.

[edit] BBC BASIC

      test% = OPENIN("input.txt")
IF test% THEN
CLOSE #test%
PRINT "File input.txt exists"
ENDIF
 
test% = OPENIN("\input.txt")
IF test% THEN
CLOSE #test%
PRINT "File \input.txt exists"
ENDIF
 
test% = OPENIN("docs\NUL")
IF test% THEN
CLOSE #test%
PRINT "Directory docs exists"
ENDIF
 
test% = OPENIN("\docs\NUL")
IF test% THEN
CLOSE #test%
PRINT "Directory \docs exists"
ENDIF

[edit] C

Library: POSIX
#include <sys/types.h> 
#include <sys/stat.h>
#include <stdio.h>
#include <unistd.h>
 
/* Check for regular file. */
int check_reg(const char *path) {
struct stat sb;
return stat(path, &sb) == 0 && S_ISREG(sb.st_mode);
}
 
/* Check for directory. */
int check_dir(const char *path) {
struct stat sb;
return stat(path, &sb) == 0 && S_ISDIR(sb.st_mode);
}
 
int main() {
printf("input.txt is a regular file? %s\n",
check_reg("input.txt") ? "yes" : "no");
printf("docs is a directory? %s\n",
check_dir("docs") ? "yes" : "no");
printf("/input.txt is a regular file? %s\n",
check_reg("/input.txt") ? "yes" : "no");
printf("/docs is a directory? %s\n",
check_dir("/docs") ? "yes" : "no");
return 0;
}

[edit] C++

Library: boost
#include "boost/filesystem.hpp"
#include <string>
#include <iostream>
 
void testfile(std::string name)
{
boost::filesystem::path file(name);
if (exists(file))
{
if (is_directory(file))
std::cout << name << " is a directory.\n";
else
std::cout << name << " is a non-directory file.\n";
}
else
std::cout << name << " does not exist.\n";
}
 
int main()
{
testfile("input.txt");
testfile("docs");
testfile("/input.txt");
testfile("/docs");
}

[edit] C#

using System.IO;
 
Console.WriteLine(File.Exists("input.txt"));
Console.WriteLine(File.Exists("/input.txt"));
Console.WriteLine(Directory.Exists("docs"));
Console.WriteLine(Directory.Exists("/docs"));

[edit] CoffeeScript

Works with: Node.js
 
fs = require 'fs'
path = require 'path'
 
root = path.resolve '/'
current_dir = __dirname
filename = 'input.txt'
dirname = 'docs'
 
local_file = path.join current_dir, filename
local_dir = path.join current_dir, dirname
 
root_file = path.join root, filename
root_dir = path.join root, dirname
 
for p in [ local_file, local_dir, root_file, root_dir ] then do ( p ) ->
fs.exists p, ( p_exists ) ->
unless p_exists
console.log "#{ p } does not exist."
else then fs.stat p, ( error, stat ) ->
console.log "#{ p } exists and is a #{ if stat.isFile() then 'file' else then 'directory' }."
 
 
 

[edit] Clojure

 
 
(map #(.exists (clojure.java.io/as-file %)) '("/input.txt" "/docs" "./input.txt" "./docs"))
 
 

[edit] Common Lisp

probe-file returns nil if a file does not exist. directory returns nil if there are no files in a specified directory.

(if (probe-file (make-pathname :name "input.txt"))
(print "rel file exists"))
(if (probe-file (make-pathname :directory '(:absolute "") :name "input.txt"))
(print "abs file exists"))
 
(if (directory (make-pathname :directory '(:relative "docs")))
(print "rel directory exists")
(print "rel directory is not known to exist"))
(if (directory (make-pathname :directory '(:absolute "docs")))
(print "abs directory exists")
(print "abs directory is not known to exist"))

There is no standardized way to determine if an empty directory exists, as Common Lisp dates from before the notion of directories as a type of file was near-universal. CL-FAD provides many of the therefore-missing capabilities in a cross-implementation library.

Library: CL-FAD
(if (cl-fad:directory-exists-p (make-pathname :directory '(:relative "docs")))
(print "rel directory exists")
(print "rel directory does not exist"))

[edit] D

import std.stdio, std.file, std.path;
 
void verify(in string name) {
if (name.exists())
writeln("'", name, "' exists");
else
writeln("'", name, "' doesn't exist");
}
 
void main() {
// check in current working dir
verify("input.txt");
verify("docs");
 
// check in root
verify(dirSeparator ~ "input.txt");
verify(dirSeparator ~ "docs");
}
Output:
'input.txt' doesn't exist
'docs' doesn't exist
'\input.txt' doesn't exist
'\docs' doesn't exist

[edit] Delphi

program EnsureFileExists;
 
{$APPTYPE CONSOLE}
 
uses
SysUtils;
 
begin
if FileExists('input.txt') then
Writeln('File "input.txt" exists.')
else
Writeln('File "input.txt" does not exist.');
 
if FileExists('\input.txt') then
Writeln('File "\input.txt" exists.')
else
Writeln('File "\input.txt" does not exist.');
 
if DirectoryExists('docs') then
Writeln('Directory "docs" exists.')
else
Writeln('Directory "docs" does not exists.');
 
if DirectoryExists('\docs') then
Writeln('Directory "\docs" exists.')
else
Writeln('Directory "\docs" does not exists.');
end.

[edit] E

for file in [<file:input.txt>,
<file:///input.txt>] {
require(file.exists(), fn { `$file is missing!` })
require(!file.isDirectory(), fn { `$file is a directory!` })
}
 
for file in [<file:docs>,
<file:///docs>] {
require(file.exists(), fn { `$file is missing!` })
require(file.isDirectory(), fn { `$file is not a directory!` })
}

[edit] Erlang

#!/usr/bin/escript
existence( true ) ->"exists";
existence( false ) ->"does not exist".
 
print_result(Type, Name, Flag) -> io:fwrite( "~s ~s ~s~n", [Type, Name, existence(Flag)] ).
 
 
main(_) ->
print_result( "File", "input.txt", filelib:is_regular("input.txt") ),
print_result( "Directory", "docs", filelib:is_dir("docs") ),
print_result( "File", "/input.txt", filelib:is_regular("/input.txt") ),
print_result( "Directory", "/docs", filelib:is_dir("/docs") ).
 

[edit] Euphoria

include file.e
 
procedure ensure_exists(sequence name)
object x
sequence s
x = dir(name)
if sequence(x) then
if find('d',x[1][D_ATTRIBUTES]) then
s = "directory"
else
s = "file"
end if
printf(1,"%s %s exists.\n",{name,s})
else
printf(1,"%s does not exist.\n",{name})
end if
end procedure
 
ensure_exists("input.txt")
ensure_exists("docs")
ensure_exists("/input.txt")
ensure_exists("/docs")

[edit] F#

open System.IO
File.Exists("input.txt")
Directory.Exists("docs")
File.Exists("/input.txt")
Directory.Exists(@"\docs")

[edit] Factor

: print-exists? ( path -- )
[ write ": " write ] [ exists? "exists." "doesn't exist." ? print ] bi ;
 
{ "input.txt" "/input.txt" "docs" "/docs" } [ print-exists? ] each

[edit] Forth

: .exists ( str len -- ) 2dup file-status nip 0= if type ."  exists" else type ."  does not exist" then ;
s" input.txt" .exists
s" /input.txt" .exists
s" docs" .exists
s" /docs" .exists

[edit] Fortran

Works with: Fortran version 90 and later

Cannot check for directories in Fortran

LOGICAL :: file_exists
INQUIRE(FILE="input.txt", EXIST=file_exists) ! file_exists will be TRUE if the file
! exists and FALSE otherwise
INQUIRE(FILE="/input.txt", EXIST=file_exists)

Actually, f90,f95 are able to deal with directory staff:

logical :: dir_e
! a trick to be sure docs is a dir
inquire( file="./docs/.", exist=dir_e )
if ( dir_e ) then
write(*,*), "dir exists!"
else
! workaround: it calls an extern program...
call system('mkdir docs')
end if

[edit] GAP

IsExistingFile("input.txt");     
IsDirectoryPath("docs");
IsExistingFile("/input.txt");
IsDirectoryPath("/docs");

[edit] Go

package main
 
import (
"fmt"
"os"
)
 
func printStat(p string) {
switch i, err := os.Stat(p); {
case err != nil:
fmt.Println(err)
case i.IsDir():
fmt.Println(p, "is a directory")
default:
fmt.Println(p, "is a file")
}
}
 
func main() {
printStat("input.txt")
printStat("/input.txt")
printStat("docs")
printStat("/docs")
}

[edit] Groovy

println new File('input.txt').exists()
println new File('/input.txt').exists()
println new File('docs').exists()
println new File('/docs').exists()

[edit] Haskell

import System.IO
import System.Directory
 
check :: (FilePath -> IO Bool) -> FilePath -> IO ()
check p s = do
result <- p s
putStrLn $ s ++ if result then " does exist" else " does not exist"
 
main = do
check doesFileExist "input.txt"
check doesDirectoryExist "docs"
check doesFileExist "/input.txt"
check doesDirectoryExist "/docs"

[edit] HicEst

   OPEN(FIle=   'input.txt', OLD, IOStat=ios, ERror=99)
OPEN(FIle='C:\input.txt', OLD, IOStat=ios, ERror=99)
! ...
99 WRITE(Messagebox='!') 'File does not exist. Error message ', ios

[edit] Icon and Unicon

Icon doesn't support 'stat'; however, information can be obtained by use of the system function to access command line.

every dir := !["./","/"] do {
write("file ", f := dir || "input.txt", if stat(f) then " exists." else " doesn't exist.")
write("directory ", f := dir || "docs", if stat(f) then " exists." else " doesn't exist.")
}

Note: Icon and Unicon accept both / and \ for directory separators.

[edit] IDL

 
print, FILE_TEST('input.txt')
print, FILE_TEST(PATH_SEP()+'input.txt')
print, FILE_TEST('docs', /DIRECTORY)
print, FILE_TEST(PATH_SEP()+'docs', /DIRECTORY)
 
 

[edit] J

require 'files'
fexist 'input.txt'
fexist '/input.txt'
direxist=: 2 = ftype
direxist 'docs'
direxist '/docs'

[edit] Java

import java.io.File;
public class FileExistsTest {
public static boolean isFileExists(String filename) {
boolean exists = new File(filename).exists();
return exists;
}
public static void test(String type, String filename) {
System.out.println("The following " + type + " called " + filename +
(isFileExists(filename) ? " exists." : " not exists.")
);
}
public static void main(String args[]) {
test("file", "input.txt");
test("file", File.separator + "input.txt");
test("directory", "docs");
test("directory", File.separator + "docs" + File.separator);
}
}
Works with: Java version 7+
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
public class FileExistsTest{
private static FileSystem defaultFS = FileSystems.getDefault();
public static boolean isFileExists(String filename){
return Files.exists(defaultFS.getPath(filename));
}
public static void test(String type, String filename){
System.out.println("The following " + type + " called " + filename +
(isFileExists(filename) ? " exists." : " not exists.")
);
}
public static void main(String args[]){
test("file", "input.txt");
test("file", defaultFS.getSeparator() + "input.txt");
test("directory", "docs");
test("directory", defaultFS.getSeparator() + "docs" + defaultFS.getSeparator());
}
}

[edit] JavaScript

Works with: JScript
var fso = new ActiveXObject("Scripting.FileSystemObject");
 
fso.FileExists('input.txt');
fso.FileExists('c:/input.txt');
fso.FolderExists('docs');
fso.FolderExists('c:/docs');

[edit] Julia

isfile("input.txt")
isfile("/input.txt")
isdir("docs")
isdir("/docs")

[edit] LabVIEW

Library: LabVIEW CWD

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Ensure that a file exists.png


[edit] Lasso

// local file
file_exists('input.txt')
 
// local directory
file_exists('docs')
 
// file in root file system (requires permissions at user OS level)
file_exists('//input.txt')
 
// directory in root file system (requires permissions at user OS level)
file_exists('//docs')

[edit] LFE

From the LFE REPL:

 
> (: filelib is_regular '"input.txt")
false
> (: filelib is_dir '"docs")
false
> (: filelib is_regular '"/input.txt")
false
> (: filelib is_dir '"/docs"))
false
 

[edit] Liberty BASIC

'fileExists.bas - Show how to determine if a file exists
dim info$(10,10)
input "Type a file path (ie. c:\windows\somefile.txt)?"; fpath$
if fileExists(fpath$) then
print fpath$; " exists!"
else
print fpath$; " doesn't exist!"
end if
end
 
'return a true if the file in fullPath$ exists, else return false
function fileExists(fullPath$)
files pathOnly$(fullPath$), filenameOnly$(fullPath$), info$()
fileExists = val(info$(0, 0)) > 0
end function
 
'return just the directory path from a full file path
function pathOnly$(fullPath$)
pathOnly$ = fullPath$
while right$(pathOnly$, 1) <> "\" and pathOnly$ <> ""
pathOnly$ = left$(pathOnly$, len(pathOnly$)-1)
wend
end function
 
'return just the filename from a full file path
function filenameOnly$(fullPath$)
pathLength = len(pathOnly$(fullPath$))
filenameOnly$ = right$(fullPath$, len(fullPath$)-pathLength)
end function

[edit]

Works with: UCB Logo
show file? "input.txt
show file? "/input.txt
show file? "docs
show file? "/docs

Alternatively, one can set a file prefix used for subsequent file commands.

setprefix "/
show file? "input.txt

[edit] Lua

For directories, the following only works on platforms on which directories can be opened for reading like files.

function output( s, b )
if b then
print ( s, " does not exist." )
else
print ( s, " does exist." )
end
end
 
output( "input.txt", io.open( "input.txt", "r" ) == nil )
output( "/input.txt", io.open( "/input.txt", "r" ) == nil )
output( "docs", io.open( "docs", "r" ) == nil )
output( "/docs", io.open( "/docs", "r" ) == nil )

The following more portable solution uses LuaFileSystem.

require "lfs"
for i, path in ipairs({"input.txt", "/input.txt", "docs", "/docs"}) do
local mode = lfs.attributes(path, "mode")
if mode then
print(path .. " exists and is a " .. mode .. ".")
else
print(path .. " does not exist.")
end
end


[edit] Maple

with(FileTools):
Exists("input.txt");
Exists("docs") and IsDirectory("docs");
Exists("/input.txt");
Exists("/docs") and IsDirectory("/docs");

[edit] Mathematica

wd = NotebookDirectory[];
FileExistsQ[wd <> "input.txt"]
DirectoryQ[wd <> "docs"]
 
FileExistsQ["/" <> "input.txt"]
DirectoryQ["/" <> "docs"]


[edit] MATLAB / Octave

 exist('input.txt','file') 
exist('/input.txt','file')
exist('docs','dir')
exist('/docs','dir')

[edit] MAXScript

-- Here
doesFileExist "input.txt"
(getDirectories "docs").count == 1
-- Root
doesFileExist "\input.txt"
(getDirectories "C:\docs").count == 1

[edit] Modula-3

MODULE FileTest EXPORTS Main;
 
IMPORT IO, Fmt, FS, File, OSError, Pathname;
 
PROCEDURE FileExists(file: Pathname.T): BOOLEAN =
VAR status: File.Status;
BEGIN
TRY
status := FS.Status(file);
RETURN TRUE;
EXCEPT
| OSError.E => RETURN FALSE;
END;
END FileExists;
 
BEGIN
IO.Put(Fmt.Bool(FileExists("input.txt")) & "\n");
IO.Put(Fmt.Bool(FileExists("/input.txt")) & "\n");
IO.Put(Fmt.Bool(FileExists("docs/")) & "\n");
IO.Put(Fmt.Bool(FileExists("/docs")) & "\n");
END FileTest.

[edit] Nemerle

Translation of: C#
using System.Console;
using System.IO;
 
WriteLine(File.Exists("input.txt"));
WriteLine(File.Exists("/input.txt"));
WriteLine(Directory.Exists("docs"));
WriteLine(Directory.Exists("/docs"));

[edit] NetRexx

/* NetRexx */
options replace format comments java crossref symbols binary
 
runSample(arg)
return
 
-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method isExistingFile(fn) public static returns boolean
ff = File(fn)
fExists = ff.exists() & ff.isFile()
return fExists
 
-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method isExistingDirectory(fn) public static returns boolean
ff = File(fn)
fExists = ff.exists() & ff.isDirectory()
return fExists
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static
parse arg files
if files = '' then files = 'input.txt F docs D /input.txt F /docs D'
loop while files.length > 0
parse files fn ft files
select case(ft.upper())
when 'F' then do
if isExistingFile(fn) then ex = 'exists'
else ex = 'does not exist'
say 'File '''fn'''' ex
end
when 'D' then do
if isExistingDirectory(fn) then ex = 'exists'
else ex = 'does not exist'
say 'Directory '''fn'''' ex
end
otherwise do
if isExistingFile(fn) then ex = 'exists'
else ex = 'does not exist'
say 'File '''fn'''' ex
end
end
end
 
return
 

[edit] Objective-C

NSFileManager *fm = [NSFileManager defaultManager];
NSLog(@"input.txt %s", [fm fileExistsAtPath:@"input.txt"] ? @"exists" : @"doesn't exist");
NSLog(@"docs %s", [fm fileExistsAtPath:@"docs"] ? @"exists" : @"doesn't exist");

[edit] Objeck

 
use IO;
 
bundle Default {
class Test {
function : Main(args : String[]) ~ Nil {
File->Exists("input.txt")->PrintLine();
File->Exists("/input.txt")->PrintLine();
Directory->Exists("docs")->PrintLine();
Directory->Exists("/docs")->PrintLine();
}
}
 

[edit] OCaml

Sys.file_exists "input.txt";;
Sys.file_exists "docs";;
Sys.file_exists "/input.txt";;
Sys.file_exists "/docs";;

[edit] ooRexx

/**********************************************************************
* exists(filespec)
* returns 1 if filespec identifies a file with size>0
* (a file of size 0 is deemed not to exist.)
* or a directory
* 0 otherwise
* 09.06.2013 Walter Pachl (retrieved from my toolset)
**********************************************************************/

exists:
parse arg spec
call sysfiletree spec, 'LIST', 'BL'
if list.0\=1 then return 0 -- does not exist
parse var list.1 . . size flags .
if size>0 then return 1 -- real file
If substr(flags,2,1)='D' Then Do
Say spec 'is a directory'
Return 1
End
If size=0 Then Say spec 'is a zero-size file'
Return 0

[edit] Oz

declare
[Path] = {Module.link ['x-oz://system/os/Path.ozf']}
in
{Show {Path.exists "docs"}}
{Show {Path.exists "input.txt"}}
{Show {Path.exists "/docs"}}
{Show {Path.exists "/input.txt"}}

[edit] PARI/GP

trap(,"does not exist",read("input.txt");"exists")
trap(,"does not exist",read("c:\\input.txt");"exists")
trap(,"does not exist",read("c:\\dirname\\nul");"exists")

A better version would use externstr.

Under PARI it would typically be more convenient to use C methods.

[edit] Pascal

See Delphi

[edit] PHP

if (file_exists('input.txt')) echo 'input.txt is here right by my side';
if (file_exists('docs' )) echo 'docs is here with me';
if (file_exists('/input.txt')) echo 'input.txt is over there in the root dir';
if (file_exists('/docs' )) echo 'docs is over there in the root dir';

[edit] Perl

use File::Spec::Functions qw(catfile rootdir);
# here
print -e 'input.txt';
print -d 'docs';
# root dir
print -e catfile rootdir, 'input.txt';
print -d catfile rootdir, 'docs';

Without a Perl Module

A 1 is printed if the file or dir exists.

perl -e 'print -e "./input.txt", "\n";'
perl -e 'print -d "./docs", "\n";'
perl -e 'print -e "/input.txt", "\n";'
perl -e 'print -d "/docs", "\n";'

[edit] Perl 6

'input.txt'.IO ~~ :e;
'docs'.IO ~~ :d;
'/input.txt'.IO ~~ :e;
'/docs'.IO ~~ :d

[edit] PicoLisp

(if (info "file.txt")
(prinl "Size: " (car @) " bytes, last modified " (stamp (cadr @) (cddr @)))
(prinl "File doesn't exist") )

[edit] Pike

import Stdio;
 
int main(){
if(exist("/var")){
write("/var exists!\n");
}
 
if(exist("file-exists.pike")){
write("I exist!\n");
}
}

[edit] PL/I

*Process source or(!);
/*********************************************************************
* 20.10.2013 Walter Pachl
* 'set dd:f=d:\_l\xxx.txt,recsize(300)'
* 'tex'
*********************************************************************/

tex: Proc Options(main);
Dcl fid Char(30) Var Init('D:\_l\tst.txt');
Dcl xxx Char(30) Var Init('D:\_l\nix.txt');
Dcl r Char(1000) Var;
Dcl f Record input;
On Undefinedfile(f) Goto label;
Open File(f) Title('/'!!fid);
Read file(f) Into(r);
Put Skip List('First line of file '!!fid!!': '!!r);
Close File(f);
Open File(f) Title('/'!!xxx);
Read file(f) Into(r);
Put Skip List(r);
Close File(f);
Label: Put Skip List('File '!!xxx!!' not found');
End;

Output:

  
First line of file D:\_l\tst.txt: Test line 1
File D:\_l\nix.txt not found    

[edit] Pop11

sys_file_exists('input.txt') =>
sys_file_exists('/input.txt') =>
sys_file_exists('docs') =>
sys_file_exists('/docs') =>

Note that the above literally checks for existence. Namely sys_file_exists returns true if file exists but can not be read.

The only sure method to check if file can be read is to try to open it. If one just wants to check if file is readable the following may be useful:

;;; Define an auxilary function, returns boolean
define file_readable(fname);
lvars f = sysopen(fname, 0, true, `A`);
if f then
sysclose(f);
return (true);
else
return (false);
endif;
enddefine;

The above works but is not the only way or the best way to check status of a file in Pop11. There is a very general procedure sys_file_stat that allows interrogation of a file or directory. The full documentation can be seen in the online documentation (search for sys_file_stat):

http://wwwcgi.rdg.ac.uk:8081/cgi-bin/cgiwrap/wsi14/poplog/pop11/ref/sysio

http://www.poplog.org/docs/popdocs/pop11/ref/sysio

http://www.cs.bham.ac.uk/research/projects/poplog/doc/popref/sysio (Not so well formatted).

Users can easily define special cases of the general procedure.

[edit] PowerShell

 Test-Path input.txt

[edit] PureBasic

result = ReadFile(#PB_Any, "input.txt")
If result>0 : Debug "this local file exists"
Else : Debug "result=" +Str(result) +" so this local file is missing"
EndIf
 
result = ReadFile(#PB_Any, "/input.txt")
If result>0 : Debug "this root file exists"
Else : Debug "result=" +Str(result) +" so this root file is missing"
EndIf
 
result = ExamineDirectory(#PB_Any,"docs","")
If result>0 : Debug "this local directory exists"
Else : Debug "result=" +Str(result) +" so this local directory is missing"
EndIf
 
result = ExamineDirectory(#PB_Any,"/docs","")
If result>0 : Debug "this root directory exists"
Else : Debug "result=" +Str(result) +" so this root directory is missing"
EndIf

[edit] Python

Works with: Python version 2.5

The os.path.exists method will return True if a path exists False if it does not.

import os
 
os.path.exists("input.txt")
os.path.exists("/input.txt")
os.path.exists("docs")
os.path.exists("/docs")

[edit] R

file.exists("input.txt")
file.exists("/input.txt")
file.exists("docs")
file.exists("/docs")
 
# or
file.exists("input.txt", "/input.txt", "docs", "/docs")

The function file.exists returns a logical value (or a vector of logical values if more than one argument is passed)

[edit] Racket

 
#lang racket
 
;; here
(file-exists? "input.txt")
(file-exists? "docs")
 
;; in the root
(file-exists? "/input.txt")
(file-exists? "/docs")
 
;; or in the root with relative paths
(parameterize ([current-directory "/"])
(and (file-exists? "input.txt")
(file-exists? "docs")))
 

[edit] Raven

'input.txt'  exists if 'input.txt exists'  print
'/input.txt' exists if '/input.txt exists' print
'docs' isdir if 'docs exists and is a directory' print
'/docs' isdir if '/docs exists and is a directory' print

[edit] REBOL

exists? %input.txt
exists? %docs/
 
exists? %/input.txt
exists? %/docs/

[edit] REXX

This version works with:

  • PC/REXX
  • Personal REXX
  • REGINA
/*REXX pgm creates a new empty file and directory; in curr dir and root.*/
fn='input.txt'
dn='docs'
@.1='current directory'; @.2='root directory' /*msgs for each pass.*/
parse upper version v; regina=pos('REGINA',v)\==0 /*Regina being used? */
 
do j=1 for 2; say /*perform these statements twice.*/
if stream(fn,'C',"QUERY EXISTS")=='' then say 'file ' fn " doesn't exist in the" @.j
else say 'file ' fn " does exist in the" @.j
if dosisdir(dn) then say 'directory ' dn " does exist in the" @.j
else say 'directory ' dn " doesn't exist in the" @.j
if regina then call chdir '\' /*use Regina's version of CHDIR.*/
else call doschdir '\' /*PC/REXX & Personal REXX version*/
end /*j*/ /*now, go and perform them again.*/
/*stick a fork in it, we're done.*/


[edit] RLaB

RLaB provides two user functions for the task, isfile and isdir.

 
>> isdir("docs")
0
>> isfile("input.txt")
0
 

[edit] Ruby

File.exists? only checks if a file exists; it can be a regular file, a directory, or something else. File.file? or File.directory? checks for a regular file or a directory. Ruby also allows FileTest.file? or FileTest.directory?.

File.file?("input.txt")
File.file?("/input.txt")
File.directory?("docs")
File.directory?("/docs")

The next program runs all four checks and prints the results.

["input.txt", "/input.txt"].each { |f|
printf "%s is a regular file? %s\n", f, File.file?(f) }
["docs", "/docs"].each { |d|
printf "%s is a directory? %s\n", d, File.directory?(d) }


[edit] Run BASIC

files #f,"input.txt"
if #f hasanswer() = 1 then print "File does not exist"
 
files #f,"docs"
if #f hasanswer() = 1 then print "File does not exist"
if #f isDir() = 0 then print "This is a directory"
 

[edit] Scala

import java.io.File
println(new File('input.txt').exists)
println(new File('/input.txt').exists)
println(new File('docs').exists)
println(new File('/docs').exists)


[edit] Scheme

Works with: Scheme version R6RS
[1]
(file-exists? filename)

[edit] Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
begin
writeln(fileType("input.txt") = FILE_REGULAR);
writeln(fileType("/input.txt") = FILE_REGULAR);
writeln(fileType("docs") = FILE_DIR);
writeln(fileType("/docs") = FILE_DIR);
end func;

[edit] Slate

(File newNamed: 'input.txt') exists
(File newNamed: '/input.txt') exists
(Directory root / 'input.txt') exists
(Directory newNamed: 'docs') exists
(Directory newNamed: '/docs') exists

[edit] Smalltalk

Squeak has no notion of 'current directory' because it isn't tied to the shell that created it.

FileDirectory new fileExists: 'c:\serial'.
(FileDirectory on: 'c:\') directoryExists: 'docs'.

In GNU Smalltalk instead you can do:

(Directory name: 'docs') exists ifTrue: [ ... ]
(Directory name: 'c:\docs') exists ifTrue: [ ... ]
(File name: 'serial') isFile ifTrue: [ ... ]
(File name: 'c:\serial') isFile ifTrue: [ ... ]

Using exists in the third and fourth case will return true for directories too.

[edit] Standard ML

OS.FileSys.access ("input.txt", []);
OS.FileSys.access ("docs", []);
OS.FileSys.access ("/input.txt", []);
OS.FileSys.access ("/docs", []);

[edit] Tcl

Taking the meaning of the task from the DOS example:

if { [file exists "input.txt"] } {
puts "input.txt exists"
}
 
if { [file exists [file nativename "/input.txt"]] } {
puts "/input.txt exists"
}
 
if { [file isdirectory "docs"] } {
puts "docs exists and is a directory"
}
 
if { [file isdirectory [file nativename "/docs"]] } {
puts "/docs exists and is a directory"
}

Note that these operations do not require the use of file nativename on either Windows or any version of Unix.

[edit] Toka

[ "R" file.open dup 0 <> [ dup file.close ] ifTrue 0 <> ] is exists?
" input.txt" exists? .
" /input.txt" exists? .
" docs" exists? .
" /docs" exists? .

[edit] TUSCRIPT

 
$$ MODE TUSCRIPT
file="input.txt",directory="docs"
IF (file=='file') THEN
PRINT file, " exists"
ELSE
PRINT/ERROR file," not exists"
ENDIF
IF (directory=='project') THEN
PRINT directory," exists"
ELSE
PRINT/ERROR "directory ",directory," not exists"
ENDIF
 

Output:

input.txt exists
@@@@@@@@  directory docs not exists                                    @@@@@@@@ 

[edit] UNIX Shell

test -f input.txt
test -f /input.txt
test -d docs
test -d /docs

The next program runs all four checks and prints the results.

for f in input.txt /input.txt; do
test -f "$f" && r=true || r=false
echo "$f is a regular file? $r"
done
for d in docs /docs; do
test -d "$d" && r=true || r=false
echo "$d is a directory? $r"
done

[edit] Vedit macro language

Vedit allows using either '\' or '/' as directory separator character, it is automatically converted to the one used by the operating system.

// In current directory
if (File_Exist("input.txt")) { M("input.txt exists\n") } else { M("input.txt does not exist\n") }
if (File_Exist("docs/nul", NOERR)) { M("docs exists\n") } else { M("docs does not exist\n") }
 
// In the root directory
if (File_Exist("/input.txt")) { M("/input.txt exists\n") } else { M("/input.txt does not exist\n") }
if (File_Exist("/docs/nul", NOERR)) { M("/docs exists\n") } else { M("/docs does not exist\n") }

[edit] Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+
'Current Directory
Console.WriteLine(If(IO.Directory.Exists("docs"), "directory exists", "directory doesn't exists"))
Console.WriteLine(If(IO.Directory.Exists("output.txt"), "file exists", "file doesn't exists"))
 
'Root
Console.WriteLine(If(IO.Directory.Exists("\docs"), "directory exists", "directory doesn't exists"))
Console.WriteLine(If(IO.Directory.Exists("\output.txt"), "file exists", "file doesn't exists"))
 
'Root, platform independent
Console.WriteLine(If(IO.Directory.Exists(IO.Path.DirectorySeparatorChar & "docs"), _
"directory exists", "directory doesn't exists"))
Console.WriteLine(If(IO.Directory.Exists(IO.Path.DirectorySeparatorChar & "output.txt"), _
"file exists", "file doesn't exists"))

[edit] VBScript

Set FSO=CreateObject("Scripting.FileSystemObject")
Function FileExists(strFile)
if FSO.fileExists(strFile) then
FileExists=true
else
FileExists=false
end if
end function
 
Function folderExists(strFolder)
if FSO.folderExists(strFolder) then
folderExists=true
else
folderexists=false
end if
end function
 
'''''usage (apostrophes indicate comments-this section will not be run)'''''
'if fileExists("C:\test.txt") then
'msgbox"It Exists!"
'else
'msgbox"awww"
'end if
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
 

[edit] zkl

File.exists("input.txt")  //--> True (in this case a sym link)
File.exists("/input.txt") //-->False
File.isDir("/") //-->True
File.isDir("docs") //-->False
 
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox