Check that file exists: Difference between revisions

;Task:

Verify that a file called     '''input.txt'''     and   a directory called     '''docs'''     exist.

:::* &nbsp; an unusual filename: &nbsp; <big> ''' `Abdu'l-Bahá.txt ''' </big>

<br><br>

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

{{Trans|Python}}

fs:is_file(‘/input.txt’)

fs:is_dir(‘docs’)

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program verifFic64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|Action!}}==

 

PROC MyError(BYTE errCode)

Test("D:INPUT.TXT")

Test("D:DOS.SYS")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Check_that_file_exists.png Screenshot from Atari 8-bit computer]

File "D:DOS.SYS" exists.

</pre>

=={{header|Ada}}==

This example should work with any Ada 95 compiler.

 

procedure File_Exists is

Put_Line (Boolean'Image (Does_File_Exist ("input.txt" )));

Put_Line (Boolean'Image (Does_File_Exist ("\input.txt")));

This example should work with any Ada 2005 compiler.

with Ada.Directories; use Ada.Directories;

 

Print_Dir_Exist ("docs");

Print_Dir_Exist ("/docs");

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

function exists (filename) {

return stat (filename) != null

exists ("/docs")

 

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

 

# check a file exists by attempting to open it for input #

test file exists( "\input.txt");

test directory exists( "docs" );

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

(macOS JavaScript for Automation)

use scripting additions

 

end script

end if

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

=={{header|Applesoft BASIC}}==

The error code for FILE NOT FOUND is 6.

110 T$(0) = "DOES NOT EXIST."

120 T$(1) = "EXISTS."

350 REM END TRY

360 RETURN

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program verifFic.s */

pop {fp,lr} /* restaur des 2 registres */

bx lr /* return */

=={{header|Arturo}}==

(or? exists? fpath

exists? .directory fpath)? -> print [fpath "exists"]

checkIfExists "/input.txt"

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

Another option is AutoHotkey's IfExist/IfNotExist command

 

ShowFileExist("input.txt")

ShowFileExist("\input.txt")

MsgBox, folder: %folder% does NOT exist.

Return

=={{header|AWK}}==

{{works with|gawk}}

 

function exists(name ,fd) {

exists("docs")

exists("/docs")

 

Portable getline method. Also works in a Windows environment.

# Check if file or directory exists, even 0-length file.

# Return 0 if not exist, 1 if exist

exists("\\docs")

exit(0)

 

{{works with|gawk}}

Check file(s) existence

=={{header|Axe}}==

Disp "EXISTS",i

Else

Disp "DOES NOT EXIST",i

=={{header|BASIC}}==

{{works with|QBasic}}

ON ERROR GOTO ohNo

f$ = "input.txt"

END IF

RESUME NEXT

 

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

 

ON ERROR GOTO ohNo

d$ = "docs"

END IF

RESUME NEXT

 

{{works with|QuickBasic|7.1}} {{works with|PowerBASIC for DOS}}

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

 

f$ = "input.txt"

GOSUB opener

END IF

RETURN

 

==={{header|BaCon}}===

f$ = "input.txt"

d$ = "docs"

 

f$ = "`Abdu'l-Bahá.txt"

 

{{out}}

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

15 ER=0:EM$="":MSG$="FILE EXISTS."

20 PRINT CHR$(147);:REM CLEAR SCREEN

1020 INPUT#15,ER,EM$,T,S

1030 CLOSE 15

 

{{Out}}<pre>ENTER FILENAME TO CHECK? INDEX.TXT

'NOFILE.DOC' IS NOT HERE.</pre>

 

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

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

if exist docs echo The following directory called docs exists.

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

IF test% THEN

CLOSE #test%

CLOSE #test%

PRINT "Directory \docs exists"

=={{header|BQN}}==

 

Takes filename as a command line argument, tells whether it exists.

 

=={{header|C}}==

{{libheader|POSIX}}

#include <sys/stat.h>

#include <stdio.h>

check_dir("/docs") ? "yes" : "no");

return 0;

 

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

 

 

Console.WriteLine(File.Exists("input.txt"));

Console.WriteLine(File.Exists("/input.txt"));

Console.WriteLine(Directory.Exists("docs"));

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

{{libheader|boost}}

#include <string>

#include <iostream>

testfile("/input.txt");

testfile("/docs");

 

=={{header|Clojure}}==

 

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

 

=={{header|COBOL}}==

{{works with|GnuCOBOL}} and other compilers with this system call extension

program-id. check-file-exist.

 

 

end program check-file-exist.

{{out}}

<pre>

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

fs = require 'fs'

path = require 'path'

 

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

(print "rel file exists"))

(if (probe-file (make-pathname :directory '(:absolute "") :name "input.txt"))

(if (directory (make-pathname :directory '(:absolute "docs")))

(print "abs directory exists")

 

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

(print "rel directory exists")

=={{header|Crystal}}==

if File.directory?(filename)

puts "#{filename} is a directory"

check_file("docs")

check_file("/input.txt")

=={{header|D}}==

 

void verify(in string name) {

verify(dirSeparator ~ "input.txt");

verify(dirSeparator ~ "docs");

{{out}}

<pre>'input.txt' doesn't exist

'\input.txt' doesn't exist

'\docs' doesn't exist</pre>

=={{header|DBL}}==

; Check file and directory exists for DBL version 4 by Dario B.

;

CLOS, CLOSE 1

CLOSE 2

=={{header|DCL}}==

$ then

$ write sys$output "input.txt not found"

$ else

$ write sys$output "directory [000000]docs found"

{{out}}

<pre>

[000000]input.txt not found

directory [000000]docs not found</pre>

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

else

Writeln('Directory "\docs" does not exists.');

=={{header|E}}==

<file:///input.txt>] {

require(file.exists(), fn { `$file is missing!` })

require(file.exists(), fn { `$file is missing!` })

require(file.isDirectory(), fn { `$file is not a directory!` })

=={{header|Elena}}==

ELENA 4.x :

import extensions;

 

console.printLine("\docs directory ",Directory.assign("\docs").validatePath())

=={{header|Elixir}}==

File.dir?("docs")

File.regular?("/input.txt")

=={{header|Emacs Lisp}}==

(file-directory-p "docs")

(file-exists-p "/input.txt")

 

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

existence( true ) ->"exists";

existence( false ) ->"does not exist".

print_result( "File", "/input.txt", filelib:is_regular("/input.txt") ),

print_result( "Directory", "/docs", filelib:is_dir("/docs") ).

=={{header|Euphoria}}==

 

procedure ensure_exists(sequence name)

ensure_exists("docs")

ensure_exists("/input.txt")

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

File.Exists("input.txt")

Directory.Exists("docs")

File.Exists("/input.txt")

=={{header|Factor}}==

[ write ": " write ] [ exists? "exists." "doesn't exist." ? print ] bi ;

 

=={{header|Forth}}==

 

 

=={{header|Fortran}}==

 

Cannot check for directories in Fortran

INQUIRE(FILE="input.txt", EXIST=file_exists) ! file_exists will be TRUE if the file

! exists and FALSE otherwise

 

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

 

! a trick to be sure docs is a dir

inquire( file="./docs/.", exist=dir_e )

! workaround: it calls an extern program...

call system('mkdir docs')

=={{header|FreeBASIC}}==

 

' Enable FileExists() function to be used

Print

Print "Press any key to quit the program"

 

{{out}}

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

 

checkFile[filename] :=

{

checkFile[normalizeUnicode[unusual, "NFC"]]

checkFile[normalizeUnicode[unusual, "NFD"]]

 

=={{header|Gambas}}==

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

 

If Exist(User.Home &/ "input.txt") Then Print "'input.txt' does exist in the Home folder"

If Exist(User.Home &/ "`Abdu'l-Bahá.txt") Then Print "'`Abdu'l-Bahá.txt' does exist (zero length and unusual name)"

 

Output:

<pre>

'`Abdu'l-Bahá.txt' does exist (zero length and unusual name)

</pre>

 

=={{header|GAP}}==

IsDirectoryPath("docs");

IsExistingFile("/input.txt");

=={{header|Genie}}==

/*

Check file exists, in Genie

if exists

dir = file.query_file_type(0) == FileType.DIRECTORY

 

{{out}}

 

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

=={{header|Go}}==

 

import (

printStat("docs")

printStat("/docs")

=={{header|Groovy}}==

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

println new File('docs').exists()

=={{header|Haskell}}==

 

 

check :: (FilePath -> IO Bool) -> FilePath -> IO ()

check doesDirectoryExist "docs"

check doesFileExist "/input.txt"

=={{header|hexiscript}}==

println "Dir \"docs\"? " + (exists "docs/")

println "File \"/input.txt\"? " + (exists "/input.txt")

=={{header|HicEst}}==

OPEN(FIle='C:\input.txt', OLD, IOStat=ios, ERror=99)

! ...

=={{header|HolyC}}==

if (FileFind(f) && !IsDir(f)) {

Print("'%s' file exists.\n", f);

FileExists("::/input.txt");

DirExists("docs");

=={{header|i}}==

open(path)

errors {

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.

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.

=={{header|IDL}}==

print, FILE_TEST('input.txt')

print, FILE_TEST(PATH_SEP()+'input.txt')

print, FILE_TEST(PATH_SEP()+'docs', /DIRECTORY)

 

=={{header|J}}==

fexist 'input.txt'

fexist '/input.txt'

direxist=: 2 = ftype

direxist 'docs'

=={{header|Java}}==

public class FileExistsTest {

public static boolean isFileExists(String filename) {

test("directory", File.separator + "docs" + File.separator);

}

{{works with|Java|7+}}

import java.nio.file.FileSystems;

import java.nio.file.Files;

test("directory", defaultFS.getSeparator() + "docs" + defaultFS.getSeparator());

}

 

=={{header|JavaScript}}==

Each non-browser JS context is likely to have its own home-grown and unstandardised file system library.

===JScript===

 

fso.FileExists('input.txt');

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

fso.FolderExists('docs');

 

===macOS JavaScript for Automation===

{{Trans|Haskell}}

(Adopting function names used in the Haskell System.Directory library)

 

// SYSTEM DIRECTORY FUNCTIONS

))

);

{{Out}}

The first four booleans are returned by doesFileExist – the last four by

true

]</pre>

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

@show isfile("/input.txt")

@show isdir("docs")

@show isdir("/docs")

@show isfile("")

=={{header|Klingphix}}==

 

"foo.bar" "w" fopen

dup 0 < ( ["Could not open 'fou.bar' for reading" print drop] [fclose] ) if

 

{{out}}

<pre>Could not open 'fou.bar' for reading</pre>

=={{header|Kotlin}}==

 

import java.io.File

println("$dirPath ${if (d.exists() && d.isDirectory) "exists" else "does not exist"}")

}

=={{header|LabVIEW}}==

{{libheader|LabVIEW CWD}}

{{VI snippet}}<br/>

[[File:Ensure_that_a_file_exists.png]]

 

=={{header|Lasso}}==

file_exists('input.txt')

 

 

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

=={{header|LFE}}==

From the LFE REPL:

> (: filelib is_regular '"input.txt")

false

> (: filelib is_dir '"/docs"))

false

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

dim info$(10,10)

input "Type a file path (ie. c:\windows\somefile.txt)?"; fpath$

pathLength = len(pathOnly$(fullPath$))

filenameOnly$ = right$(fullPath$, len(fullPath$)-pathLength)

=={{header|Little}}==

puts("The file \"input.txt\" exist");

}

if (exists("/docs")) {

puts("The file \"/docs\" exist");

=={{header|LiveCode}}==

there is a file "input.txt"

there is a folder "docs"

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

=={{header|Logo}}==

{{works with|UCB Logo}}

show file? "/input.txt

show file? "docs

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

=={{header|Lua}}==

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

if b then

print ( s, " does not exist." )

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

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

 

The following more portable solution uses LuaFileSystem.

for i, path in ipairs({"input.txt", "/input.txt", "docs", "/docs"}) do

local mode = lfs.attributes(path, "mode")

print(path .. " does not exist.")

end

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

 

Module ExistDirAndFile {

Let WorkingDir$=Dir$, RootDir$="C:\"

}

ExistDirAndFile

=={{header|Maple}}==

Exists("input.txt");

Exists("docs") and IsDirectory("docs");

Exists("/input.txt");

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

FileExistsQ[wd <> "input.txt"]

DirectoryQ[wd <> "docs"]

 

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

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

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

exist('docs','dir')

=={{header|MAXScript}}==

doesFileExist "input.txt"

(getDirectories "docs").count == 1

-- Root

doesFileExist "\input.txt"

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

 

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

IO.Put(Fmt.Bool(FileExists("docs/")) & "\n");

IO.Put(Fmt.Bool(FileExists("/docs")) & "\n");

=={{header|Nanoquery}}==

 

def exists(fname)

 

return f.exists()

=={{header|Neko}}==

Check that file/dir exists, in Neko

*/

 

name = "`Abdu'l-Bahá.txt"

 

{{out}}

empty.txt exists as empty file: true

`Abdu'l-Bahá.txt exists as file: true</pre>

=={{header|Nemerle}}==

{{trans|C#}}

using System.IO;

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

WriteLine(Directory.Exists("docs"));

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

 

return

=={{header|NewLISP}}==

(if (file? file true)

(println "file " file " exists")))

(dolist (dir '("docs" "/docs"))

(if (directory? dir)

=={{header|Nim}}==

 

echo fileExists "input.txt"

echo fileExists "/input.txt"

echo dirExists "docs"

=={{header|Objeck}}==

use IO;

 

}

}

 

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

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

 

=={{header|OCaml}}==

Sys.file_exists "docs";;

Sys.file_exists "/input.txt";;

=={{header|ooRexx}}==

* exists(filespec)

* returns 1 if filespec identifies a file with size>0

End

If size=0 Then Say spec 'is a zero-size file'

=={{header|Oz}}==

[Path] = {Module.link ['x-oz://system/os/Path.ozf']}

in

{Show {Path.exists "input.txt"}}

{Show {Path.exists "/docs"}}

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

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

 

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|Perl}}==

# here

print -e 'input.txt';

# root dir

print -e catfile rootdir, 'input.txt';

 

'''Without a Perl Module'''

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

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

=={{header|Phix}}==

{{libheader|Phix/basics}}

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

{{out}}

<pre>

directory /Program Files (x86) exists.

</pre>

=={{header|Phixmonti}}==

"Hallo !" over fputs

fclose

 

"fou.bar" "r" fopen

=={{header|PHP}}==

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

=={{header|PicoLisp}}==

(prinl "Size: " (car @) " bytes, last modified " (stamp (cadr @) (cddr @)))

(prinl "File doesn't exist") )

((=T (car I)) "Is not a directory")

(NIL "Directory exists") ) ) )

=={{header|Pike}}==

 

int main(){

write("I exist!\n");

}

=={{header|PL/I}}==

/*********************************************************************

* 20.10.2013 Walter Pachl

Close File(f);

Label: Put Skip List('File '!!xxx!!' not found');

{{out}}

<pre>

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.

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

 

DECLARE FCB$SIZE LITERALLY '36';

CALL PRINT$NL;

 

{{out}}

Assuming there is no INPUT.TXT on the current drive, but there is one on D:.

Bdos Err on A: Select

</pre>

 

=={{header|Pop11}}==

 

sys_file_exists('/input.txt') =>

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 file_readable(fname);

lvars f = sysopen(fname, 0, true, `A`);

return (false);

endif;

 

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

 

Users can easily define special cases of the general procedure.

=={{header|PowerShell}}==

 

write-host "File input exist"

}

else {

write-host "File input doesn't exist"

=={{header|Prolog}}==

 

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

 

 

exists_file('input.txt'),

exists_directory('/docs').

 

=={{header|PureBasic}}==

If result>0 : Debug "this local file exists"

Else : Debug "result=" +Str(result) +" so this local file is missing"

If result>0 : Debug "this root directory exists"

Else : Debug "result=" +Str(result) +" so this root directory is missing"

=={{header|Python}}==

 

 

os.path.isfile("input.txt")

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

os.path.isdir("docs")

 

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

PRINT DIREXISTS("docs")

PRINT DIREXISTS("\docs")

PRINT FILEEXISTS("input.txt")

=={{header|R}}==

file.exists("/input.txt")

file.exists("docs")

 

# or

 

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:

 

=={{header|Racket}}==

 

#lang racket

 

(and (file-exists? "input.txt")

(file-exists? "docs")))

=={{header|Raku}}==

(formerly Perl 6)

my $path = "/etc/passwd";

say $path.IO.e ?? "Exists" !! "Does not exist";

when :e { say "$path is neither a directory nor a file, but it does exist"; }

default { say "$path does not exist" }

 

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

 

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

 

say "♥ Unicode.txt".IO.e; # "True"

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

=={{header|Raven}}==

 

'/input.txt' exists if '/input.txt exists' print

'docs' isdir if 'docs exists and is a directory' print

=={{header|REBOL}}==

exists? %docs/

 

exists? %/input.txt

=={{header|Red}}==

exists? %docs/

exists? %/c/input.txt

 

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

=={{header|REXX}}==

===version 1===

{{works with|Personal REXX}}

{{works with|Regina}}

fn= 'input.txt' /*default name of a file. */

dn= 'docs' /*default name of a directory (folder).*/

otherwise call doschdir '\' /*PC/REXX & Personal REXX version.*/

end /*select*/

 

===version 2===

{{works with|ARexx}}

{{works with|Regina 3.8 and later, with options: &nbsp; AREXX_BIFS &nbsp; AREXX_SEMANTICS}}

/* Check if a file already exists */

filename='file.txt'

CALL Open(filehandle,filename,'APPEND')

RETURN 1

=={{header|Ring}}==

aFile = "C:\Ring\ReadMe.txt"

see aFile

if Fexists(aFile) see " exists" + nl

else see " doesn't exist" + nl ok

=={{header|RLaB}}==

 

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

>> isdir("docs")

0

>> isfile("input.txt")

0

 

=={{header|Ruby}}==

 

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

File.directory?("docs")

 

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

 

printf "%s is a regular file? %s\n", f, File.file?(f) }

["docs", "/docs"].each { |d|

 

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

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"

=={{header|Rust}}==

 

fn main() {

}

}

=={{header|Scala}}==

 

object FileExistsTest extends App {

// main

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

=={{header|Scheme}}==

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

=={{header|Seed7}}==

 

 

const proc: main is func

writeln(fileType("docs") = FILE_DIR);

writeln(fileType("/docs") = FILE_DIR);

=={{header|SenseTalk}}==

put file "input.txt" exists

put folder "docs" exists

put file "/input.txt" exists

put there is a folder "/docs"

=={{header|Sidef}}==

say (Dir.cwd + %f'input.txt' -> is_file);

say (Dir.cwd + %d'docs' -> is_dir);

# Root

say (Dir.root + %f'input.txt' -> is_file);

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

=={{header|Slate}}==

(File newNamed: '/input.txt') exists

(Directory root / 'input.txt') exists

(Directory newNamed: 'docs') exists

=={{header|Smalltalk}}==

 

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

 

 

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

 

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

(File name: 'serial') isFile ifTrue: [ ... ]

 

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

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

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

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

=={{header|Stata}}==

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

fileexists("input.txt")

direxists("docs")

 

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.

 

if !_rc {

* do something if the file exists

 

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:

 

if !`r(confirmdir)' {

* do something if the directory exists

 

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:

 

=={{header|Tcl}}==

Taking the meaning of the task from the DOS example: <!-- multiline “if” because of formatting -->

puts "input.txt exists"

}

if { [file isdirectory [file nativename "/docs"]] } {

puts "/docs exists and is a directory"

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

=={{header|Toka}}==

 

" input.txt" exists? .

" /input.txt" exists? .

" docs" exists? .

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

file="input.txt",directory="docs"

PRINT/ERROR "directory ",directory," not exists"

ENDIF

{{out}}

<pre>

@@@@@@@@ directory docs not exists @@@@@@@@

</pre>

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

test -f /input.txt

test -d docs

 

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

 

test -f "$f" && r=true || r=false

echo "$f is a regular file? $r"

test -d "$d" && r=true || r=false

echo "$d is a directory? $r"

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

decl file f

try

return false

end try

=={{header|Vala}}==

This needs to be compiled with the gio-2.0 package: valac --pkg gio-2.0 check_that_file_exists.vala

string[] files = {"input.txt", "docs", Path.DIR_SEPARATOR_S + "input.txt", Path.DIR_SEPARATOR_S + "docs"};

foreach (string f in files) {

}

return 0;

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

string[] files = {"input.txt", "docs", Path.DIR_SEPARATOR_S + "input.txt", Path.DIR_SEPARATOR_S + "docs"};

foreach (var f in files) {

}

return 0;

=={{header|VBA}}==

 

Option Explicit

 

End If

End Function

=={{header|VBScript}}==

 

 

Function FileExists(strFile)

 

 

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

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

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

'declarations:

Public Declare Function GetFileAttributes Lib "kernel32" _

End If

End Function

=={{header|Visual Basic .NET}}==

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

 

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

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

"directory exists", "directory doesn't exists"))

Console.WriteLine(If(IO.Directory.Exists(IO.Path.DirectorySeparatorChar & "output.txt"), _

// Tectonics: v run check-that-file-exists.v

module main

_ := os.execute('touch $efn')

println('os.is_file("$wfn"): ${os.is_file(wfn)}')

 

{{out}}

os.is_file('empty.txt'): true

os.is_file("`Abdu'l-Bahá.txt"): true</pre>

 

=={{header|Wren}}==

 

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.

 

for (name in ["input.txt", "`Abdu'l-Bahá.txt"]) {

} else {

System.print("%(dir) directory does not exist.")

 

{{out}}

</pre>

 

=={{header|Yabasic}}==

print #1 "Hallo !"

close #1

close #1

if (not open(1,"buzz.bar")) print "Could not open 'buzz.bar' for reading"

=={{header|zkl}}==

File.exists("/input.txt") //-->False

File.isDir("/") //-->True

File.isDir("docs") //-->False

{{omit from|Befunge|No filesystem support}}

{{omit from|HTML}}

{{omit from|Scratch|No filesystem support}}