Check that file exists: Difference between revisions

 
(160 intermediate revisions by 64 users not shown)
Line 1:
{{task|File System Operations}} [[Category:Simple]]
{{task|File System Operations}}
;Task:
Verify that a file called     '''input.txt'''     and   a directory called     '''docs'''     exist.
 
This should be done twice:  
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.
:::*   once for a file and a directory in the filesystem root.
 
<br>
Optional criteria (May 2015): verify it works with 0-length files; and with an unusual filename: `Abdu'l-Bahá.txt
Optional criteria (May 2015): &nbsp; verify it works with:
:::* &nbsp; zero-length files
:::* &nbsp; an unusual filename: &nbsp; <big> ''' `Abdu'l-Bahá.txt ''' </big>
<br><br>
=={{header|11l}}==
{{Trans|Python}}
<syntaxhighlight lang="11l">fs:is_file(‘input.txt’)
fs:is_file(‘/input.txt’)
fs:is_dir(‘docs’)
fs:is_dir(‘/docs’)</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program verifFic64.s */
 
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ CHDIR, 49
.equ AT_FDCWD, -100
 
/*******************************************/
/* Initialized data */
/*******************************************/
.data
szMessFound1: .asciz "File 1 found.\n"
szMessFound2: .asciz "File 2 found.\n"
szMessNotFound1: .asciz "File 1 not found.\n"
szMessNotFound2: .asciz "File 2 not found.\n"
szMessDir2: .asciz "File 2 is a directory.\n"
szMessNotAuth2: .asciz "File 2 permission denied.\n"
szCarriageReturn: .asciz "\n"
/* areas strings */
szPath2: .asciz "/"
szFicName1: .asciz "test1.txt"
szFicName2: .asciz "root"
/*******************************************/
/* UnInitialized data */
/*******************************************/
.bss
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main: // entry of program
 
/*************************************
open file 1
************************************/
mov x0,AT_FDCWD // current directory
ldr x1,qAdrszFicName1 // file name
mov x2,#O_RDWR // flags
mov x3,#0 // mode
mov x8, #OPEN // call system OPEN
svc 0
cmp x0,#0 // error ?
ble 1f
mov x1,x0 // FD
ldr x0,qAdrszMessFound1
bl affichageMess
// close file
mov x0,x1 // Fd
mov x8, #CLOSE
svc 0
b 2f
1:
ldr x0,qAdrszMessNotFound1
bl affichageMess
2:
/*************************************
open file 2
************************************/
ldr x0,qAdrszPath2
mov x8,CHDIR // call system change directory
svc 0
mov x0,AT_FDCWD // current directory
ldr x1,qAdrszFicName2 // file name
mov x2,O_RDWR // flags
mov x3,0 // mode
mov x8,OPEN // call system OPEN
svc 0
cmp x0,-21 // is a directory ?
beq 4f
cmp x0,0 // error ?
ble 3f
mov x1,x0 // FD
ldr x0,qAdrszMessFound2
bl affichageMess
// close file
mov x0,x1 // Fd
mov x8, #CLOSE
svc 0
b 100f
3:
ldr x0,qAdrszMessNotFound2
bl affichageMess
b 100f
4:
ldr x0,qAdrszMessDir2
bl affichageMess
100: // standard end of the program
mov x0,0 // return code
mov x8,EXIT // request to exit program
svc 0 // perform the system call
qAdrszFicName1: .quad szFicName1
qAdrszFicName2: .quad szFicName2
qAdrszMessFound1: .quad szMessFound1
qAdrszMessFound2: .quad szMessFound2
qAdrszMessNotFound1: .quad szMessNotFound1
qAdrszMessNotFound2: .quad szMessNotFound2
qAdrszMessNotAuth2: .quad szMessNotAuth2
qAdrszPath2: .quad szPath2
qAdrszMessDir2: .quad szMessDir2
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|Action!}}==
<syntaxhighlight lang="action!">BYTE lastError
 
PROC MyError(BYTE errCode)
lastError=errCode
RETURN
 
BYTE FUNC FileExists(CHAR ARRAY fname)
DEFINE PTR="CARD"
PTR old
BYTE dev=[1]
 
lastError=0
old=Error
Error=MyError ;replace error handling to capture I/O error
 
Close(dev)
Open(dev,fname,4)
Close(dev)
 
Error=old ;restore the original error handling
 
IF lastError=0 THEN
RETURN (1)
FI
RETURN (0)
 
PROC Test(CHAR ARRAY fname)
BYTE exists
 
exists=FileExists(fname)
IF exists THEN
PrintF("File ""%S"" exists.%E",fname)
ELSE
PrintF("File ""%S"" does not exist.%E",fname)
FI
RETURN
 
PROC Main()
Test("D:INPUT.TXT")
Test("D:DOS.SYS")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Check_that_file_exists.png Screenshot from Atari 8-bit computer]
<pre>
File "D:INPUT.TXT" does not exist.
File "D:DOS.SYS" exists.
</pre>
=={{header|Ada}}==
This example should work with any Ada 95 compiler.
<langsyntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
 
procedure File_Exists is
Line 24 ⟶ 201:
Put_Line (Boolean'Image (Does_File_Exist ("input.txt" )));
Put_Line (Boolean'Image (Does_File_Exist ("\input.txt")));
end File_Exists;</langsyntaxhighlight>
This example should work with any Ada 2005 compiler.
<langsyntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
with Ada.Directories; use Ada.Directories;
 
Line 45 ⟶ 222:
Print_Dir_Exist ("docs");
Print_Dir_Exist ("/docs");
end File_Exists;</langsyntaxhighlight>
 
=={{header|Aikido}}==
The <code>stat</code> function returns a <code>System.Stat</code> object for an existing file or directory, or <code>null</code> if it can't be found.
<langsyntaxhighlight lang="aikido">
function exists (filename) {
return stat (filename) != null
Line 59 ⟶ 235:
exists ("/docs")
 
</syntaxhighlight>
</lang>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses the Algol 68G specific "file is directory" procedure to test for the existence of directories.
<syntaxhighlight lang="algol68"># Check files and directories exist #
 
# check a file exists by attempting to open it for input #
# returns TRUE if the file exists, FALSE otherwise #
PROC file exists = ( STRING file name )BOOL:
IF FILE f;
open( f, file name, stand in channel ) = 0
THEN
# file opened OK so must exist #
close( f );
TRUE
ELSE
# file cannot be opened - assume it does not exist #
FALSE
FI # file exists # ;
 
# print a suitable messages if the specified file exists #
PROC test file exists = ( STRING name )VOID:
print( ( "file: "
, name
, IF file exists( name ) THEN " does" ELSE " does not" FI
, " exist"
, newline
)
);
# print a suitable messages if the specified directory exists #
PROC test directory exists = ( STRING name )VOID:
print( ( "dir: "
, name
, IF file is directory( name ) THEN " does" ELSE " does not" FI
, " exist"
, newline
)
);
 
# test the flies and directories mentioned in the task exist or not #
test file exists( "input.txt" );
test file exists( "\input.txt");
test directory exists( "docs" );
test directory exists( "\docs" )</syntaxhighlight>
=={{header|Amazing Hopper}}==
Version: hopper-FLOW!:
<syntaxhighlight lang="amazing hopper">
#include <flow.h>
 
DEF-MAIN(argv, argc)
WHEN( IS-FILE?("hopper") ){
MEM("File \"hopper\" exist!\n")
}
WHEN( IS-DIR?("fl") ){
MEM("Directory \"fl\" exist!\n")
}
IF( IS-DIR?("noExisDir"), "Directory \"noExistDir\" exist!\n", \
"Directory \"noExistDir\" does NOT exist!\n" )
//"arch mañoso bacán.txt" text-file created
 
STR-TO-UTF8("File \"arch mañoso bacán.txt\" ")
IF( IS-FILE?( STR-TO-UTF8("arch mañoso bacán.txt") ), "exist!\n", "NOT exist!\n")
 
PRNL
END
</syntaxhighlight>
{{out}}
<pre>
$ hopper existFile.flw
File "hopper" exist!
Directory "fl" exist!
Directory "noExistDir" does NOT exist!
File "arch mañoso bacán.txt" exist!
$
</pre>
=={{header|APL}}==
<syntaxhighlight lang="apl">
h ← ⎕fio['fopen'] 'input.txt'
h
7
⎕fio['fstat'] h
66311 803134 33188 1 1000 1000 0 11634 4096 24 1642047105 1642047105 1642047105
⎕fio['fclose'] h
0
h ← ⎕fio['fopen'] 'docs/'
h
7
⎕fio['fstat'] h
66311 3296858 16877 2 1000 1000 0 4096 4096 8 1642047108 1642047108 1642047108
⎕fio['fclose'] h
0
h ← ⎕fio['fopen'] 'does_not_exist.txt'
h
¯1
</syntaxhighlight>
=={{header|AppleScript}}==
{{Trans|JavaScript}}
(macOS JavaScript for Automation)
<syntaxhighlight lang="applescript">use framework "Foundation" -- YOSEMITE OS X onwards
use scripting additions
 
on run
setCurrentDirectory("~/Desktop")
ap({doesFileExist, doesDirectoryExist}, ¬
{"input.txt", "/input.txt", "docs", "/docs"})
--> {true, true, true, true, false, false, true, true}
-- The first four booleans are returned by `doesFileExist`.
-- The last four are returned by `doesDirectoryExist`,
-- which yields false for simple files, and true for directories.
end run
 
-- GENERIC SYSTEM DIRECTORY FUNCTIONS -----------------------------------------
 
-- doesDirectoryExist :: String -> Bool
on doesDirectoryExist(strPath)
set ca to current application
set oPath to (ca's NSString's stringWithString:strPath)'s ¬
stringByStandardizingPath
set {bln, int} to (ca's NSFileManager's defaultManager()'s ¬
fileExistsAtPath:oPath isDirectory:(reference))
bln and (int = 1)
end doesDirectoryExist
 
-- doesFileExist :: String -> Bool
on doesFileExist(strPath)
set ca to current application
set oPath to (ca's NSString's stringWithString:strPath)'s ¬
stringByStandardizingPath
ca's NSFileManager's defaultManager()'s fileExistsAtPath:oPath
end doesFileExist
 
-- getCurrentDirectory :: String
on getCurrentDirectory()
set ca to current application
ca's NSFileManager's defaultManager()'s currentDirectoryPath as string
end getCurrentDirectory
 
-- getFinderDirectory :: String
on getFinderDirectory()
tell application "Finder" to POSIX path of (insertion location as alias)
end getFinderDirectory
 
-- getHomeDirectory :: String
on getHomeDirectory()
(current application's NSHomeDirectory() as string)
end getHomeDirectory
 
-- setCurrentDirectory :: String -> IO ()
on setCurrentDirectory(strPath)
if doesDirectoryExist(strPath) then
set ca to current application
set oPath to (ca's NSString's stringWithString:strPath)'s ¬
stringByStandardizingPath
ca's NSFileManager's defaultManager()'s ¬
changeCurrentDirectoryPath:oPath
end if
end setCurrentDirectory
 
 
-- GENERIC HIGHER ORDER FUNCTIONS FOR THE TEST --------------------------------
 
-- A list of functions applied to a list of arguments
-- (<*> | ap) :: [(a -> b)] -> [a] -> [b]
on ap(fs, xs)
set {intFs, intXs} to {length of fs, length of xs}
set lst to {}
repeat with i from 1 to intFs
tell mReturn(item i of fs)
repeat with j from 1 to intXs
set end of lst to |λ|(contents of (item j of xs))
end repeat
end tell
end repeat
return lst
end ap
 
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn</syntaxhighlight>
{{Out}}
The first four booleans are returned by `doesFileExist`.
The last four are returned by `doesDirectoryExist`,
which yields false for simple files, and true for directories.
<syntaxhighlight lang="applescript">{true, true, true, true, false, false, true, true}</syntaxhighlight>
=={{header|Applesoft BASIC}}==
The error code for FILE NOT FOUND is 6.
<langsyntaxhighlight ApplesoftBasiclang="applesoftbasic">100 F$ = "THAT FILE"
110 T$(0) = "DOES NOT EXIST."
120 T$(1) = "EXISTS."
Line 84 ⟶ 455:
350 REM END TRY
360 RETURN
</syntaxhighlight>
</lang>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program verifFic.s */
 
/* Constantes */
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
.equ OPEN, 5 @ Linux syscall
.equ CLOSE, 6 @ Linux syscall
 
.equ O_RDWR, 0x0002 /* open for reading and writing */
 
/*******************************************/
/* Fichier des macros */
/********************************************/
.include "../../ficmacros.s"
 
/* Initialized data */
.data
szMessFound1: .asciz "File 1 found.\n"
szMessFound2: .asciz "File 2 found.\n"
szMessNotFound1: .asciz "File 1 not found.\n"
szMessNotFound2: .asciz "File 2 not found.\n"
szMessNotAuth2: .asciz "File 2 permission denied.\n"
szCarriageReturn: .asciz "\n"
 
/* areas strings */
szFicName1: .asciz "test1.txt"
szFicName2: .asciz "/debian-binary"
 
 
/* UnInitialized data */
.bss
 
/* code section */
.text
.global main
main: /* entry of program */
push {fp,lr} /* saves 2 registers */
 
/*************************************
open file 1
************************************/
ldr r0,iAdrszFicName1 @ file name
mov r1,#O_RDWR @ flags
mov r2,#0 @ mode
mov r7, #OPEN @ call system OPEN
swi 0
cmp r0,#0 @ error ?
ble 1f
mov r1,r0 @ FD
ldr r0,iAdrszMessFound1
bl affichageMess
@ close file
mov r0,r1 @ Fd
mov r7, #CLOSE
swi 0
b 2f
1:
ldr r0,iAdrszMessNotFound1
bl affichageMess
2:
/*************************************
open file 2
************************************/
ldr r0,iAdrszFicName2 @ file name
mov r1,#O_RDWR @ flags
mov r2,#0 @ mode
mov r7, #OPEN @ call system OPEN
swi 0
vidregtit verif
cmp r0,#-13 @ permission denied
beq 4f
cmp r0,#0 @ error ?
ble 3f
mov r1,r0 @ FD
ldr r0,iAdrszMessFound2
bl affichageMess
@ close file
mov r0,r1 @ Fd
mov r7, #CLOSE
swi 0
b 100f
3:
ldr r0,iAdrszMessNotFound2
bl affichageMess
b 100f
4:
ldr r0,iAdrszMessNotAuth2
bl affichageMess
100: /* standard end of the program */
mov r0, #0 @ return code
pop {fp,lr} @restaur 2 registers
mov r7, #EXIT @ request to exit program
swi 0 @ perform the system call
iAdrszFicName1: .int szFicName1
iAdrszFicName2: .int szFicName2
iAdrszMessFound1: .int szMessFound1
iAdrszMessFound2: .int szMessFound2
iAdrszMessNotFound1: .int szMessNotFound1
iAdrszMessNotFound2: .int szMessNotFound2
iAdrszMessNotAuth2: .int szMessNotAuth2
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {fp,lr} /* save registres */
push {r0,r1,r2,r7} /* save others registers */
mov r2,#0 /* counter length */
1: /* loop length calculation */
ldrb r1,[r0,r2] /* read octet start position + index */
cmp r1,#0 /* if 0 its over */
addne r2,r2,#1 /* else add 1 in the length */
bne 1b /* and loop */
/* so here r2 contains the length of the message */
mov r1,r0 /* address message in r1 */
mov r0,#STDOUT /* code to write to the standard output Linux */
mov r7, #WRITE /* code call system "write" */
swi #0 /* call systeme */
pop {r0,r1,r2,r7} /* restaur others registers */
pop {fp,lr} /* restaur des 2 registres */
bx lr /* return */
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">checkIfExists: function [fpath][
(or? exists? fpath
exists? .directory fpath)? -> print [fpath "exists"]
-> print [fpath "doesn't exist"]
]
checkIfExists "input.txt"
checkIfExists "docs"
checkIfExists "/input.txt"
checkIfExists "/docs"</syntaxhighlight>
=={{header|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.
Line 91 ⟶ 600:
Another option is AutoHotkey's IfExist/IfNotExist command
 
<langsyntaxhighlight lang="autohotkey">; FileExist() function examples
ShowFileExist("input.txt")
ShowFileExist("\input.txt")
Line 123 ⟶ 632:
MsgBox, folder: %folder% does NOT exist.
Return
}</langsyntaxhighlight>
 
=={{header|AWK}}==
{{works with|gawk}}
<langsyntaxhighlight lang="awk">@load "filefuncs"
BEGIN {
exists("input.txt")
exists("/input.txt")
exists("docs")
exists("/docs")
}
 
function exists(name ,fd) {
Line 140 ⟶ 642:
else
print name " exists"
}
}</lang>
BEGIN {
 
Getline method. Also works in a Windows environment.
<lang AWK>BEGIN {
exists("input.txt")
exists("\\/input.txt")
exists("docs")
exists("\\/docs")
}</syntaxhighlight>
exit(0)
}
 
Portable getline method. Also works in a Windows environment.
#
<syntaxhighlight lang="awk">#
# Check if file or directory exists, even 0-length file.
# Return 0 if not exist, 1 if exist
Line 168 ⟶ 668:
return 1
}
}
}</lang>
BEGIN {
exists("input.txt")
exists("\\input.txt")
exists("docs")
exists("\\docs")
exit(0)
}</syntaxhighlight>
 
