Erlang

#!/usr/bin/escript
existence( true ) ->"exists";
existence( false ) ->"does not exist".

print_result(Type, Name, Flag) -> io:fwrite( "~s ~s ~s~n", [Type, Name, existence(Flag)] ).


main(_) ->
        print_result( "File", "input.txt", filelib:is_regular("input.txt") ),
        print_result( "Directory", "docs", filelib:is_dir("docs") ),
        print_result( "File", "/input.txt", filelib:is_regular("/input.txt") ),
        print_result( "Directory", "/docs", filelib:is_dir("/docs") ).

Euphoria

include file.e

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

ensure_exists("input.txt")
ensure_exists("docs")
ensure_exists("/input.txt")
ensure_exists("/docs")

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

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

Factor

: print-exists? ( path -- )
    [ write ": " write ] [ exists? "exists." "doesn't exist." ? print ] bi ;

{ "input.txt" "/input.txt" "docs" "/docs" } [ print-exists? ] each

Forth

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

Fortran

{{works with|Fortran|90 and later}}

Cannot check for directories in Fortran

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

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

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

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

{{out}} All files and directories were created first. The files are empty:

'c:\FreeBasic\input.txt' exists
'c:\FreeBasic\docs' exists
'c:\input.txt' exists
'c:\docs' exists

Gambas

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

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

Output:

'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)

GAP

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

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" : "")

{{out}}

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

For the run, ''input.txt'' was zero length.

Go

package main

import (
    "fmt"
    "os"
)

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

func main() {
    printStat("input.txt")
    printStat("/input.txt")
    printStat("docs")
    printStat("/docs")
}

Groovy

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

Haskell

import System.Directory (doesFileExist, doesDirectoryExist)

check :: (FilePath -> IO Bool) -> FilePath -> IO ()
check p s = do
  result <- p s
  putStrLn $
    s ++
    if result
      then " does exist"
      else " does not exist"

main :: IO ()
main = do
  check doesFileExist "input.txt"
  check doesDirectoryExist "docs"
  check doesFileExist "/input.txt"
  check doesDirectoryExist "/docs"

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/")

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

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

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

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

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

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");

IDL

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

J

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

Java

import java.io.File;
public class FileExistsTest {
   public static boolean isFileExists(String filename) {
       boolean exists = new File(filename).exists();
       return exists;
   }
   public static void test(String type, String filename) {
       System.out.println("The following " + type + " called " + filename +
           (isFileExists(filename) ? " exists." : " not exists.")
       );
   }
   public static void main(String args[]) {
        test("file", "input.txt");
        test("file", File.separator + "input.txt");
        test("directory", "docs");
        test("directory", File.separator + "docs" + File.separator);
   }
}

{{works with|Java|7+}}

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

Non retarded version:

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());
   }

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. Each non-browser JS context is likely to have its own home-grown and unstandardised file system library.

JScript

var fso = new ActiveXObject("Scripting.FileSystemObject");

fso.FileExists('input.txt');
fso.FileExists('c:/input.txt');
fso.FolderExists('docs');
fso.FolderExists('c:/docs');

macOS JavaScript for Automation

=ES6: Sierra onwards=

{{Trans|Haskell}} (Adopting function names used in the Haskell System.Directory library)

(() => {

    // 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']
        ))
    );
})();

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

[
  true,
  true,
  true,
  true,
  false,
  false,
  true,
  true
]

Julia

{{works with|Julia|0.6}}

@show isfile("input.txt")
@show isfile("/input.txt")
@show isdir("docs")
@show isdir("/docs")
@show isfile("")
@show isfile("`Abdu'l-Bahá.txt")

Kotlin

// 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"}")
    }
}

LabVIEW

{{libheader|LabVIEW CWD}} {{VI snippet}}
[[File:Ensure_that_a_file_exists.png]]

Lasso

// local file
file_exists('input.txt')

// local directory
file_exists('docs')

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

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

LFE

From the LFE REPL:

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

Liberty BASIC

'fileExists.bas - Show how to determine if a file exists
dim info$(10,10)
input "Type a file path (ie. c:\windows\somefile.txt)?"; fpath$
if fileExists(fpath$) then
    print fpath$; " exists!"
else
    print fpath$; " doesn't exist!"
end if
end

'return a true if the file in fullPath$ exists, else return false
function fileExists(fullPath$)
    files pathOnly$(fullPath$), filenameOnly$(fullPath$), info$()
    fileExists = val(info$(0, 0)) > 0
