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

fs:is_dir(‘/docs’)</syntaxhighlight>

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program verifFic64.s */

.include "../includeARM64.inc"

</syntaxhighlight>

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

 

PROC MyError(BYTE errCode)

File "D:DOS.SYS" exists.

</pre>

=={{header|Ada}}==

This example should work with any Ada 95 compiler.

 

procedure File_Exists is

end File_Exists;</syntaxhighlight>

This example should work with any Ada 2005 compiler.

with Ada.Directories; use Ada.Directories;

 

Print_Dir_Exist ("/docs");

end File_Exists;</syntaxhighlight>

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

 

</syntaxhighlight>

=={{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 directory exists( "docs" );

test directory exists( "\docs" )</syntaxhighlight>

=={{header|Amazing Hopper}}==

Version: hopper-FLOW!:

#include <flow.h>

 

$

</pre>

=={{header|APL}}==

h ← ⎕fio['fopen'] 'input.txt'

h

¯1

</syntaxhighlight>

=={{header|AppleScript}}==

{{Trans|JavaScript}}

(macOS JavaScript for Automation)

use scripting additions

 

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

360 RETURN

</syntaxhighlight>

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program verifFic.s */

bx lr /* return */

</syntaxhighlight>

=={{header|Arturo}}==

(or? exists? fpath

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

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.

Another option is AutoHotkey's IfExist/IfNotExist command

 

ShowFileExist("input.txt")

ShowFileExist("\input.txt")

Return

}</syntaxhighlight>

=={{header|AWK}}==

{{works with|gawk}}

 

function exists(name ,fd) {

 

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

{{works with|gawk}}

Check file(s) existence

=={{header|Axe}}==

Disp "EXISTS",i

Else

Disp "DOES NOT EXIST",i

End</syntaxhighlight>

=={{header|BASIC}}==

{{works with|QBasic}}

ON ERROR GOTO ohNo

f$ = "input.txt"

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

 

ON ERROR GOTO ohNo

d$ = "docs"

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

 

f$ = "input.txt"

GOSUB opener

 

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

f$ = "input.txt"

d$ = "docs"

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

ENTER FILENAME TO CHECK? NOFILE.DOC

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

 

=={{header|BASIC256}}==

if exists(filename$) then

print filename$; " exists"

call opener ("`Abdu'l-Bahá.txt"))

end</syntaxhighlight>

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

if exist \docs\ echo The following directory called \docs\ exists.</syntaxhighlight>

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

IF test% THEN

CLOSE #test%

PRINT "Directory \docs exists"

ENDIF</syntaxhighlight>

=={{header|BQN}}==

 

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

 

•Out fname∾" Does not exist"‿" Exists"⊑˜•File.exists fname</syntaxhighlight>

=={{header|C}}==

{{libheader|POSIX}}

#include <sys/stat.h>

#include <stdio.h>

return 0;

}</syntaxhighlight>

 

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

 

 

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

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

Console.WriteLine(Directory.Exists("/docs"));</syntaxhighlight>

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

{{libheader|boost}}

#include <string>

#include <iostream>

testfile("/docs");

}</syntaxhighlight>

 

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

program-id. check-file-exist.

 

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'

 

</syntaxhighlight>

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

 

{{libheader|CL-FAD}}

(print "rel directory exists")

(print "rel directory does not exist"))</syntaxhighlight>

=={{header|Crystal}}==

if File.directory?(filename)

puts "#{filename} is a directory"

check_file("/input.txt")

check_file("/docs")</syntaxhighlight>

=={{header|D}}==

 

void verify(in string name) {

'\input.txt' doesn't exist

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

=={{header|DBL}}==

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

;

CLOSE 2

STOP</syntaxhighlight>

=={{header|DCL}}==

$ then

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

[000000]input.txt not found

directory [000000]docs not found</pre>

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

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

end.</syntaxhighlight>

=={{header|E}}==

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

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

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

}</syntaxhighlight>

=={{header|Elena}}==

ELENA 4.x :

import extensions;

 

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

}</syntaxhighlight>

=={{header|Elixir}}==

File.dir?("docs")

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

File.dir?("/docs")</syntaxhighlight>