{{works with|gawk}}
Check file only (nos) directories)existence
<syntaxhighlight lang="text">gawk 'BEGINFILE{if (ERRNO) {print "Not exist."; exitnextfile} }else {print "Exist."; exitnextfile}}' input.txt input-missing.txt</langsyntaxhighlight>
 
=={{header|Axe}}==
<langsyntaxhighlight lang="axe">If GetCalc("appvINPUT")
Disp "EXISTS",i
Else
Disp "DOES NOT EXIST",i
End</langsyntaxhighlight>
 
=={{header|BASIC}}==
{{works with|QBasic}}
<langsyntaxhighlight lang="qbasic">
ON ERROR GOTO ohNo
f$ = "input.txt"
Line 212 ⟶ 717:
END IF
RESUME NEXT
</syntaxhighlight>
</lang>
 
You can also check for a directory by trying to enter it.
 
<langsyntaxhighlight lang="qbasic">
ON ERROR GOTO ohNo
d$ = "docs"
Line 231 ⟶ 736:
END IF
RESUME NEXT
</syntaxhighlight>
</lang>
 
{{works with|QuickBasic|7.1}} {{works with|PowerBASIC for DOS}}
Line 237 ⟶ 742:
Later versions of MS-compatible BASICs include the <CODE>DIR$</CODE> keyword, which makes this pretty trivial.
 
<langsyntaxhighlight lang="qbasic">
f$ = "input.txt"
GOSUB opener
Line 259 ⟶ 764:
END IF
RETURN
</syntaxhighlight>
</lang>
 
==={{header|BaCon}}===
<syntaxhighlight lang="freebasic">' File exists
f$ = "input.txt"
d$ = "docs"
IF FILEEXISTS(f$) THEN PRINT f$, " exists"
IF FILEEXISTS(d$) AND FILETYPE(d$) = 2 THEN PRINT d$, " directory exists"
 
f$ = "/" & f$
d$ = "/" & d$
PRINT f$, IIF$(FILEEXISTS(f$), " exists", " does not exist")
PRINT d$, IIF$(FILEEXISTS(d$) AND FILETYPE(d$) = 2, " is", " is not"), " a directory"
 
f$ = "empty.bac"
PRINT f$, IIF$(FILEEXISTS(f$), " exists", " does not exist")
 
f$ = "`Abdu'l-Bahá.txt"
PRINT f$, IIF$(FILEEXISTS(f$), " exists", " does not exist")</syntaxhighlight>
 
{{out}}
<pre>prompt$ ./fileexits
/input.txt does not exist
/docs is not a directory
empty.bac exists
`Abdu'l-Bahá.txt does not exist</pre>
 
 
==={{header|Commodore BASIC}}===
Try a file, then check the error status of the disk drive. Error code 62 is the "File not found" error. The trick is to open the file without specifying the file type (PRG, SEQ, REL, etc.) and the Read/Write mode in the OPEN statement, otherwise you may end up with error code 64 "File Type Mismatch".
<syntaxhighlight lang="gwbasic">10 REM CHECK FILE EXISTS
15 ER=0:EM$="":MSG$="FILE EXISTS."
20 PRINT CHR$(147);:REM CLEAR SCREEN
30 FI$="":INPUT "ENTER FILENAME TO CHECK";FI$:PRINT
35 IF FI$="" THEN PRINT "ABORTED.":END
40 OPEN 8,8,8,FI$
50 GOSUB 1000:REM FETCH ERROR STATUS FROM DRIVE: 0=OK, 62=FILE NOT FOUND
55 REM COMPARE ERROR NUMBER
60 IF ER<>0 THEN MSG$="I/O ERROR:"+STR$(ER)+" "+EM$
70 IF ER=62 THEN MSG$="'"+FI$+"' IS NOT HERE."
80 REM DO THINGS WITH FILE...
100 CLOSE 8
110 PRINT MSG$
120 PRINT:GOTO 30:REM REPEAT UNTIL EMPTY FILENAME IS ENTERED
1000 REM CHECK ERROR CHANNEL FOR STATUS OF LAST DISK OPERATION
1010 OPEN 15,8,15
1015 REM GET ERROR CODE, ERROR MESSAGE, TRACK, SECTOR
1020 INPUT#15,ER,EM$,T,S
1030 CLOSE 15
1040 RETURN</syntaxhighlight>
 
{{Out}}<pre>ENTER FILENAME TO CHECK? INDEX.TXT
FILE EXISTS.
 
ENTER FILENAME TO CHECK? NOFILE.DOC
'NOFILE.DOC' IS NOT HERE.</pre>
 
==={{header|SmallBASIC}}===
<syntaxhighlight lang="qbasic">
if(isdir("docs")) then print "directory docs exist"
if(isdir("/docs")) then print "directory /docs exist"
if(isfile("input.txt")) then print "file input.txt exist"
if(isfile("/input.txt")) then print "file /input.txt exist"
</syntaxhighlight>
 
 
 
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">subroutine opener (filename$)
if exists(filename$) then
print filename$; " exists"
else
print filename$; " does not exists"
end if
end subroutine
 
call opener ("input.txt")
call opener ("\input.txt")
call opener ("docs\nul")
call opener ("\docs\nul")
call opener ("empty.kbs")
call opener ("`Abdu'l-Bahá.txt"))
end</syntaxhighlight>
=={{header|Batch File}}==
<langsyntaxhighlight lang="dos">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.</langsyntaxhighlight>
 
=={{header|BBC BASIC}}==
<langsyntaxhighlight lang="bbcbasic"> test% = OPENIN("input.txt")
IF test% THEN
CLOSE #test%
Line 290 ⟶ 876:
CLOSE #test%
PRINT "Directory \docs exists"
ENDIF</langsyntaxhighlight>
=={{header|BQN}}==
 
'''Works In:''' [[CBQN]]
 
Takes filename as a command line argument, tells whether it exists.
 
<syntaxhighlight lang="bqn">fname ← ⊑args
•Out fname∾" Does not exist"‿" Exists"⊑˜•File.exists fname</syntaxhighlight>
=={{header|C}}==
{{libheader|POSIX}}
<langsyntaxhighlight lang="c">#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
Line 321 ⟶ 914:
check_dir("/docs") ? "yes" : "no");
return 0;
}</langsyntaxhighlight>
 
{{libheader|Gadget}}
<syntaxhighlight lang="c">
#include <gadget/gadget.h>
 
LIB_GADGET_START
 
/* input.txt = check_file.c
docs = tests */
 
Main
Print "tests/check_file.c is a regular file? %s\n", Exist_file("tests/check_file.c") ? "yes" : "no";
Print "tests is a directory? %s\n", Exist_dir("tests") ? "yes" : "no";
Print "some.txt is a regular file? %s\n", Exist_file("some.txt") ? "yes" : "no";
Print "/tests is a directory? %s\n", Exist_dir("/tests") ? "yes" : "no";
End
</syntaxhighlight>
{{out}}
<pre>
tests/check_file.c is a regular file? yes
tests is a directory? yes
some.txt is a regular file? no
/tests is a directory? no
 
</pre>
 