end function

'return just the directory path from a full file path
function pathOnly$(fullPath$)
    pathOnly$ = fullPath$
    while right$(pathOnly$, 1) <> "\" and pathOnly$ <> ""
        pathOnly$ = left$(pathOnly$, len(pathOnly$)-1)
    wend
end function

'return just the filename from a full file path
function filenameOnly$(fullPath$)
    pathLength = len(pathOnly$(fullPath$))
    filenameOnly$ = right$(fullPath$, len(fullPath$)-pathLength)
end function

Little

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");
}

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"

LiveCode also allows setting a default folder for subsequent file commands. To check if a file exists in the doc folder

set the defaultFolder to "docs"
there is a file "input.txt"

Logo

{{works with|UCB Logo}}

show file? "input.txt
show file? "/input.txt
show file? "docs
show file? "/docs

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

setprefix "/
show file? "input.txt

Lua

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

function output( s, b )
    if b then
        print ( s, " does not exist." )
    else
        print ( s, " does exist." )
    end
end

output( "input.txt",  io.open( "input.txt", "r" ) == nil )
output( "/input.txt", io.open( "/input.txt", "r" ) == nil )
output( "docs",  io.open( "docs", "r" ) == nil )
output( "/docs", io.open( "/docs", "r" ) == nil )

The following more portable solution uses LuaFileSystem.

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

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.

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

Maple

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

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

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

FileExistsQ["/" <> "input.txt"]
DirectoryQ["/" <> "docs"]

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

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

MAXScript

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

=={{header|Modula-3}}==

MODULE FileTest EXPORTS Main;

IMPORT IO, Fmt, FS, File, OSError, Pathname;

PROCEDURE FileExists(file: Pathname.T): BOOLEAN =
  VAR status: File.Status;
  BEGIN
    TRY
      status := FS.Status(file);
      RETURN TRUE;
    EXCEPT
    | OSError.E => RETURN FALSE;
    END;
  END FileExists;

BEGIN
  IO.Put(Fmt.Bool(FileExists("input.txt")) & "\n");
  IO.Put(Fmt.Bool(FileExists("/input.txt")) & "\n");
  IO.Put(Fmt.Bool(FileExists("docs/")) & "\n");
  IO.Put(Fmt.Bool(FileExists("/docs")) & "\n");
END FileTest.

Neko

/**
 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")

{{out}}

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

Nemerle

{{trans|C#}}

using System.Console;
using System.IO;

WriteLine(File.Exists("input.txt"));
WriteLine(File.Exists("/input.txt"));
WriteLine(Directory.Exists("docs"));
WriteLine(Directory.Exists("/docs"));

NetRexx

/* NetRexx */
options replace format comments java crossref symbols binary

runSample(arg)
return

-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method isExistingFile(fn) public static returns boolean
  ff = File(fn)
  fExists = ff.exists() & ff.isFile()
  return fExists