=={{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( "Directory", "/docs", filelib:is_dir("/docs") ).

</syntaxhighlight>

=={{header|Euphoria}}==

 

procedure ensure_exists(sequence name)

ensure_exists("/input.txt")

ensure_exists("/docs")</syntaxhighlight>

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

File.Exists("input.txt")

Directory.Exists("docs")

File.Exists("/input.txt")

Directory.Exists(@"\docs")</syntaxhighlight>

=={{header|Factor}}==

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

 

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

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

call system('mkdir docs')

end if</syntaxhighlight>

=={{header|FreeBASIC}}==

 

' Enable FileExists() function to be used

'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"]]

</syntaxhighlight>

 

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

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

</pre>

 

=={{header|GAP}}==

IsDirectoryPath("docs");

IsExistingFile("/input.txt");

IsDirectoryPath("/docs");</syntaxhighlight>

=={{header|Genie}}==

/*

Check file exists, in Genie

 

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

=={{header|Go}}==

 

import (

printStat("/docs")

}</syntaxhighlight>

=={{header|Groovy}}==

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

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

println new File('/docs').exists()</syntaxhighlight>

=={{header|Haskell}}==

 

 

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

check doesFileExist "/input.txt"

check doesDirectoryExist "/docs"</syntaxhighlight>

=={{header|hexiscript}}==

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

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

println "Dir \"/docs\"? " + (exists "/docs/")</syntaxhighlight>

=={{header|HicEst}}==

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

! ...

99 WRITE(Messagebox='!') 'File does not exist. Error message ', ios </syntaxhighlight>

=={{header|HolyC}}==

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

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

DirExists("docs");

DirExists("::/docs");</syntaxhighlight>

=={{header|i}}==

open(path)

errors {

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.

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

}</syntaxhighlight>

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

=={{header|IDL}}==

print, FILE_TEST('input.txt')

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

 

</syntaxhighlight>

=={{header|J}}==

fexist 'input.txt'

fexist '/input.txt'

direxist 'docs'

direxist '/docs'</syntaxhighlight>

=={{header|Java}}==

public class FileExistsTest {

public static boolean isFileExists(String filename) {

}</syntaxhighlight>

{{works with|Java|7+}}

import java.nio.file.FileSystems;

import java.nio.file.Files;

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

===JScript===

 

fso.FileExists('input.txt');

{{Trans|Haskell}}

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

 

// SYSTEM DIRECTORY FUNCTIONS

true

]</pre>

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

@show isfile("/input.txt")

@show isdir("docs")

@show isfile("")

@show isfile("`Abdu'l-Bahá.txt")</syntaxhighlight>

=={{header|Klingphix}}==

 

"foo.bar" "w" fopen

{{out}}

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

=={{header|Kotlin}}==

 

import java.io.File

}

}</syntaxhighlight>

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

file_exists('//docs')</syntaxhighlight>

=={{header|LFE}}==

From the LFE REPL:

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

false

false

</syntaxhighlight>

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

dim info$(10,10)

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

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

end function</syntaxhighlight>

=={{header|Little}}==

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

}

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

}</syntaxhighlight>

=={{header|LiveCode}}==

there is a file "input.txt"

there is a folder "docs"

there is a file "/docs/input.txt"</syntaxhighlight>

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

there is a file "input.txt"</syntaxhighlight>

=={{header|Logo}}==

{{works with|UCB Logo}}

show file? "/input.txt

show file? "docs

show file? "/docs</syntaxhighlight>

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

show file? "input.txt</syntaxhighlight>

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

 

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

end

end</syntaxhighlight>

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

</syntaxhighlight>

=={{header|Maple}}==

Exists("input.txt");

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

Exists("/input.txt");

Exists("/docs") and IsDirectory("/docs");</syntaxhighlight>

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

FileExistsQ[wd <> "input.txt"]

DirectoryQ[wd <> "docs"]

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

DirectoryQ["/" <> "docs"]</syntaxhighlight>

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

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

exist('docs','dir')

exist('/docs','dir')</syntaxhighlight>

=={{header|MAXScript}}==

doesFileExist "input.txt"

(getDirectories "docs").count == 1

doesFileExist "\input.txt"

(getDirectories "C:\docs").count == 1</syntaxhighlight>

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

 

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

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

END FileTest.</syntaxhighlight>

=={{header|Nanoquery}}==

 

def exists(fname)

return f.exists()

end</syntaxhighlight>

=={{header|Neko}}==

Check that file/dir exists, in Neko

*/

empty.txt exists as empty file: true

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

=={{header|Nemerle}}==

{{trans|C#}}

using System.IO;

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

WriteLine(Directory.Exists("/docs"));</syntaxhighlight>

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

return

</syntaxhighlight>

=={{header|NewLISP}}==

(if (file? file true)

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

(if (directory? dir)

(println "directory " dir " exists")))</syntaxhighlight>

=={{header|Nim}}==

 

echo fileExists "input.txt"

echo dirExists "docs"

echo dirExists "/docs"</syntaxhighlight>

=={{header|Objeck}}==

use IO;

 

 

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

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

NSLog(@"docs %s", [fm fileExistsAtPath:@"docs"] ? @"exists" : @"doesn't exist");</syntaxhighlight>

 

=={{header|OCaml}}==

Sys.file_exists "docs";;

Sys.file_exists "/input.txt";;

Sys.file_exists "/docs";;</syntaxhighlight>

=={{header|ooRexx}}==

* exists(filespec)

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

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

Return 0</syntaxhighlight>

=={{header|Oz}}==

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

in

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

{Show {Path.exists "/input.txt"}}</syntaxhighlight>

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

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

trap(,"does not exist",read("c:\\dirname\\nul");"exists")</syntaxhighlight>

 

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

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

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

=={{header|Phix}}==

{{libheader|Phix/basics}}

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

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

directory /Program Files (x86) exists.

</pre>

=={{header|Phixmonti}}==

"Hallo !" over fputs

fclose

"fou.bar" "r" fopen

dup 0 < if "Could not open 'foo.bar' for reading" print drop else fclose endif</syntaxhighlight>

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

if (file_exists('/docs' )) echo 'docs is over there in the root dir';</syntaxhighlight>

=={{header|PicoLisp}}==

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

(prinl "File doesn't exist") )

(NIL "Directory exists") ) ) )