=={{header|C sharp|C#}}==
 
<syntaxhighlight lang="csharp">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"));</syntaxhighlight>
=={{header|C++}}==
{{libheader|boost}}
<langsyntaxhighlight lang="cpp">#include "boost/filesystem.hpp"
#include <string>
#include <iostream>
Line 349 ⟶ 975:
testfile("/input.txt");
testfile("/docs");
}</langsyntaxhighlight>
 
=={{header|C=Using sharp|C#}}++ 17===
C++ 17 contains a Filesystem library which significantly improves operations with files.
<syntaxhighlight lang="c++">
 
#include <iostream>
<lang csharp>using System.IO;
#include <filesystem>
 
void file_exists(const std::filesystem::path& path) {
Console.WriteLine(File.Exists("input.txt"));
std::cout << path;
Console.WriteLine(File.Exists("/input.txt"));
if ( std::filesystem::exists(path) ) {
Console.WriteLine(Directory.Exists("docs"));
if ( std::filesystem::is_directory(path) ) {
Console.WriteLine(Directory.Exists("/docs"));</lang>
std::cout << " is a directory" << std::endl;
} else {
std::cout << " exists with a file size of " << std::filesystem::file_size(path) << " bytes." << std::endl;
}
} else {
std::cout << " does not exist" << std::endl;
}
}
 
int main() {
file_exists("input.txt");
file_exists("zero_length.txt");
file_exists("docs/input.txt");
file_exists("docs/zero_length.txt");
}
</syntaxhighlight>
{{ out }}
</pre>
"input.txt" exists with a file size of 11 bytes.
 
"zero_length.txt" exists with a file size of 0 bytes.
 
"docs/input.txt" exists with a file size of 11 bytes.
 
"docs/zero_length.txt" exists with a file size of 0 bytes.
</pre>
 
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">
 
(dorun (map #(.exists (clojure.java.io/as-file %)) '("/input.txt" "/docs" "./input.txt" "./docs")))
 
</syntaxhighlight>
=={{header|COBOL}}==
{{works with|GnuCOBOL}} and other compilers with this system call extension
<syntaxhighlight lang="cobol"> identification division.
program-id. check-file-exist.
 
environment division.
configuration section.
repository.
function all intrinsic.
 
data division.
working-storage section.
01 skip pic 9 value 2.
01 file-name.
05 value "/output.txt".
01 dir-name.
05 value "/docs/".
01 unusual-name.
05 value "Abdu'l-Bahá.txt".
 
01 test-name pic x(256).
 
01 file-handle usage binary-long.
01 file-info.
05 file-size pic x(8) comp-x.
05 file-date.
10 file-day pic x comp-x.
10 file-month pic x comp-x.
10 file-year pic xx comp-x.
05 file-time.
10 file-hours pic x comp-x.
10 file-minutes pic x comp-x.
10 file-seconds pic x comp-x.
10 file-hundredths pic x comp-x.
 
procedure division.
files-main.
 
*> check in current working dir
move file-name(skip:) to test-name
perform check-file
 
move dir-name(skip:) to test-name
perform check-file
 
move unusual-name to test-name
perform check-file
 
*> check in root dir
move 1 to skip
move file-name(skip:) to test-name
perform check-file
 
move dir-name(skip:) to test-name
perform check-file
 
goback.
 
check-file.
call "CBL_CHECK_FILE_EXIST" using test-name file-info
if return-code equal zero then
display test-name(1:32) ": size " file-size ", "
file-year "-" file-month "-" file-day space
file-hours ":" file-minutes ":" file-seconds "."
file-hundredths
else
display "error: CBL_CHECK_FILE_EXIST " return-code space
trim(test-name)
end-if
.
 
end program check-file-exist.
</syntaxhighlight>
{{out}}
<pre>
prompt$ cobc -xj check-file-exists.cob
output.txt : size 000000000000000000, 2016-06-01 09:27:14.00
docs/ : size 000000000000004096, 2016-06-01 09:27:14.00
error: CBL_CHECK_FILE_EXIST +000000035 Abdu'l-Bahá.txt
error: CBL_CHECK_FILE_EXIST +000000035 /output.txt
error: CBL_CHECK_FILE_EXIST +000000035 /docs/
prompt$ echo -n >Abdu\'l-Bahá.txt
prompt$ cobc -xj check-file-exists.cob
output.txt : size 000000000000000000, 2016-06-01 09:27:14.00
docs/ : size 000000000000004096, 2016-06-01 09:27:14.00
Abdu'l-Bahá.txt : size 000000000000000000, 2016-06-01 09:33:35.00
error: CBL_CHECK_FILE_EXIST +000000035 /output.txt
error: CBL_CHECK_FILE_EXIST +000000035 /docs/</pre>
Errors due to file and dir not existing in root directory for this test pass
=={{header|CoffeeScript}}==
{{works with|Node.js}}
<langsyntaxhighlight lang="coffeescript">
fs = require 'fs'
path = require 'path'
Line 385 ⟶ 1,135:
 
</syntaxhighlight>
</lang>
 
=={{header|Clojure}}==
<lang clojure>
 
(map #(.exists (clojure.java.io/as-file %)) '("/input.txt" "/docs" "./input.txt" "./docs"))
 
</lang>
 
=={{header|Common Lisp}}==
 
''probe-file'' returns ''nil'' if a file does not exist. ''directory'' returns ''nil'' if there are no files in a specified directory.
<langsyntaxhighlight lang="lisp">(if (probe-file (make-pathname :name "input.txt"))
(print "rel file exists"))
(if (probe-file (make-pathname :directory '(:absolute "") :name "input.txt"))
Line 407 ⟶ 1,149:
(if (directory (make-pathname :directory '(:absolute "docs")))
(print "abs directory exists")
(print "abs directory is not known to exist"))</langsyntaxhighlight>
 
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. [http://www.weitz.de/cl-fad/ CL-FAD] provides many of the therefore-missing capabilities in a cross-implementation library.
 
{{libheader|CL-FAD}}
<langsyntaxhighlight lang="lisp">(if (cl-fad:directory-exists-p (make-pathname :directory '(:relative "docs")))
(print "rel directory exists")
(print "rel directory does not exist"))</langsyntaxhighlight>
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">def check_file(filename : String)
if File.directory?(filename)
puts "#{filename} is a directory"
elsif File.exists?(filename)
puts "#{filename} is a file"
else
puts "#{filename} does not exist"
end
end
 
check_file("input.txt")
check_file("docs")
check_file("/input.txt")
check_file("/docs")</syntaxhighlight>
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.file, std.path;
 
void verify(in string name) {
Line 434 ⟶ 1,190:
verify(dirSeparator ~ "input.txt");
verify(dirSeparator ~ "docs");
}</langsyntaxhighlight>
{{out}}
<pre>'input.txt' doesn't exist
Line 440 ⟶ 1,196:
'\input.txt' doesn't exist
'\docs' doesn't exist</pre>
=={{header|DBL}}==
<syntaxhighlight lang="dbl">;
; Check file and directory exists for DBL version 4 by Dario B.
;
PROC
;------------------------------------------------------------------
XCALL FLAGS (0007000000,1) ;Suppress STOP message
 
CLOSE 1
OPEN (1,O,'TT:')
 
;The file path can be written as:
; "input.txt" (current directory)
; "/directory/input.txt" (complete path)
; "DEV:input.txt" (device DEV defined in shell)
; "$DEV/input.txt" (device DEV defined in shell)
CLOSE 2
OPEN (2,I,"input.txt") [ERR=NOFIL]
CLOSE 2
 
;Check directory (unix/linux systems)
CLOSE 2
OPEN (2,O,"/docs/.") [ERR=NODIR]
 
GOTO CLOS
 
;--------------------------------------------------------
NOFIL, DISPLAY (1,"File input.txt not found!",10)
GOTO CLOS
 
NODIR, DISPLAY (1,"Directory /docs not found!",10)
GOTO CLOS
 
CLOS, CLOSE 1
CLOSE 2
STOP</syntaxhighlight>
=={{header|DCL}}==
<langsyntaxhighlight DCLlang="dcl">$ if f$search( "input.txt" ) .eqs. ""
$ then
$ write sys$output "input.txt not found"
Line 464 ⟶ 1,256:
$ else
$ write sys$output "directory [000000]docs found"
$ endif</langsyntaxhighlight>
{{out}}
<pre>
Line 472 ⟶ 1,264:
[000000]input.txt not found
directory [000000]docs not found</pre>
 
=={{header|Delphi}}==
<langsyntaxhighlight Delphilang="delphi">program EnsureFileExists;
 
{$APPTYPE CONSOLE}
Line 501 ⟶ 1,292:
else
Writeln('Directory "\docs" does not exists.');
end.</langsyntaxhighlight>
 
=={{header|E}}==
<langsyntaxhighlight lang="e">for file in [<file:input.txt>,
<file:///input.txt>] {
require(file.exists(), fn { `$file is missing!` })
Line 514 ⟶ 1,304:
require(file.exists(), fn { `$file is missing!` })
require(file.isDirectory(), fn { `$file is not a directory!` })
}</langsyntaxhighlight>
 
=={{header|Elena}}==
ELENA 4.x :
<lang elena>#import system.
#<syntaxhighlight lang="elena">import system'io.;
#import extensions.;
 
extension op
#symbol program =
{
[
validatePath()
console writeLine:"input.txt file ":("input.txt" file_path is &available iif:"exists":"not found").
= self.Available.iif("exists","not found");
 
}
console writeLine:"\input.txt file ":("\input.txt" file_path is &available iif:"exists":"not found").
 
public program()
console writeLine:"docs directory ":("docs" directory_path is &available iif:"exists":"not found").
{
 
console.printLine("input.txt file ",File.assign("input.txt").validatePath());
console writeLine:"\docs directory ":("\docs" directory_path is &available iif:"exists":"not found").
].</lang>
console.printLine("\input.txt file ",File.assign("\input.txt").validatePath());
 
console.printLine("docs directory ",Directory.assign("docs").validatePath());
console.printLine("\docs directory ",Directory.assign("\docs").validatePath())
}</syntaxhighlight>
=={{header|Elixir}}==
<langsyntaxhighlight Elixirlang="elixir">File.regular?("input.txt")
File.dir?("docs")
File.regular?("/input.txt")
File.dir?("/docs")</langsyntaxhighlight>
 
=={{header|Emacs Lisp}}==
<langsyntaxhighlight Lisplang="lisp">(file-exists-p "input.txt")
(file-directory-p "docs")
(file-exists-p "/input.txt")
(file-directory-p "/docs")</langsyntaxhighlight>
 
<code>file-exists-p</code> is true on both files and directories. <code>file-directory-p</code> is true only on directories. Both go through the <code>file-name-handler-alist</code> "magic filenames" mechanism so can act on remote files. On MS-DOS generally both <code>/</code> and <code>\</code> work to specify the root directory.
 
=={{header|Erlang}}==
<langsyntaxhighlight lang="erlang">#!/usr/bin/escript
existence( true ) ->"exists";
existence( false ) ->"does not exist".
Line 559 ⟶ 1,351:
print_result( "File", "/input.txt", filelib:is_regular("/input.txt") ),
print_result( "Directory", "/docs", filelib:is_dir("/docs") ).
</syntaxhighlight>
</lang>
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang="euphoria">include file.e
 
procedure ensure_exists(sequence name)
Line 583 ⟶ 1,374:
ensure_exists("docs")
ensure_exists("/input.txt")
ensure_exists("/docs")</langsyntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">open System.IO
File.Exists("input.txt")
Directory.Exists("docs")
File.Exists("/input.txt")
Directory.Exists(@"\docs")</langsyntaxhighlight>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">: print-exists? ( path -- )
[ write ": " write ] [ exists? "exists." "doesn't exist." ? print ] bi ;
 
{ "input.txt" "/input.txt" "docs" "/docs" } [ print-exists? ] each</langsyntaxhighlight>
=={{header|Forth}}==
 
<syntaxhighlight lang="forth">: .exists ( str len -- )
=={{header|Forth}}==
2dup file-status nip 0= if
." exists: "
else
." does not exist: "
then
type
;
 
s" input.txt" .exists cr
<lang forth>: .exists ( str len -- ) 2dup file-status nip 0= if type ." exists" else type ." does not exist" then ;
s" /input.txt" .exists cr
s" /input.txtdocs" .exists cr
s" /docs" .exists cr
</syntaxhighlight>
s" /docs" .exists</lang>
 
=={{header|Fortran}}==
Line 610 ⟶ 1,407:
 
Cannot check for directories in Fortran
<langsyntaxhighlight lang="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)</langsyntaxhighlight>
 
Actually, f90,f95 are able to deal with directory staff:
 
<langsyntaxhighlight lang="fortran">logical :: dir_e
! a trick to be sure docs is a dir
inquire( file="./docs/.", exist=dir_e )
Line 625 ⟶ 1,422:
! workaround: it calls an extern program...
call system('mkdir docs')
end if</langsyntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
' Enable FileExists() function to be used
#include "file.bi"
 
' Use Win32 function to check if directory exists on Windows 10
Declare Function GetFileAttributes Lib "kernel32.dll" Alias "GetFileAttributesA" _
(ByVal lpFileName As ZString Ptr) As ULong
 
Const InvalidFileAttributes As ULong = -1UL
Const FileAttributeDirectory As ULong = &H10UL
 
Sub CheckFileExists(ByRef filePath As String)
If FileExists(filePath) Then
Print "'"; filePath; "' exists"
Else
Print "'"; filePath; "' does not exist"
End If
End Sub
 
Sub CheckDirectoryExists(ByVal dirPath As ZString Ptr)
Dim attrib As ULong = GetFileAttributes(dirPath)
Dim dirExists As ULong = attrib <> InvalidFileAttributes AndAlso (attrib And FileAttributeDirectory) <> 0
If dirExists Then
Print "'"; *dirPath; "' exists"
Else
Print "'"; *dirPath; "' does not exist"
End If
End Sub
 
CheckFileExists(CurDir + "\input.txt")
Dim dirPath As String = CurDir + "\docs"
CheckDirectoryExists(StrPtr(dirPath))
CheckFileExists("c:\input.txt")
CheckDirectoryExists(StrPtr("c:\docs"))
Print
Print "Press any key to quit the program"
Sleep</syntaxhighlight>
 
{{out}}
All files and directories were created first. The files are empty:
<pre>
'c:\FreeBasic\input.txt' exists
'c:\FreeBasic\docs' exists
'c:\input.txt' exists
'c:\docs' exists
</pre>
 
 
 
=={{header|Frink}}==
This checks that the file exists and is a file, and that the directory exists, and is a directory. (Many of the samples on this page do not check that the files are actually a file or the directories are actually a directory.) It also tries to find various Unicode encodings of the "unusual" filename that may be encoded in different Unicode compositions (e.g. using "precomposed" or "decomposed" representations for some characters.
 
<syntaxhighlight lang="frink">
checkFile[filename] :=
{
file = newJava["java.io.File", [filename]]
if file.exists[] and file.isFile[]
println["$filename is a file"]
else
println["$filename is not a file"]
}
 
checkDir[filename] :=
{
file = newJava["java.io.File", [filename]]
if file.exists[] and file.isDirectory[]
println["$filename is a directory"]
else
println["$filename is not a directory"]
}
 
checkFile["input.txt"]
checkFile["/input.txt"]
checkDir["docs"]
checkDir["/docs"]
 
// This tests the "unusual" filename with various Unicode
// normalizations that would look identical to a human
// For example, the á character could be written as either
// the Unicode sequences
// \u00e1 ('LATIN SMALL LETTER A WITH ACUTE')
// or
// \u0061\u0301 ('LATIN SMALL LETTER A' 'COMBINING ACUTE ACCENT')
unusual = "`Abdu'l-Bahá.txt"
checkFile[unusual]
checkFile[normalizeUnicode[unusual, "NFC"]]
checkFile[normalizeUnicode[unusual, "NFD"]]
</syntaxhighlight>
 
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
 
CFURLRef url
url = fn URLFileURLWithPath( fn StringByExpandingTildeInPath(@"~/Desktop/input.txt") )
if (fn FileManagerFileExistsAtURL( url ) )
NSLog( @"File \"input.txt\" exists." )
else
NSLog( @"File \"input.txt\" does not exist at this location." )
end if
 
url = fn URLFileURLWithPath( fn StringByExpandingTildeInPath(@"~/Desktop/docs") )
if (fn FileManagerIsDirectoryAtURL( url ) )
NSLog( @"Directory \"docs\" exists." )
else
NSLog( @"Directory \"docs\" does not exist at this location." )
end if
 
HandleEvents
</syntaxhighlight>
 
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=fa06b7cc43166fb0ab48e878d86e3d1b Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
 
If Exist(User.Home &/ "input.txt") Then Print "'input.txt' does exist in the Home folder"
If Not Exist("/input.txt") Then Print "'input.txt' does NOT exist in Root" 'Not messing With my Root files
 
If Exist(User.home &/ "docs/") Then Print "The folder '~/docs' does exist"
If Not Exist("/docs/") Then Print "The folder '/docs' does NOT exist" 'Not messing With my Root files
 
File.Save(User.Home &/ "`Abdu'l-Bahá.txt", "")
If Exist(User.Home &/ "`Abdu'l-Bahá.txt") Then Print "'`Abdu'l-Bahá.txt' does exist (zero length and unusual name)"
 
End</syntaxhighlight>
Output:
<pre>
'input.txt' does exist in the Home folder
'input.txt' does NOT exist in Root
The folder '~/docs' does exist
The folder '/docs' does NOT exist
'`Abdu'l-Bahá.txt' does exist (zero length and unusual name)
</pre>
 
 
 
=={{header|GAP}}==
<langsyntaxhighlight lang="gap">IsExistingFile("input.txt");
IsDirectoryPath("docs");
IsExistingFile("/input.txt");
IsDirectoryPath("/docs");</langsyntaxhighlight>
=={{header|Genie}}==
<syntaxhighlight lang="genie">[indent=4]
/*
Check file exists, in Genie
valac --pkg=gio-2.0 checkFile.gs
*/
 
init
Intl.setlocale()
 
files:array of string[] = {"input.txt", "docs",
Path.DIR_SEPARATOR_S + "input.txt", Path.DIR_SEPARATOR_S + "docs", "`Abdu'l-Bahá.txt"}
for f:string in files
var file = File.new_for_path(f)
var exists = file.query_exists()
var dir = false
if exists
dir = file.query_file_type(0) == FileType.DIRECTORY
print("%s %sexist%s%s", f, exists ? "" : "does not ", exists ? "s" : "", dir ? " and is a directory" : "")</syntaxhighlight>
 
{{out}}
<pre>prompt$ valac --pkg=gio-2.0 checkFile.gs
prompt$ ./checkFile
input.txt exists
docs exists and is a directory
/input.txt does not exist
/docs does not exist
`Abdu'l-Bahá.txt does not exist</pre>
 
For the run, ''input.txt'' was zero length.
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 655 ⟶ 1,621:
printStat("docs")
printStat("/docs")
}</langsyntaxhighlight>
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">println new File('input.txt').exists()
println new File('/input.txt').exists()
println new File('docs').exists()
println new File('/docs').exists()</langsyntaxhighlight>
 
=={{header|Haskell}}==
 
<langsyntaxhighlight lang="haskell">import System.IODirectory (doesFileExist, doesDirectoryExist)
import System.Directory
 
check :: (FilePath -> IO Bool) -> FilePath -> IO ()
check p s = do
result <- p s
putStrLn $
putStrLn $ s ++ if result then " does exist" else " does not exist"
s ++
if result
then " does exist"
else " does not exist"
 
main :: IO ()
main = do
check doesFileExist "input.txt"
check doesDirectoryExist "docs"
check doesFileExist "/input.txt"
check doesDirectoryExist "/docs"</langsyntaxhighlight>
=={{header|hexiscript}}==
 
<syntaxhighlight lang="hexiscript">println "File \"input.txt\"? " + (exists "input.txt")
println "Dir \"docs\"? " + (exists "docs/")
println "File \"/input.txt\"? " + (exists "/input.txt")
println "Dir \"/docs\"? " + (exists "/docs/")</syntaxhighlight>
=={{header|HicEst}}==
<langsyntaxhighlight lang="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 </langsyntaxhighlight>
=={{header|HolyC}}==
<syntaxhighlight lang="holyc">U0 FileExists(U8 *f) {
if (FileFind(f) && !IsDir(f)) {
Print("'%s' file exists.\n", f);
} else {
Print("'%s' file does not exist.\n", f);
}
}
 
U0 DirExists(U8 *d) {
if (IsDir(d)) {
Print("'%s' directory exists.\n", d);
} else {
Print("'%s' directory does not exist.\n", d);
}
}
 
FileExists("input.txt");
FileExists("::/input.txt");
DirExists("docs");
DirExists("::/docs");</syntaxhighlight>
=={{header|i}}==
<syntaxhighlight lang="i">concept exists(path) {
open(path)
errors {
if error.DoesNotExist()
print(path, " does not exist!")
end
return
}
print(path, " exists!")
}
 
software {
exists("input.txt")
exists("/input.txt")
exists("docs")
exists("/docs")
exists("docs/Abdu'l-Bahá.txt")
}</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
Icon doesn't support 'stat'; however, information can be obtained by use of the system function to access command line.
<langsyntaxhighlight Uniconlang="unicon">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.")
}</langsyntaxhighlight>
Note: Icon and Unicon accept both / and \ for directory separators.
 
=={{header|IDL}}==
<langsyntaxhighlight lang="idl">
print, FILE_TEST('input.txt')
print, FILE_TEST(PATH_SEP()+'input.txt')
Line 700 ⟶ 1,710:
print, FILE_TEST(PATH_SEP()+'docs', /DIRECTORY)
 
</syntaxhighlight>
</lang>
 
=={{header|J}}==
<langsyntaxhighlight lang="j">require 'files'
fexist 'input.txt'
fexist '/input.txt'
direxist=: 2 = ftype
direxist 'docs'
direxist '/docs'</langsyntaxhighlight>
 
=={{header|Java}}==
This can be done with a <code>File</code> object.<br />
<lang java>import java.io.File;
<syntaxhighlight lang="java">
new File("docs/input.txt").exists();
new File("/docs/input.txt").exists();
</syntaxhighlight>
Zero-length files are not a problem, and return as existent.<br />
Java supports UTF-16, so the unusual file name is not a problem.
<syntaxhighlight lang="java">
new File("`Abdu'l-Bahá.txt").exists()
</syntaxhighlight>
<syntaxhighlight lang="java">
new File("`Abdu'l-Bah\u00E1.txt").exists();
</syntaxhighlight>
<br />
Alternately
<syntaxhighlight lang="java">import java.io.File;
public class FileExistsTest {
public static boolean isFileExists(String filename) {
Line 728 ⟶ 1,751:
test("directory", File.separator + "docs" + File.separator);
}
}</langsyntaxhighlight>
{{works with|Java|7+}}
<langsyntaxhighlight lang="java5">import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
Line 749 ⟶ 1,772:
test("directory", defaultFS.getSeparator() + "docs" + defaultFS.getSeparator());
}
}</langsyntaxhighlight>
Non retarded version:
<lang java5>
import java.nio.file.Files;
public class FileExistsTest{
public static void main(String args[]){
System.out.printf("input.txt - %s", new File("input.txt").exists());
}
</lang>
 
=={{header|JavaScript}}==
Javascript interpreters are now widely embedded in contexts which do have access to file systems, but the early context of browser scripting has precluded the inclusion of file system libraries in the definition of the language itself.
{{works with|JScript}}
Each non-browser JS context is likely to have its own home-grown and unstandardised file system library.
<lang javascript>var fso = new ActiveXObject("Scripting.FileSystemObject");
===JScript===
<syntaxhighlight lang="javascript">var fso = new ActiveXObject("Scripting.FileSystemObject");
 
fso.FileExists('input.txt');
fso.FileExists('c:/input.txt');
fso.FolderExists('docs');
fso.FolderExists('c:/docs');</langsyntaxhighlight>
 
===macOS JavaScript for Automation===
====ES6: Sierra onwards====
{{Trans|Haskell}}
(Adopting function names used in the Haskell System.Directory library)
<syntaxhighlight lang="javascript">(() => {
 
// SYSTEM DIRECTORY FUNCTIONS
// FOR MAC OS 'JAVASCRIPT FOR AUTOMATION' SCRIPTING -----------------------
 
// doesDirectoryExist :: String -> IO Bool
const doesDirectoryExist = strPath => {
const
dm = $.NSFileManager.defaultManager,
ref = Ref();
return dm
.fileExistsAtPathIsDirectory(
$(strPath)
.stringByStandardizingPath, ref
) && ref[0] === 1;
};
 
// doesFileExist :: String -> Bool
const doesFileExist = strPath => {
var error = $();
return (
$.NSFileManager.defaultManager
.attributesOfItemAtPathError(
$(strPath)
.stringByStandardizingPath,
error
),
error.code === undefined
);
};
 
// getCurrentDirectory :: String
const getCurrentDirectory = () =>
ObjC.unwrap($.NSFileManager.defaultManager.currentDirectoryPath);
 
// getFinderDirectory :: String
const getFinderDirectory = () =>
Application('Finder')
.insertionLocation()
.url()
.slice(7);
 
// getHomeDirectory :: String
const getHomeDirectory = () =>
ObjC.unwrap($.NSHomeDirectory());
 
// setCurrentDirectory :: String -> IO ()
const setCurrentDirectory = strPath =>
$.NSFileManager.defaultManager
.changeCurrentDirectoryPath(
$(strPath)
.stringByStandardizingPath
);
 
// GENERIC FUNCTIONS FOR THE TEST -----------------------------------------
 
// A list of functions applied to a list of arguments
// <*> :: [(a -> b)] -> [a] -> [b]
const ap = (fs, xs) => //
[].concat.apply([], fs.map(f => //
[].concat.apply([], xs.map(x => [f(x)]))));
 
// show :: a -> String
const show = x => JSON.stringify(x, null, 2);
 
// TEST -------------------------------------------------------------------
return (
setCurrentDirectory('~/Desktop'),
show(ap(
[doesFileExist, doesDirectoryExist],
['input.txt', '/input.txt', 'docs', '/docs']
))
);
})();</syntaxhighlight>
{{Out}}
The first four booleans are returned by doesFileExist – the last four by
doesDirectoryExist, which returns false in the case of files which do
exist but are not directories.
<pre>[
true,
true,
true,
true,
false,
false,
true,
true
]</pre>
=={{header|Julia}}==
{{works with|Julia|0.6}}
<lang julia>isfile("input.txt")
isfile("/input.txt")
isdir("docs")
isdir("/docs")</lang>
 
<syntaxhighlight lang="julia">@show isfile("input.txt")
@show isfile("/input.txt")
@show isdir("docs")
@show isdir("/docs")
@show isfile("")
@show isfile("`Abdu'l-Bahá.txt")</syntaxhighlight>
=={{header|Klingphix}}==
<syntaxhighlight lang="klingphix">include ..\Utilitys.tlhy
 
"foo.bar" "w" fopen
"Hallo !" over fputs
fclose
"fou.bar" "r" fopen
dup 0 < ( ["Could not open 'fou.bar' for reading" print drop] [fclose] ) if
 
" " input</syntaxhighlight>
{{out}}
<pre>Could not open 'fou.bar' for reading</pre>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6
 
import java.io.File
 
fun main(args: Array<String>) {
val filePaths = arrayOf("input.txt", "c:\\input.txt", "zero_length.txt", "`Abdu'l-Bahá.txt")
val dirPaths = arrayOf("docs", "c:\\docs")
for (filePath in filePaths) {
val f = File(filePath)
println("$filePath ${if (f.exists() && !f.isDirectory) "exists" else "does not exist"}")
}
for (dirPath in dirPaths) {
val d = File(dirPath)
println("$dirPath ${if (d.exists() && d.isDirectory) "exists" else "does not exist"}")
}
}</syntaxhighlight>
=={{header|LabVIEW}}==
{{libheader|LabVIEW CWD}}
Line 779 ⟶ 1,921:
[[File:Ensure_that_a_file_exists.png]]
 
 
=={{header|Lang}}==
{{libheader|lang-io-module}}
<syntaxhighlight lang="lang">
# Load the IO module
# Replace "<pathToIO.lm>" with the location where the io.lm Lang module was installed to without "<" and ">"
ln.loadModule(<pathToIO.lm>)
 
$file1 = [[io]]::fp.openFile(input.txt)
[[io]]::fp.existsFile($file1)
[[io]]::fp.closeFile($file1)
 
$file2 = [[io]]::fp.openFile(/input.txt)
[[io]]::fp.existsFile($file2)
[[io]]::fp.closeFile($file2)
 
$dir1 = [[io]]::fp.openFile(docs)
[[io]]::fp.existsFile($dir1)
[[io]]::fp.closeFile($dir1)
 
$dir2 = [[io]]::fp.openFile(/docs)
[[io]]::fp.existsFile($dir2)
[[io]]::fp.closeFile($dir2)
</syntaxhighlight>
 
=={{header|langur}}==
The prop() function returns a hash of file/directory properties.
<syntaxhighlight lang="langur">val .printresult = impure fn(.file) {
write .file, ": "
if val .p = prop(.file) {
if .p'isdir {
writeln "is directory"
} else {
writeln "is file"
}
} else {
writeln "nothing"
}
}
 
.printresult("input.txt")
.printresult("/input.txt")
.printresult("docs")
.printresult("/docs")
</syntaxhighlight>
 
=={{header|Lasso}}==
<langsyntaxhighlight Lassolang="lasso">// local file
file_exists('input.txt')
 
Line 791 ⟶ 1,978:
 
// directory in root file system (requires permissions at user OS level)
file_exists('//docs')</langsyntaxhighlight>
 
=={{header|LFE}}==
From the LFE REPL:
<langsyntaxhighlight lang="lisp">
> (: filelib is_regular '"input.txt")
false
Line 804 ⟶ 1,990:
> (: filelib is_dir '"/docs"))
false
</syntaxhighlight>
</lang>
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang="lb">'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$
Line 835 ⟶ 2,020:
pathLength = len(pathOnly$(fullPath$))
filenameOnly$ = right$(fullPath$, len(fullPath$)-pathLength)
end function</langsyntaxhighlight>
=={{header|Little}}==
 
<syntaxhighlight lang="c">if (exists("input.txt")) {
puts("The file \"input.txt\" exist");
}
if (exists("/input.txt")) {
puts("The file \"/input.txt\" exist");
}
if (exists("docs")) {
puts("The file \"docs\" exist");
}
if (exists("/docs")) {
puts("The file \"/docs\" exist");
}</syntaxhighlight>
=={{header|LiveCode}}==
<langsyntaxhighlight LiveCodelang="livecode">there is a file "/input.txt"
there is a file "input.txt"
there is a folder "docs"
there is a file "/docs/input.txt"</langsyntaxhighlight>
LiveCode also allows setting a default folder for subsequent file commands. To check if a file exists in the doc folder
<langsyntaxhighlight LiveCodelang="livecode">set the defaultFolder to "docs"
there is a file "input.txt"</langsyntaxhighlight>
 
=={{header|Logo}}==
{{works with|UCB Logo}}
<langsyntaxhighlight lang="logo">show file? "input.txt
show file? "/input.txt
show file? "docs
show file? "/docs</langsyntaxhighlight>
Alternatively, one can set a file prefix used for subsequent file commands.
<langsyntaxhighlight lang="logo">setprefix "/
show file? "input.txt</langsyntaxhighlight>
 
=={{header|Lua}}==
For directories, the following only works on platforms on which directories can be opened for reading like files.
<langsyntaxhighlight lang="lua">function output( s, b )
if b then
print ( s, " does not exist." )
Line 869 ⟶ 2,064:
output( "/input.txt", io.open( "/input.txt", "r" ) == nil )
output( "docs", io.open( "docs", "r" ) == nil )
output( "/docs", io.open( "/docs", "r" ) == nil )</langsyntaxhighlight>
 
The following more portable solution uses LuaFileSystem.
<langsyntaxhighlight lang="lua">require "lfs"
for i, path in ipairs({"input.txt", "/input.txt", "docs", "/docs"}) do
local mode = lfs.attributes(path, "mode")
Line 880 ⟶ 2,075:
print(path .. " does not exist.")
end
end</langsyntaxhighlight>
=={{header|M2000 Interpreter}}==
 
Report print proportional text using word wrap, and justification. Can be used to calculate lines, and to render form a line, a number of lines. We can specify the width of the text, and by moving the cursor horizontal we can specify the left margin. This statement can be used to any layer, including user forms and printer page.
 
<syntaxhighlight lang="m2000 interpreter">
Module ExistDirAndFile {
Let WorkingDir$=Dir$, RootDir$="C:\"
task(WorkingDir$)
task(RootDir$)
Dir User ' return to user directroy
Sub task(WorkingDir$)
Local counter
Dir WorkingDir$
If Not Exist.Dir("docs") then Report "docs not exist in "+WorkingDir$ : counter++
If Not Exist("output.txt") Then {
Report "output.txt not exist in "+ WorkingDir$ : counter++
} Else.if Filelen("output.txt")=0 Then Report "output.txt has zero length"
If counter =0 then Report WorkingDir$+ " has docs directory and file output.txt"
End Sub
}
ExistDirAndFile
</syntaxhighlight>
=={{header|Maple}}==
<langsyntaxhighlight Maplelang="maple">with(FileTools):
Exists("input.txt");
Exists("docs") and IsDirectory("docs");
Exists("/input.txt");
Exists("/docs") and IsDirectory("/docs");</langsyntaxhighlight>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">wd = NotebookDirectory[];
FileExistsQ[wd <> "input.txt"]
DirectoryQ[wd <> "docs"]
 
FileExistsQ["/" <> "input.txt"]
DirectoryQ["/" <> "docs"]</langsyntaxhighlight>
 
=={{header|MATLAB}} / {{header|Octave}}==
<langsyntaxhighlight Matlablang="matlab"> exist('input.txt','file')
exist('/input.txt','file')
exist('docs','dir')
exist('/docs','dir')</langsyntaxhighlight>
 
=={{header|MAXScript}}==
<langsyntaxhighlight lang="maxscript">-- Here
doesFileExist "input.txt"
(getDirectories "docs").count == 1
-- Root
doesFileExist "\input.txt"
(getDirectories "C:\docs").count == 1</langsyntaxhighlight>
 
=={{header|Modula-3}}==
<langsyntaxhighlight lang="modula3">MODULE FileTest EXPORTS Main;
 
IMPORT IO, Fmt, FS, File, OSError, Pathname;
Line 933 ⟶ 2,145:
IO.Put(Fmt.Bool(FileExists("docs/")) & "\n");
IO.Put(Fmt.Bool(FileExists("/docs")) & "\n");
END FileTest.</langsyntaxhighlight>
=={{header|Nanoquery}}==
<syntaxhighlight lang="nanoquery">import Nanoquery.IO
 
def exists(fname)
f = new(File, fname)
 
return f.exists()
end</syntaxhighlight>
=={{header|Neko}}==
<syntaxhighlight lang="actionscript">/**
Check that file/dir exists, in Neko
*/
 
var sys_exists = $loader.loadprim("std@sys_exists", 1)
var sys_file_type = $loader.loadprim("std@sys_file_type", 1)
var sys_command = $loader.loadprim("std@sys_command", 1)
 
var name = "input.txt"
$print(name, " exists as file: ", sys_exists(name), "\n")
 
$print(name = "docs", " exists as dir: ", sys_exists(name) && sys_file_type(name) == "dir", "\n")
$print(name = "neko", " exists as dir: ", sys_exists(name) && sys_file_type(name) == "dir", "\n")
 
$print(name = "/input.txt", " exists as file: ", sys_exists(name) && sys_file_type(name) == "file", "\n")
$print(name = "/docs", " exists as dir: ", sys_exists(name) && sys_file_type(name) == "dir", "\n")
$print(name = "/tmp", " exists as dir: ", sys_exists(name) && sys_file_type(name) == "dir", "\n")
 
/* bonus round */
name = "empty.txt"
var stat_size = $loader.loadprim("std@sys_stat", 1)(name).size
$print(name, " exists as empty file: ", sys_exists(name) && stat_size == 0, "\n")
 
name = "`Abdu'l-Bahá.txt"
$print(name, " exists as file: ", sys_exists(name) && sys_file_type(name) == "file", "\n")</syntaxhighlight>
 
{{out}}
<pre>prompt$ nekoc exists.neko
prompt$ neko exists.n
input.txt exists as file: true
docs exists as dir: false
neko exists as dir: true
/input.txt exists as file: false
/docs exists as dir: false
/tmp exists as dir: true
empty.txt exists as empty file: true
`Abdu'l-Bahá.txt exists as file: true</pre>
=={{header|Nemerle}}==
{{trans|C#}}
<langsyntaxhighlight Nemerlelang="nemerle">using System.Console;
using System.IO;
Line 943 ⟶ 2,200:
WriteLine(File.Exists("/input.txt"));
WriteLine(Directory.Exists("docs"));
WriteLine(Directory.Exists("/docs"));</langsyntaxhighlight>
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols binary
 
Line 990 ⟶ 2,246:
 
return
</syntaxhighlight>
</lang>
 
=={{header|NewLISP}}==
<langsyntaxhighlight NewLISPlang="newlisp">(dolist (file '("input.txt" "/input.txt"))
(if (file? file true)
(println "file " file " exists")))
Line 999 ⟶ 2,254:
(dolist (dir '("docs" "/docs"))
(if (directory? dir)
(println "directory " dir " exists")))</langsyntaxhighlight>
 
=={{header|Nim}}==
<langsyntaxhighlight lang="nim">import os
 
echo existsFile "input.txt"
echo existsFile "/input.txt"
echo existsDir "docs"
echo existsDir "/docs"</lang>
 
=={{header|Objective-C}}==
<lang objc>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");</lang>
 
echo fileExists "input.txt"
echo fileExists "/input.txt"
echo dirExists "docs"
echo dirExists "/docs"</syntaxhighlight>
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">
use IO;
 
Line 1,027 ⟶ 2,275:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Objective-C}}==
<syntaxhighlight lang="objc">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");</syntaxhighlight>
 
=={{header|Odin}}==
 
<syntaxhighlight lang="odin">package main
 
import "core:os"
 
main :: proc() {
os.exists("input.txt")
os.exists("/input.txt")
os.exists("docs")
os.exists("/docs")
}</syntaxhighlight>
 
=={{header|OCaml}}==
<langsyntaxhighlight lang="ocaml">Sys.file_exists "input.txt";;
Sys.file_exists "docs";;
Sys.file_exists "/input.txt";;
Sys.file_exists "/docs";;</langsyntaxhighlight>
 
=={{header|ooRexx}}==
<langsyntaxhighlight lang="oorexx">/**********************************************************************
* exists(filespec)
* returns 1 if filespec identifies a file with size>0
Line 1,055 ⟶ 2,320:
End
If size=0 Then Say spec 'is a zero-size file'
Return 0</langsyntaxhighlight>
 
=={{header|Oz}}==
<langsyntaxhighlight lang="oz">declare
[Path] = {Module.link ['x-oz://system/os/Path.ozf']}
in
Line 1,064 ⟶ 2,328:
{Show {Path.exists "input.txt"}}
{Show {Path.exists "/docs"}}
{Show {Path.exists "/input.txt"}}</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">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")</langsyntaxhighlight>
 
A better version would use <code>externstr</code>.
 
Under PARI it would typically be more convenient to use [[#C|C]] methods.
 
=={{header|Pascal}}==
See [[Ensure_that_a_file_exists#Delphi | Delphi]]
 
=={{header|Phix}}==
<lang Phix>constant fd = {"file","directory"}
 
procedure check(string name)
object d = dir(name)
if sequence(d) then
d = (find('d',d[1][D_ATTRIBUTES])!=0)
printf(1,"%s %s exists.\n",{fd[1+d],name})
else
printf(1,"%s does not exist.\n",{name})
end if
end procedure
check("input.txt")
check("docs")
check("/input.txt")
check("/docs")
check("/pagefile.sys")
check("/Program Files (x86)")</lang>
{{out}}
<pre>
input.txt does not exist.
directory docs exists.
/input.txt does not exist.
/docs does not exist.
file /pagefile.sys exists.
directory /Program Files (x86) exists.
</pre>
 
=={{header|PHP}}==
<lang 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';</lang>
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use File::Spec::Functions qw(catfile rootdir);
# here
print -e 'input.txt';
Line 1,120 ⟶ 2,346:
# root dir
print -e catfile rootdir, 'input.txt';
print -d catfile rootdir, 'docs';</langsyntaxhighlight>
 
'''Without a Perl Module'''
Line 1,129 ⟶ 2,355:
perl -e 'print -e "/input.txt", "\n";'
perl -e 'print -d "/docs", "\n";'
=={{header|Perl 6Phix}}==
{{libheader|Phix/basics}}
<lang perl6>
<!--<syntaxhighlight lang="phix">(notonline)-->
my $path = "/etc/passwd";
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>
say $path.IO.e ?? "Exists" !! "Does not exist";
<span style="color: #008080;">procedure</span> <span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">name</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">bool</span> <span style="color: #000000;">bExists</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">file_exists</span><span style="color: #0000FF;">(</span><span style="color: #000000;">name</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">bDir</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_file_type</span><span style="color: #0000FF;">(</span><span style="color: #000000;">name</span><span style="color: #0000FF;">)=</span><span style="color: #004600;">FILETYPE_DIRECTORY</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">exists</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bExists</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"exists"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"does not exist"</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">dfs</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bExists</span><span style="color: #0000FF;">?</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bDir</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"directory "</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"file "</span><span style="color: #0000FF;">):</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s%s %s.\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">dfs</span><span style="color: #0000FF;">,</span><span style="color: #000000;">name</span><span style="color: #0000FF;">,</span><span style="color: #000000;">exists</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"input.txt"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"docs"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"/input.txt"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"/docs"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"/pagefile.sys"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">check</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"/Program Files (x86)"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
file input.txt exists.
directory docs exists.
/input.txt does not exist.
/docs does not exist.
file /pagefile.sys exists.
directory /Program Files (x86) exists.
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">"foo.bar" "w" fopen
"Hallo !" over fputs
fclose
 
"fou.bar" "r" fopen
given $path.IO {
dup 0 < if "Could not open 'foo.bar' for reading" print drop else fclose endif</syntaxhighlight>
when :d { say "$path is a directory"; }
=={{header|PHP}}==
when :f { say "$path is a regular file"; }
<syntaxhighlight lang="php">if (file_exists('input.txt')) echo 'input.txt is here right by my side';
when :e { say "$path is neither a directory nor a file, but it does exist"; }
if (file_exists('docs' )) echo 'docs is here with me';
default { say "$path does not exist" }
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';</syntaxhighlight>
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisp">(if (info "file.txt")
(prinl "Size: " (car @) " bytes, last modified " (stamp (cadr @) (cddr @)))
(prinl "File doesn't exist") )
 
# for directory existing
</lang>
# Nehal-Singhal 2018-05-25
 
(if (info "./docs")
<code>when</code> internally uses the smart match operator <code>~~</code>, so <code>when :e</code> really does <code>$given ~~ :e</code> instead of the method call <code>$given.e</code>; both test whether the file exists.
(print 'exists)
(print 'doesNotExist)))
 
# To verify if it's really a directory, (CAR of return value will be 'T').
<lang perl6>
# abu 2018-05-25
run ('touch', "♥ Unicode.txt");
 
(let I (info "./docs")
say "♥ Unicode.txt".IO.e; # "True"
(prinl
say "♥ Unicode.txt".IO ~~ :e; # same
(nond
</lang>
(I "Does not exist")
 
((=T (car I)) "Is not a directory")
=={{header|PicoLisp}}==
(NIL "Directory exists") ) ) )
<lang PicoLisp>(if (info "file.txt")
</syntaxhighlight>
(prinl "Size: " (car @) " bytes, last modified " (stamp (cadr @) (cddr @)))
(prinl "File doesn't exist") )</lang>
=={{header|Pike}}==
<langsyntaxhighlight lang="pike">import Stdio;
 
int main(){
Line 1,168 ⟶ 2,428:
write("I exist!\n");
}
}</langsyntaxhighlight>
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">*Process source or(!);
/*********************************************************************
* 20.10.2013 Walter Pachl
Line 1,192 ⟶ 2,451:
Close File(f);
Label: Put Skip List('File '!!xxx!!' not found');
End;</langsyntaxhighlight>
{{out}}
<pre>
First line of file D:\_l\tst.txt: Test line 1
File D:\_l\nix.txt not found
</pre>
=={{header|PL/M}}==
This sample assumes that the original 8080 PL/M compiler is used and that the program will be running under CP/M.
CP/M doesn't have a hierarchical file-system, so there are no folders or directories. This sample looks for INPUT.TXT on the current drive and also on the D: drive. An error will occur if there is no D: drive, so it is best not to run this if you haven't got one... :)
<br>Note that CP/M restricts file names to 7-bit ascii upper-case and not all non-letter, non-digit characters can be used.
<br>CP/M filenames are up to 8 characters long with an optional, up to three character extension.
<syntaxhighlight lang="plm">100H:
 
DECLARE FCB$SIZE LITERALLY '36';
 
BDOS: PROCEDURE( FN, ARG )BYTE; /* CP/M BDOS SYSTEM CALL, RETURNS A VALUE */
DECLARE FN BYTE, ARG ADDRESS;
GOTO 5;
END BDOS;
BDOS$P: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL, NO RETURN VALUE */
DECLARE FN BYTE, ARG ADDRESS;
GOTO 5;
END BDOS$P;
PRINT$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS$P( 2, C ); END;
PRINT$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS$P( 9, S ); END;
PRINT$NL: PROCEDURE; CALL PRINT$STRING( .( 0DH, 0AH, '$' ) ); END;
SEARCH$FIRST: PROCEDURE( FCB )BYTE; /* RETURN 0, 1, 2, 3 IF FILE IN FCB */
DECLARE FCB ADDRESS; /* EXISTS, 255 OTHERWISE */
RETURN BDOS( 17, FCB );
END SEARCH$FIRST ;
 
INIT$FCB: PROCEDURE( FCB, NAME ); /* INITIALISE A FILE-CONTROL-BLOCK */
DECLARE ( FCB, NAME ) ADDRESS; /* SETTING THE FILE NAME */
DECLARE ( F$PTR, N$PTR, X$PTR ) ADDRESS;
DECLARE F BASED F$PTR BYTE, N BASED N$PTR BYTE;
DECLARE BLANKS ( 5 )BYTE INITIAL( ' ', ' ', ' ', ' ', '$' );
X$PTR = .BLANKS;
N$PTR = NAME + 1;
F$PTR = FCB;
IF N <> ':' THEN DO; /* NO DRIVE LETTER */
F = 0;
N$PTR = NAME;
END;
ELSE DO; /* FIRST CHAR IS THE DRIVE LETTER */
N$PTR = NAME;
F = ( N + 1 ) - 'A';
N$PTR = N$PTR + 2;
END;
DO F$PTR = FCB + 1 TO FCB + 8; /* NAME */
IF N = '$' THEN N$PTR = .BLANKS;
ELSE IF N = '.' THEN DO; /* START OF THE EXTENSION */
X$PTR = N$PTR + 1;
N$PTR = .BLANKS;
END;
F = N;
N$PTR = N$PTR + 1;
END;
N$PTR = X$PTR; /* EXTENSION */
DO F$PTR = FCB + 9 TO FCB + 11;
IF N = '$' THEN N$PTR =.BLANKS;
F = N;
N$PTR = N$PTR + 1;
END;
DO F$PTR = FCB + 12 TO FCB + ( FCB$SIZE - 1 ); /* OTHER FIELDS */
F = 0;
END;
END INIT$FCB ;
 
EXISTS: PROCEDURE( FCB )BYTE; /* RETURNS TRUE IF THE FILE NAMED IN THE */
DECLARE FCB ADDRESS; /* FCB EXISTS */
RETURN ( SEARCH$FIRST( FCB ) < 4 );
END EXISTS ;
 
DECLARE FCB$1$DATA ( FCB$SIZE )BYTE; /* DECLARE A FILE-CONTROL-BLOCK */
DECLARE FCB$1 ADDRESS;
FCB$1 = .FCB$1$DATA;
 
/* CP/M DOES NOT HAVE DIRECTORIES/FOLDERS - THIS TESTS FOR INPUT.TXT IN */
/* THE CURRENT DEFAULT DRIVE */
CALL INIT$FCB( FCB$1, .'INPUT.TXT$' );
CALL PRINT$STRING( .'INPUT.TXT: $' );
IF EXISTS( FCB$1 ) THEN CALL PRINT$STRING( .'EXISTS$' );
ELSE CALL PRINT$STRING( .'DOES NOT EXIST$' );
CALL PRINT$NL;
 
/* CHECK FOR INPUT.TXT IN THE D: DRIVE */
/* !!! THIS WILL CAUSE AN ERROR IF THERE IS NO DRIVE D: !!! */
/* !!! OR THERE IS NO DISC IN DRIVE D: !!! */
CALL INIT$FCB( FCB$1, .'D:INPUT.TXT$' );
CALL PRINT$STRING( .'D:INPUT.TXT: $' );
IF EXISTS( FCB$1 ) THEN CALL PRINT$STRING( .'EXISTS$' );
ELSE CALL PRINT$STRING( .'DOES NOT EXIST$' );
CALL PRINT$NL;
 
EOF</syntaxhighlight>
{{out}}
Assuming there is no INPUT.TXT on the current drive, but there is one on D:.
<pre>
INPUT.TXT: DOES NOT EXIST
D:INPUT.TXT: EXISTS
</pre>
Assuming there is no INPUT.TXT on the current drive and there os no D: drive.
<pre>
INPUT.TXT: DOES NOT EXIST
D:INPUT.TXT:
Bdos Err on A: Select
</pre>
 
=={{header|Plain English}}==
{{libheader|Plain English-output}}
<syntaxhighlight lang="text">
To run:
Start up.
\ In the current working directory
Check that ".\input.txt" is in the file system.
Check that ".\docs\" is in the file system.
\ In the filesystem root
Check that "C:\input.txt" is in the file system.
Check that "C:\docs\" is in the file system.
Wait for the escape key.
Shut down.
 
To check that a path is in the file system:
If the path is in the file system, write the path then " exists" to the output; exit.
If the path is not in the file system, write the path then " does not exist" to the output; exit.
</syntaxhighlight>
 
=={{header|Pop11}}==
 
<langsyntaxhighlight lang="pop11">sys_file_exists('input.txt') =>
sys_file_exists('/input.txt') =>
sys_file_exists('docs') =>
sys_file_exists('/docs') =></langsyntaxhighlight>
 
Note that the above literally checks for existence. Namely sys_file_exists returns true if file exists but can not be read.
Line 1,210 ⟶ 2,589:
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:
 
<langsyntaxhighlight lang="pop11">;;; Define an auxilary function, returns boolean
define file_readable(fname);
lvars f = sysopen(fname, 0, true, `A`);
Line 1,219 ⟶ 2,598:
return (false);
endif;
enddefine;</langsyntaxhighlight>
 
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):
Line 1,231 ⟶ 2,610:
 
Users can easily define special cases of the general procedure.
 
=={{header|PowerShell}}==
 
<langsyntaxhighlight lang="powershell"> if (Test-Path -Path .\input.txt</lang>) {
write-host "File input exist"
 
}
 
else {
write-host "File input doesn't exist"
}</syntaxhighlight>
=={{header|Prolog}}==
 
{{works with|SWI-Prolog|6.6}}
 
<langsyntaxhighlight lang="prolog">
 
exists_file('input.txt'),
Line 1,249 ⟶ 2,630:
exists_directory('/docs').
 
</syntaxhighlight>
</lang>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="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"
Line 1,270 ⟶ 2,650:
If result>0 : Debug "this root directory exists"
Else : Debug "result=" +Str(result) +" so this root directory is missing"
EndIf </langsyntaxhighlight>
 
=={{header|Python}}==
{{works with|Python|2.5}}
 
The ''os.path.exists'' method will return True if a path exists False if it does not.
 
<langsyntaxhighlight lang="python">import os
 
os.path.existsisfile("input.txt")
os.path.existsisfile("/input.txt")
os.path.existsisdir("docs")
os.path.existsisdir("/docs")</langsyntaxhighlight>
 
The more generic [https://docs.python.org/3/library/os.path.html#os.path.exists <code>os.path.exists(path)</code>] function will return True if the path exists, being it either a regular file or a directory.
=={{header|QB64}}==
<syntaxhighlight lang="qbasic">$NOPREFIX
PRINT DIREXISTS("docs")
PRINT DIREXISTS("\docs")
PRINT FILEEXISTS("input.txt")
PRINT FILEEXISTS("\input.txt")</syntaxhighlight>
=={{header|R}}==
<langsyntaxhighlight Rlang="r">file.exists("input.txt")
file.exists("/input.txt")
file.exists("docs")
Line 1,291 ⟶ 2,674:
 
# or
file.exists("input.txt", "/input.txt", "docs", "/docs")</langsyntaxhighlight>
 
The function <tt>file.exists</tt> returns a logical value (or a vector of logical values if more than one argument is passed)
 
This works with special names:
 
<syntaxhighlight lang="r">file.exists("`Abdu'l-Bahá.txt")</syntaxhighlight>
=={{header|Racket}}==
 
<syntaxhighlight lang="racket">
<lang Racket>
#lang racket
 
Line 1,312 ⟶ 2,698:
(and (file-exists? "input.txt")
(file-exists? "docs")))
</syntaxhighlight>
</lang>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>
my $path = "/etc/passwd";
say $path.IO.e ?? "Exists" !! "Does not exist";
 
given $path.IO {
when :d { say "$path is a directory"; }
when :f { say "$path is a regular file"; }
when :e { say "$path is neither a directory nor a file, but it does exist"; }
default { say "$path does not exist" }
}</syntaxhighlight>
 
<code>when</code> internally uses the smart match operator <code>~~</code>, so <code>when :e</code> really does <code>$given ~~ :e</code> instead of the method call <code>$given.e</code>; both test whether the file exists.
 
<syntaxhighlight lang="raku" line>
run ('touch', "♥ Unicode.txt");
 
say "♥ Unicode.txt".IO.e; # "True"
say "♥ Unicode.txt".IO ~~ :e; # same
</syntaxhighlight>
=={{header|Raven}}==
 
<langsyntaxhighlight lang="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</langsyntaxhighlight>
 
=={{header|REBOL}}==
<langsyntaxhighlight REBOLlang="rebol">exists? %input.txt
exists? %docs/
 
exists? %/input.txt
exists? %/docs/</langsyntaxhighlight>
=={{header|Red}}==
<syntaxhighlight lang="red">exists? %input.txt
exists? %docs/
exists? %/c/input.txt
exists? %/c/docs/
exists? %//input.txt
exists? %//docs/
 
>> exists? %`Abdu'l-Bahá.txt
== true</syntaxhighlight>
=={{header|REXX}}==
===version 1===
Line 1,333 ⟶ 2,747:
{{works with|Personal REXX}}
{{works with|Regina}}
<langsyntaxhighlight lang="rexx">/*REXX pgmprogram creates a new empty file and directory; in currcurrent dirdirectory and root dir.*/
fn= 'input.txt' /*default name of a file. */
fn='input.txt'
dn= 'docs' /*default name of a directory (folder).*/
dn='docs'
@.1= 'current directory'; @.2= 'root directory' /*msgsmessages used to forindicate eachwhich pass.*/
parse upper version v; regina=pos('REGINA',v)\==0 /*Reginaobtain name of the REXX being used?. */
regina= pos('REGINA' , v)\==0 /*is this the Regina REXX being used? */
r4 = pos('REXX-R4' , v)\==0 /*is this the R4 REXX being used? */
@doesnt= "doesn't exist in the"
@does = "does exist in the"
 
do j=1 for 2; say /* [↑] perform these statements twice.*/
if stream(fn, 'C', "QUERY EXISTS")=='' then say 'file ' fn " doesn't exist@doesnt in the" @.j
else say 'file ' fn " fn @does exist in the" @.j
 
if dosisdir(dn) then say 'directory ' dn " does exist in the" @.j
if j==2 then iterate
else say 'directory ' dn " doesn't exist in the" @.j
if reginastream(dn, 'C', then"QUERY callEXISTS")=='' then chdirsay '\directory' dn /*use Regina's version@doesnt of CHDIR@.*/j
else call doschdir else say '\directory' dn @does /*PC/REXX & Personal REXX version*/@.j
if j==1 then select
end /*j*/ /*now, go and perform them again.*/
when regina then call chdir '\' /*stickuse aRegina's forkversion inof it, we'reCHDIR. done.*/</lang>
when r4 then call stream '\', "C", 'CHDIR' /*R4's version. */
otherwise call doschdir '\' /*PC/REXX & Personal REXX version.*/
end /*select*/
end /*j*/ /*stick a fork in it, we're all done. */</syntaxhighlight>
 
===version 2===
{{works with|ARexx}}
{{works with|Regina 3.8 and later, with options: &nbsp; AREXX_BIFS &nbsp; AREXX_SEMANTICS}}
<langsyntaxhighlight lang="rexx">
/* Check if a file already exists */
filename='file.txt'
Line 1,361 ⟶ 2,783:
CALL Open(filehandle,filename,'APPEND')
RETURN 1
</syntaxhighlight>
</lang>
=={{header|Ring}}==
 
<syntaxhighlight lang="ring">
aFile = "C:\Ring\ReadMe.txt"
see aFile
if Fexists(aFile) see " exists" + nl
else see " doesn't exist" + nl ok
</syntaxhighlight>
=={{header|RLaB}}==
 
RLaB provides two user functions for the task, ''isfile'' and ''isdir''.
<syntaxhighlight lang="rlab">
<lang RLaB>
>> isdir("docs")
0
>> isfile("input.txt")
0
</syntaxhighlight>
</lang>
=={{header|RPL}}==
The 2 functions below take a word as an argument and return a boolean stating the presence or not of a 'file' (a 'variable' in RPL jargon) or a directory corresponding to the word.
« VARS SWAP POS
» '<span style="color:blue">ISHERE?</span>' STO
« PATH HOME
VARS ROT POS
SWAP EVAL <span style="color:grey">@ Back to initial directory</span>
» '<span style="color:blue">ISHOME?</span>' STO
 
=={{header|Ruby}}==
<code>File.existsexist?</code> only checks if a file exists; it can be a regular file, a directory, or something else. <code>File.file?</code> or <code>File.directory?</code> checks for a regular file or a directory. Ruby also allows <code>FileTest.file?</code> or <code>FileTest.directory?</code>.
 
<langsyntaxhighlight lang="ruby">File.file?("input.txt")
File.file?("/input.txt")
File.directory?("docs")
File.directory?("/docs")</langsyntaxhighlight>
 
The next program runs all four checks and prints the results.
 
<langsyntaxhighlight lang="ruby">["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) }</langsyntaxhighlight>
 
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">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"
</syntaxhighlight>
</lang>
=={{header|Rust}}==
<syntaxhighlight lang="rust">use std::fs;
 
fn main() {
for file in ["input.txt", "docs", "/input.txt", "/docs"].iter() {
match fs::metadata(file) {
Ok(attr) => {
if attr.is_dir() {
println!("{} is a directory", file);
}else {
println!("{} is a file", file);
}
},
Err(_) => {
println!("{} does not exist", file);
}
};
}
}
</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}<langsyntaxhighlight lang="scala">import java.nio.file.{ Files, FileSystems }
 
object FileExistsTest extends App {
Line 1,415 ⟶ 2,869:
// main
List("output.txt", separator + "output.txt", "docs", separator + "docs" + separator).foreach(test)
}</langsyntaxhighlight>
 
=={{header|Scheme}}==
{{works with|Scheme|R6RS}}[http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-10.html]
<syntaxhighlight lang ="scheme">(file-exists? filename)</langsyntaxhighlight>
 
=={{header|Seed7}}==
 
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const proc: main is func
Line 1,431 ⟶ 2,883:
writeln(fileType("docs") = FILE_DIR);
writeln(fileType("/docs") = FILE_DIR);
end func;</langsyntaxhighlight>
=={{header|SenseTalk}}==
 
<syntaxhighlight lang="sensetalk">
put file "input.txt" exists
put folder "docs" exists
put file "/input.txt" exists
put there is a folder "/docs"
</syntaxhighlight>
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby"># Here
say (Dir.cwd + %f'input.txt' -> is_file);
say (Dir.cwd + %d'docs' -> is_dir);
Line 1,440 ⟶ 2,899:
# Root
say (Dir.root + %f'input.txt' -> is_file);
say (Dir.root + %d'docs' -> is_dir);</langsyntaxhighlight>
NOTE: To check only for existence, use the method ''exists''
 
=={{header|Slate}}==
<langsyntaxhighlight lang="slate">(File newNamed: 'input.txt') exists
(File newNamed: '/input.txt') exists
(Directory root / 'input.txt') exists
(Directory newNamed: 'docs') exists
(Directory newNamed: '/docs') exists</langsyntaxhighlight>
 
=={{header|Smalltalk}}==
 
[[Squeak]] has no notion of 'current directory' because it isn't tied to the shell that created it.
 
<langsyntaxhighlight lang="smalltalk">FileDirectory new fileExists: 'c:\serial'.
(FileDirectory on: 'c:\') directoryExists: 'docs'.</langsyntaxhighlight>
 
In [[GNU Smalltalk]] instead you can do:
 
<langsyntaxhighlight lang="smalltalk">(Directory name: 'docs') exists ifTrue: [ ... ]
(Directory name: 'c:\docs') exists ifTrue: [ ... ]
(File name: 'serial') isFile ifTrue: [ ... ]
(File name: 'c:\serial') isFile ifTrue: [ ... ]</langsyntaxhighlight>
 
Using ''exists'' in the third and fourth case will return true for directories too.
 
=={{header|Standard ML}}==
<langsyntaxhighlight lang="sml">OS.FileSys.access ("input.txt", []);
OS.FileSys.access ("docs", []);
OS.FileSys.access ("/input.txt", []);
OS.FileSys.access ("/docs", []);</langsyntaxhighlight>
=={{header|Stata}}==
Mata has functions to check the existence of files and directories:
<syntaxhighlight lang="stata">mata
fileexists("input.txt")
direxists("docs")
end</syntaxhighlight>
 
It's not as straightforward in Stata's macro language. For files, use [http://www.stata.com/help.cgi?confirm confirm]. Since it throws an error when the file does not exist, use [http://www.stata.com/help.cgi?capture capture] and check [http://www.stata.com/help.cgi?_variables _rc] afterwards.
 
<syntaxhighlight lang="stata">capture confirm file input.txt
if !_rc {
* do something if the file exists
}</syntaxhighlight>
 
It's not possible to check the existence of a directory with confirm. One may use the [https://ideas.repec.org/c/boc/bocode/s435507.html confirmdir] package from SSC. The confirmdir command saves the current directory, then tries to chdir to the directory to test (with capture to prevent an error). Then the value of _rc is put in a [http://www.stata.com/help.cgi?return stored result]. Example of use:
 
<syntaxhighlight lang="stata">confirmdir docs
if !`r(confirmdir)' {
* do something if the directory exists
}</syntaxhighlight>
 
The command works with special names, but one has to be careful: the name "`Abdu'l-Bahá.txt" contains a backquote, which is used to denote macros in Stata. So this character must be escaped with a backslash:
 
<syntaxhighlight lang="stata">confirm file "\`Abdu'l-Bahá.txt"</syntaxhighlight>
=={{header|Tcl}}==
Taking the meaning of the task from the DOS example: <!-- multiline “if” because of formatting -->
<langsyntaxhighlight lang="tcl">if { [file exists "input.txt"] } {
puts "input.txt exists"
}
Line 1,488 ⟶ 2,967:
if { [file isdirectory [file nativename "/docs"]] } {
puts "/docs exists and is a directory"
}</langsyntaxhighlight>
Note that these operations do not require the use of <tt>file nativename</tt> on either Windows or any version of Unix.
 
=={{header|Toka}}==
 
<langsyntaxhighlight lang="toka">[ "R" file.open dup 0 <> [ dup file.close ] ifTrue 0 <> ] is exists?
" input.txt" exists? .
" /input.txt" exists? .
" docs" exists? .
" /docs" exists? .</langsyntaxhighlight>
=={{header|True BASIC}}==
<syntaxhighlight lang="truebasic">SUB opener (a$)
WHEN EXCEPTION IN
OPEN #1: NAME f$
PRINT f$; " exists"
USE
PRINT f$; " not exists"
END WHEN
CLOSE #1
END SUB
 
LET f$ = "input.txt"
CALL opener (f$)
LET f$ = "\input.txt"
CALL opener (f$)
LET f$ = "docs\nul"
CALL opener (f$)
LET f$ = "\docs\nul"
CALL opener (f$)
 
LET f$ = "empty.tru"
CALL opener (f$)
LET f$ = "`Abdu'l-Bahá.txt"
CALL opener (f$)
END</syntaxhighlight>
=={{header|TUSCRIPT}}==
<langsyntaxhighlight lang="tuscript">
$$ MODE TUSCRIPT
file="input.txt",directory="docs"
Line 1,513 ⟶ 3,015:
PRINT/ERROR "directory ",directory," not exists"
ENDIF
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,519 ⟶ 3,021:
@@@@@@@@ directory docs not exists @@@@@@@@
</pre>
 
=={{header|UNIX Shell}}==
<langsyntaxhighlight lang="bash">test -f input.txt
test -f /input.txt
test -d docs
test -d /docs</langsyntaxhighlight>
 
The next program runs all four checks and prints the results.
 
<langsyntaxhighlight lang="bash">for f in input.txt /input.txt; do
test -f "$f" && r=true || r=false
echo "$f is a regular file? $r"
Line 1,535 ⟶ 3,036:
test -d "$d" && r=true || r=false
echo "$d is a directory? $r"
done</langsyntaxhighlight>
=={{header|Ursa}}==
The easiest way to do this in Ursa is to attempt to open the file in question. If it doesn't exist, an ioerror will be thrown.
<syntaxhighlight lang="ursa">def exists (string filename)
decl file f
try
f.open filename
return true
catch ioerror
return false
end try
end exists</syntaxhighlight>
=={{header|Vala}}==
This needs to be compiled with the gio-2.0 package: valac --pkg gio-2.0 check_that_file_exists.vala
<syntaxhighlight lang="vala">int main (string[] args) {
string[] files = {"input.txt", "docs", Path.DIR_SEPARATOR_S + "input.txt", Path.DIR_SEPARATOR_S + "docs"};
foreach (string f in files) {
var file = File.new_for_path (f);
print ("%s exists: %s\n", f, file.query_exists ().to_string ());
}
return 0;
}</syntaxhighlight>
A more complete version which informs whether the existing file is a regular file or a directory
<syntaxhighlight lang="vala">int main (string[] args) {
string[] files = {"input.txt", "docs", Path.DIR_SEPARATOR_S + "input.txt", Path.DIR_SEPARATOR_S + "docs"};
foreach (var f in files) {
var file = File.new_for_path (f);
var exists = file.query_exists ();
var name = "";
if (!exists) {
print ("%s does not exist\n", f);
} else {
var type = file.query_file_type (FileQueryInfoFlags.NOFOLLOW_SYMLINKS);
if (type == 1) {
name = "file";
} else if (type == 2) {
name = "directory";
}
print ("%s %s exists\n", name, f);
}
}
return 0;
}</syntaxhighlight>
=={{header|VBA}}==
 
<syntaxhighlight lang="vb">
Option Explicit
 
Sub Main_File_Exists()
Dim myFile As String, myDirectory As String
myFile = "Abdu'l-Bahá.txt"
myDirectory = "C:\"
Debug.Print File_Exists(myFile, myDirectory)
End Sub
 
Function File_Exists(F As String, D As String) As Boolean
If F = "" Then
File_Exists = False
Else
D = IIf(Right(D, 1) = "\", D, D & "\")
File_Exists = (Dir(D & F) <> "")
End If
End Function
</syntaxhighlight>
=={{header|VBScript}}==
 
<syntaxhighlight lang="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
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
 
'Shorter version
 
If CreateObject("Scripting.FileSystemObject").FileExists("d:\test.txt") Then
Wscript.Echo "File Exists"
Else
Wscript.Echo "File Does Not Exist")
End If
 
 
</syntaxhighlight>
=={{header|Vedit macro language}}==
Vedit allows using either '\' or '/' as directory separator character, it is automatically converted to the one used by the operating system.
<langsyntaxhighlight lang="vedit">// 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") }
Line 1,545 ⟶ 3,147:
// 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") }</langsyntaxhighlight>
=={{header|Visual Basic}}==
{{works with|Visual Basic|VB6 Standard}}
The proposed solutions for VBA and VBScript work in VB6 as well, however here's a Windows API based approach:
<syntaxhighlight lang="vb">
'declarations:
Public Declare Function GetFileAttributes Lib "kernel32" _
Alias "GetFileAttributesA" (ByVal lpFileName As String) As Long
Public Const INVALID_FILE_ATTRIBUTES As Long = -1
Public Const ERROR_SHARING_VIOLATION As Long = 32&
 
'implementation:
Public Function FileExists(ByVal Filename As String) As Boolean
Dim l As Long
l = GetFileAttributes(Filename)
If l <> INVALID_FILE_ATTRIBUTES Then
FileExists = ((l And vbDirectory) = 0)
ElseIf Err.LastDllError = ERROR_SHARING_VIOLATION Then
FileExists = True
End If
End Function
</syntaxhighlight>
=={{header|Visual Basic .NET}}==
'''Platform:''' [[.NET]]
 
{{works with|Visual Basic .NET|9.0+}}
<langsyntaxhighlight lang="vbnet">'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"))
Line 1,563 ⟶ 3,185:
"directory exists", "directory doesn't exists"))
Console.WriteLine(If(IO.Directory.Exists(IO.Path.DirectorySeparatorChar & "output.txt"), _
"file exists", "file doesn't exists"))</langsyntaxhighlight>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="go">// Check file exists in V
// Tectonics: v run check-that-file-exists.v
module main
import os
 
// starts here
=={{header|VBScript}}==
pub fn main() {
// file and directory checks
_ := os.execute("touch input.txt")
println("os.is_file('input.txt'): ${os.is_file('input.txt')}")
 
// make doc directory in current dir if it doesn't exist
<lang vbscript>Set FSO=CreateObject("Scripting.FileSystemObject")
_ := os.execute("mkdir -p doc")
Function FileExists(strFile)
println("os.is_dir('doc'): ${os.is_dir('doc')}")
if FSO.fileExists(strFile) then
FileExists=true
else
FileExists=false
end if
end function
 
// check in the root dir
Function folderExists(strFolder)
println("os.is_file('/input.txt'): ${os.is_file('/input.txt')}")
if FSO.folderExists(strFolder) then
println("os.is_dir('/doc'): ${os.is_dir('/doc')}")
folderExists=true
else
folderexists=false
end if
end function
 
// check for file, with empty file
'''''usage (apostrophes indicate comments-this section will not be run)'''''
_ := os.execute("truncate -s 0 empty.txt")
'if fileExists("C:\test.txt") then
println("os.is_file('empty.txt'): ${os.is_file('empty.txt')}")
'msgbox"It Exists!"
'else
'msgbox"awww"
'end if
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
</lang>
 
// check for file, with exotic name
wfn := "`Abdu'l-Bahá.txt"
efn := wfn.replace_each(["'", r"\'", "`", r"\`"])
_ := os.execute('touch $efn')
println('os.is_file("$wfn"): ${os.is_file(wfn)}')
}</syntaxhighlight>
 
{{out}}
<pre>prompt$ v run check-that-file-exists.v
os.is_file('input.txt'): true
os.is_dir('doc'): true
os.is_file('/input.txt'): false
os.is_dir('/doc'): false
os.is_file('empty.txt'): true
os.is_file("`Abdu'l-Bahá.txt"): true</pre>
 
=={{header|Wren}}==
Empty files and directories have been created beforehand.
 
To check a file or directory exists in the root, just change "input.txt" to "/input.txt" and "docs" to "/docs" in the following script.
 
Since in Linux an ''empty'' directory has a size of 4K bytes, we check the number of files it contains to confirm that it's empty.
<syntaxhighlight lang="wren">import "io" for Directory, File
 
for (name in ["input.txt", "`Abdu'l-Bahá.txt"]) {
if (File.exists(name)) {
System.print("%(name) file exists and has a size of %(File.size(name)) bytes.")
} else {
System.print("%(name) file does not exist.")
}
}
 
var dir = "docs"
// if it exists get number of files it contains
if (Directory.exists(dir)) {
var files = Directory.list(dir).count
System.print("%(dir) directory exists and contains %(files) files.")
} else {
System.print("%(dir) directory does not exist.")
}</syntaxhighlight>
 
{{out}}
<pre>
input.txt file exists and has a size of 0 bytes.
`Abdu'l-Bahá.txt file exists and has a size of 0 bytes.
docs directory exists and contains 0 files.
</pre>
 
=={{header|XPL0}}==
Attempting to open a non-existent file or directory will cause an error.
A zero-length file is detected as existing.
<syntaxhighlight lang="xpl0">
int FD; \file descriptor
[Trap(false); \prevent errors from aborting program
FD:= FOpen("input.txt", 0);
if GetErr then Text(0, "input.txt doesn't exist^m^j");
FD:= FOpen("dir", 0);
if GetErr then Text(0, "dir doesn't exist^m^j");
FD:= FOpen("/input.txt", 0);
if GetErr then Text(0, "/input.txt doesn't exist^m^j");
FD:= FOpen("/dir", 0);
if GetErr then Text(0, "/dir doesn't exist^m^j");
]</syntaxhighlight>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">open "foo.bar" for writing as #1
print #1 "Hallo !"
close #1
if (not open(1,"foo.bar")) print "Could not open 'foo.bar' for reading"
close #1
if (not open(1,"buzz.bar")) print "Could not open 'buzz.bar' for reading"
</syntaxhighlight>
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">File.exists("input.txt") //--> True (in this case a sym link)
File.exists("/input.txt") //-->False
File.isDir("/") //-->True
File.isDir("docs") //-->False
</syntaxhighlight>
</lang>
{{omit from|Befunge|No filesystem support}}
 
{{omit from|EasyLang}}
{{omit from|HTML}}
{{omit from|Scratch|No filesystem support}}
{{omit from|TI-83 BASIC|Does not have a filesystem, just namespaced variables.}}
{{omit from|TI-89 BASIC|Does not have a filesystem, just namespaced variables.}}
{{omit from|Befunge|No filesystem support}}
885

edits