-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method isExistingDirectory(fn) public static returns boolean
  ff = File(fn)
  fExists = ff.exists() & ff.isDirectory()
  return fExists

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static
  parse arg files
  if files = '' then files = 'input.txt F docs D /input.txt F /docs D'
  loop while files.length > 0
    parse files fn ft files
    select case(ft.upper())
      when 'F' then do
        if isExistingFile(fn) then ex = 'exists'
        else                       ex = 'does not exist'
        say 'File '''fn'''' ex
        end
      when 'D' then do
        if isExistingDirectory(fn) then ex = 'exists'
        else                            ex = 'does not exist'
        say 'Directory '''fn'''' ex
        end
      otherwise do
        if isExistingFile(fn) then ex = 'exists'
        else                       ex = 'does not exist'
        say 'File '''fn'''' ex
        end
      end
    end

  return

NewLISP

(dolist (file '("input.txt" "/input.txt"))
  (if (file? file true)
      (println "file " file " exists")))

(dolist (dir '("docs" "/docs"))
  (if (directory? dir)
      (println "directory " dir " exists")))

Nim

import os

echo existsFile "input.txt"
echo existsFile "/input.txt"
echo existsDir "docs"
echo existsDir "/docs"

=={{header|Objective-C}}==

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

Objeck

use IO;

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

OCaml

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

ooRexx

/**********************************************************************
* exists(filespec)
* returns 1   if filespec identifies a file with size>0
*                (a file of size 0 is deemed not to exist.)
*             or a directory
*         0   otherwise
* 09.06.2013 Walter Pachl (retrieved from my toolset)
**********************************************************************/
exists:
  parse arg spec
  call sysfiletree spec, 'LIST', 'BL'
  if list.0\=1 then return 0        -- does not exist
  parse var list.1 . . size flags .
  if size>0 then return 1           -- real file
  If substr(flags,2,1)='D' Then Do
    Say spec 'is a directory'
    Return 1
    End
  If size=0 Then Say spec 'is a zero-size file'
  Return 0

Oz

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

PARI/GP

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

A better version would use externstr.

Under PARI it would typically be more convenient to use [[#C|C]] methods.

Pascal

See [[Ensure_that_a_file_exists#Delphi | Delphi]]

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)")

{{out}}

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.

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';

Perl

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

'''Without a Perl Module'''

A '''1''' is printed if the file or dir exists. perl -e 'print -e "./input.txt", "\n";' perl -e 'print -d "./docs", "\n";' perl -e 'print -e "/input.txt", "\n";' perl -e 'print -d "/docs", "\n";'

Perl 6

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

when internally uses the smart match operator ~~, so when :e really does $given ~~ :e instead of the method call $given.e; both test whether the file exists.

run ('touch', "♥ Unicode.txt");

say "♥ Unicode.txt".IO.e;      # "True"
say "♥ Unicode.txt".IO ~~ :e;  # same

PicoLisp

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

# for directory existing
# Nehal-Singhal 2018-05-25

(if (info "./docs")
  (print 'exists)
  (print 'doesNotExist)))

# To verify if it's really a directory, (CAR of return value will be 'T').
# abu 2018-05-25

  (let I (info "./docs")
      (prinl
         (nond
            (I "Does not exist")
            ((=T (car I)) "Is not a directory")
            (NIL "Directory exists") ) ) )

Pike

import Stdio;

int main(){
   if(exist("/var")){
      write("/var exists!\n");
   }

   if(exist("file-exists.pike")){
      write("I exist!\n");
   }
}

PL/I

*Process source or(!);
 /*********************************************************************
 * 20.10.2013 Walter Pachl
 * 'set dd:f=d:\_l\xxx.txt,recsize(300)'
 * 'tex'
 *********************************************************************/
 tex: Proc Options(main);
 Dcl fid Char(30) Var Init('D:\_l\tst.txt');
 Dcl xxx Char(30) Var Init('D:\_l\nix.txt');
 Dcl r   Char(1000) Var;
 Dcl f Record input;
 On Undefinedfile(f) Goto label;
 Open File(f) Title('/'!!fid);
 Read file(f) Into(r);
 Put Skip List('First line of file '!!fid!!': '!!r);
 Close File(f);
 Open File(f) Title('/'!!xxx);
 Read file(f) Into(r);
 Put Skip List(r);
 Close File(f);
 Label: Put Skip List('File '!!xxx!!' not found');
 End;

{{out}}

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

Pop11

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

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

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

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

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

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

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

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

Users can easily define special cases of the general procedure.

PowerShell

 Test-Path input.txt

Prolog

{{works with|SWI-Prolog|6.6}}

exists_file('input.txt'),
exists_directory('docs').

exits_file('/input.txt'),
exists_directory('/docs').

PureBasic

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

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

result = ExamineDirectory(#PB_Any,"docs","")
If result>0 : Debug "this local directory exists"
  Else : Debug "result=" +Str(result) +" so this local directory is missing"
EndIf

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

Python

import os

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

The more generic [https://docs.python.org/3/library/os.path.html#os.path.exists os.path.exists(path)] function will return True if the path exists, being it either a regular file or a directory.

R

file.exists("input.txt")
file.exists("/input.txt")
file.exists("docs")
file.exists("/docs")

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

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

Racket

#lang racket

;; here
(file-exists? "input.txt")
(file-exists? "docs")

;; in the root
(file-exists? "/input.txt")
(file-exists? "/docs")

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

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

REBOL

exists? %input.txt
exists? %docs/

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

Red

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

>> exists? %`Abdu'l-Bahá.txt
== true

REXX

version 1

{{works with|PC/REXX}} {{works with|Personal REXX}} {{works with|Regina}}

/*REXX program creates a new empty file and directory in current directory and root dir.*/
fn= 'input.txt'                                  /*default name of a file.              */
dn= 'docs'                                       /*default name of a directory (folder).*/
@.1= 'current directory';  @.2= 'root directory' /*messages used to indicate which pass.*/
parse upper version v                            /*obtain 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   @doesnt   @.j
                                         else say 'file '       fn   @does     @.j

 if j==2  then iterate
 if stream(dn, 'C', "QUERY EXISTS")==''  then say 'directory'   dn   @doesnt   @.j
                                         else say 'directory'   dn   @does     @.j
 if j==1  then select
               when regina  then call chdir    '\'    /*use Regina's version of  CHDIR. */
               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. */

version 2

{{works with|ARexx}} {{works with|Regina 3.8 and later, with options: AREXX_BIFS AREXX_SEMANTICS}}

/* Check if a file already exists */
filename='file.txt'
IF ~Openfile(filename) THEN CALL Openfile(':'filename)
EXIT 0
Openfile:
IF ~Exists(filename) THEN RETURN 0
CALL Open(filehandle,filename,'APPEND')
RETURN 1

Ring

aFile = "C:\Ring\ReadMe.txt"
see aFile
if Fexists(aFile) see " exists" + nl
else see " doesn't exist" + nl ok

RLaB

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

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

Ruby

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

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

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

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

Run BASIC

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

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);
            }
        };
    }
}

Scala

{{libheader|Scala}}

import java.nio.file.{ Files, FileSystems }

object FileExistsTest extends App {

  val defaultFS = FileSystems.getDefault()
  val separator = defaultFS.getSeparator()

  def test(filename: String) {
    val path = defaultFS.getPath(filename)

    println(s"The following ${if (Files.isDirectory(path)) "directory" else "file"} called $filename" +
      (if (Files.exists(path)) " exists." else " not exists."))
  }

  // main
  List("output.txt", separator + "output.txt", "docs", separator + "docs" + separator).foreach(test)
}

Scheme

{{works with|Scheme|R6RS}}[http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-10.html]

(file-exists? filename)

Seed7

$ include "seed7_05.s7i";

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

Sidef

# Here
say (Dir.cwd  + %f'input.txt' -> is_file);
say (Dir.cwd  + %d'docs'      -> is_dir);

# Root
say (Dir.root + %f'input.txt' -> is_file);
say (Dir.root + %d'docs'      -> is_dir);

NOTE: To check only for existence, use the method ''exists''

Slate

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

Smalltalk

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

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

In [[GNU Smalltalk]] instead you can do:

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

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

Standard ML

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

Stata

Mata has functions to check the existence of files and directories:

mata
fileexists("input.txt")
direxists("docs")
end

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.

capture confirm file input.txt
if !_rc {
	* do something if the file exists
}

It's not possible to check 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:

confirmdir docs
if !`r(confirmdir)' {
	* do something if the directory exists
}

Tcl

Taking the meaning of the task from the DOS example:

if { [file exists "input.txt"] } {
    puts "input.txt exists"
}

if { [file exists [file nativename "/input.txt"]] } {
    puts "/input.txt exists"
}

if { [file isdirectory "docs"] } {
    puts "docs exists and is a directory"
}

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

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

Toka

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

TUSCRIPT

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

{{out}}

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

UNIX Shell

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

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

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

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.

def exists (string filename)
	decl file f
	try
		f.open filename
		return true
	catch ioerror
		return false
	end try
end exists

Vala

This needs to be compiled with the gio-2.0 package: valac --pkg gio-2.0 check_that_file_exists.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;
}

A more complete version which informs whether the existing file is a regular file or a directory

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

Vedit macro language

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

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

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

Visual Basic .NET

'''Platform:''' [[.NET]]

{{works with|Visual Basic .NET|9.0+}}

'Current Directory
Console.WriteLine(If(IO.Directory.Exists("docs"), "directory exists", "directory doesn't exists"))
Console.WriteLine(If(IO.Directory.Exists("output.txt"), "file exists", "file doesn't exists"))

'Root
Console.WriteLine(If(IO.Directory.Exists("\docs"), "directory exists", "directory doesn't exists"))
Console.WriteLine(If(IO.Directory.Exists("\output.txt"), "file exists", "file doesn't exists"))

'Root, platform independent
Console.WriteLine(If(IO.Directory.Exists(IO.Path.DirectorySeparatorChar & "docs"), _
   "directory exists", "directory doesn't exists"))
Console.WriteLine(If(IO.Directory.Exists(IO.Path.DirectorySeparatorChar & "output.txt"), _
  "file exists", "file doesn't exists"))

VBA

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

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

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:

'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

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"

zkl

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

{{omit from|HTML}} {{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}}