</syntaxhighlight>

=={{header|Pike}}==

 

int main(){

}

}</syntaxhighlight>

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

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

* 20.10.2013 Walter Pachl

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

Bdos Err on A: Select

</pre>

 

=={{header|Pop11}}==

 

sys_file_exists('/input.txt') =>

sys_file_exists('docs') =>

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

 

Users can easily define special cases of the general procedure.

=={{header|PowerShell}}==

 

write-host "File input exist"

}

write-host "File input doesn't exist"

}</syntaxhighlight>

=={{header|Prolog}}==

 

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

 

 

exists_file('input.txt'),

 

</syntaxhighlight>

=={{header|PureBasic}}==

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

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

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

EndIf </syntaxhighlight>

=={{header|Python}}==

 

 

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

 

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

PRINT FILEEXISTS("\input.txt")</syntaxhighlight>

=={{header|R}}==

file.exists("/input.txt")

file.exists("docs")

This works with special names:

 

=={{header|Racket}}==

 

#lang racket

 

(file-exists? "docs")))

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

my $path = "/etc/passwd";

say $path.IO.e ?? "Exists" !! "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; # same

</syntaxhighlight>

=={{header|Raven}}==

 

'/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</syntaxhighlight>

=={{header|REBOL}}==

exists? %docs/

 

exists? %/input.txt

exists? %/docs/</syntaxhighlight>

=={{header|Red}}==

exists? %docs/

exists? %/c/input.txt

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

== true</syntaxhighlight>

=={{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).*/

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

RETURN 1

</syntaxhighlight>

=={{header|Ring}}==

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

see aFile

else see " doesn't exist" + nl ok

</syntaxhighlight>

=={{header|RLaB}}==

 

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

>> isdir("docs")

0

0

</syntaxhighlight>

 

=={{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 isDir() = 0 then print "This is a directory"

</syntaxhighlight>

=={{header|Rust}}==

 

fn main() {

}

</syntaxhighlight>

=={{header|Scala}}==

 

object FileExistsTest extends App {

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

}</syntaxhighlight>

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

end func;</syntaxhighlight>

=={{header|SenseTalk}}==

put file "input.txt" exists

put folder "docs" exists

put there is a folder "/docs"

</syntaxhighlight>

=={{header|Sidef}}==

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

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

say (Dir.root + %d'docs' -> is_dir);</syntaxhighlight>

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

(Directory newNamed: '/docs') exists</syntaxhighlight>

=={{header|Smalltalk}}==

 

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

 

(FileDirectory on: 'c:\') directoryExists: 'docs'.</syntaxhighlight>

 

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", []);

OS.FileSys.access ("/docs", []);</syntaxhighlight>

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

}

}</syntaxhighlight>

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

" /docs" exists? .</syntaxhighlight>

=={{header|True BASIC}}==

WHEN EXCEPTION IN

OPEN #1: NAME f$

CALL opener (f$)

END</syntaxhighlight>

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

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

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

echo "$d is a directory? $r"

done</syntaxhighlight>

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

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

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

foreach (string f in files) {

}</syntaxhighlight>

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;

}</syntaxhighlight>

=={{header|VBA}}==

 

Option Explicit

 

End Function

</syntaxhighlight>

=={{header|VBScript}}==

 

 

Function FileExists(strFile)

 

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

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

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

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

</syntaxhighlight>

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

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

"file exists", "file doesn't exists"))</syntaxhighlight>

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

module main

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

Attempting to open a non-existent file or directory will cause an error.

A zero-length file is detected as existing.

int FD; \file descriptor

[Trap(false); \prevent errors from aborting program

if GetErr then Text(0, "/dir doesn't exist^m^j");

]</syntaxhighlight>

=={{header|Yabasic}}==

print #1 "Hallo !"

close #1

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

</syntaxhighlight>

=={{header|zkl}}==

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

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

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

</syntaxhighlight>

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

{{omit from|HTML}}

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