Delete a file: Difference between revisions

 

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

fs:remove_dir(‘docs’)

fs:remove_file(‘/output.txt’)

 

=={{header|8th}}==

"input.txt" f:rm drop

"/input.txt" f:rm drop

"docs" f:rmdir drop

"/docs" f:rmdir drop

The 'drop' removes the result (true or false, indicating success or failure). It is not strictly necessary to do so, but it keeps the stack clean.

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program deleteFic64.s */

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

.include "../includeARM64.inc"

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

The attached result has been obtained under DOS 2.5.

CHAR ARRAY line(255)

BYTE dev=[1]

PrintF("Dir ""%S""%E",filter)

Dir(filter)

{{out}}

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

 

=={{header|Ada}}==

and then

Delete_File ("/input.txt");

Delete_Tree ("docs");

Naming conventions for the file path are [[OS]]-specific. The language does not specify the encoding of the file paths, the directory separators or brackets, the file extension delimiter, the file version delimiter and syntax. The example provided works under [[Linux]] and [[Windows]].

 

=={{header|Aikido}}==

The <code>remove</code> function removes either a file or a directory (the directory must be empty for this to work). Exception is thrown if this fails.

remove ("input.txt")

remove ("/input.txt")

remove ("docs")

remove ("/docs")

 

=={{header|Aime}}==

remove("/input.txt");

remove("docs");

 

=={{header|ALGOL 68}}==

Note: <tt>scratch</tt> does not appear to do anything on [[ALGOL 68G]]. Also note that file names are Operating System dependent.

PROC remove = (STRING file name)INT:

BEGIN

remove("docs");

remove("/docs")

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program deleteFic.s */

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

.include "../affichage.inc"

 

=={{header|Arturo}}==

docs: "docs"

 

 

delete join.path ["/" file]

 

=={{header|AutoHotkey}}==

FileDelete, \input.txt

FileRemoveDir, docs, 1

===with DllCall===

Source: [https://github.com/jNizM/AHK_DllCall_WinAPI/ DeleteFile @github] by jNizM

{

DllCall("Kernel32.dll\DeleteFile", "Str", lpFileName)

}

 

 

=={{header|AWK}}==

Assuming we are on a Unix/Linux or at least Cygwin system:

system("rm /input.txt")

system("rm -rf docs")

 

=={{header|Axe}}==

 

=={{header|BASIC}}==

Some versions of Qbasic may have had a builtin RMDIR command. However this is not documented in the manual, so we use the external MSDOS command in this example.

 

KILL "INPUT.TXT"

KILL "C:\INPUT.TXT"

SHELL "RMDIR /S /Q DIR"

SHELL "RMDIR /S /Q C:\DIR"

 

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

BaCon has a <tt>DELETE</tt> instruction, that accepts <tt>FILE|DIRECTORY|RECURSIVE</tt> options.

 

 

Errors can be caught with the <tt>CATCH GOTO label</tt> instruction (which allows <tt>RESUME</tt> from the labelled code section).

file extensions. Here we delete the file named INPUTTXT from the first microdrive:

 

ERASE "m"; 1; "INPUTTXT"

 

And for disc drive of ZX Spectrum +3:

 

ERASE "a:INPUTTXT"

 

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

If the names are known as constants at compile time:

*DELETE input.txt

*DELETE \input.txt

*RMDIR docs

*RMDIR \docs

If the names are known only at run time:

 

==={{header|IS-BASIC}}===

110 EXT "del input.txt"

120 EXT "del \input.txt"

180 PRINT "*** ";EXSTRING$(EXTYPE)

190 CONTINUE

 

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

rd /s /q docs

 

del \input.txt

 

=={{header|C}}==

ISO C:

 

int main() {

remove("/docs");

return 0;

 

POSIX:

 

int main() {

rmdir("/docs");

return 0;

 

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

using System.IO;

 

}

}

 

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

#include <direct.h>

 

 

return 0;

 

=={{header|Clojure}}==

(.delete (File. "output.txt"))

(.delete (File. "docs"))

 

(.delete (new File (str (File/separator) "output.txt")))

 

=={{header|COBOL}}==

{{works with|Visual COBOL}}

PROGRAM-ID. Delete-Files.

 

ENVIRONMENT DIVISION.

FD Local-File.

01 Local-Record PIC X.

FD Root-File.

01 Root-Record PIC X.

DELETE FILE Local-File

DELETE FILE Root-File

 

 

=={{header|Common Lisp}}==

To delete directories we need an implementation specific extension. In clisp this is ''ext:delete-dir''.

{{works with|CLISP}}

(ext:delete-dir path))

 

(let ((path (make-pathname :directory '(:absolute "docs"))))

 

Or you can use the portability library CL-FAD:

 

{{libheader|CL-FAD}}

 

=={{header|Component Pascal}}==

{{Works with|BlackBox Component Builder}}

VAR

l: Files.Locator;

Files.dir.Delete(l,"xx.txt");

END ...

 

=={{header|D}}==

{{works with|D|2}}

 

void main() {

remove("data.txt");

{{libheader|Tango}}

 

void main() {

remove("docs");

remove("/docs");

 

{{libheader|Tango}}

POSIX:

 

void main() {

rmdir("docs");

rmdir("/docs");

 

=={{header|Delphi}}==

var

CurrentDirectory : String;

RmDir(PChar('c:\docs'));

end;

 

=={{header|E}}==

<file:docs>.delete(null)

<file:///input.txt>.delete(null)

 

=={{header|Elena}}==

ELENA 4.x :

public program()

Directory.assign("\docs").delete();

 

=={{header|Elixir}}==

File.rmdir!("docs")

File.rm!("/input.txt")

 

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

 

=={{header|Erlang}}==

-module(delete).

-export([main/0]).

ok = file:del_dir( "/docs" ),

ok = file:delete( "/input.txt" ).

 

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

 

[<EntryPoint>]

ignore (File.Delete(Path.Combine(path, fileName)))

ignore (Directory.Delete(Path.Combine(path, dirName)))

 

=={{header|Factor}}==

 

=={{header|Forth}}==

There is no means to delete directories in ANS Forth.

 

=={{header|Fortran}}==

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

 

CLOSE (UNIT=5, STATUS="DELETE")

OPEN (UNIT=5, FILE="/input.txt", STATUS="OLD") ! Root directory

=== Intel Fortran on Windows ===

 

Use Intel Fortran bindings to the Win32 API. Here we are using the [https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-deletefilea DeleteFileA] and [https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-removedirectorya RemoveDirectoryA] functions.

 

use kernel32

implicit none

print *, RemoveDirectory("docs")

print *, RemoveDirectory("\docs")

 

=={{header|Free Pascal}}==

All required functions already exist in the RTL’s (run-time library) <code>system</code> unit which is shipped with every FPC (Free Pascal compiler) distribution and automatically included by every program.

const

rootDirectory = '/'; // might have to be altered for other platforms

rmDir(rootDirectory + docsFilename);

Note, depending on the <code>{$IOChecks}</code> compiler switch state, run-time error generation is inserted.

In particular deletion of non-existent files or lack of privileges may cause an abort.

 

=={{header|FreeBASIC}}==

' delete file and empty sub-directory in current directory

Print "Press any key to quit"

Sleep

 

=={{header|Furor}}==

###sysinclude dir.uh

// ===================

2 argv removefile

end

<pre>

Usage: furor removefile.upu filename

</pre>

 

###sysinclude dir.uh

#g argc 3 < { ."Usage: " #s 0 argv print SPACE 1 argv print SPACE ."unnecessary_directory\n" end }

}

end

<pre>

Usage: furor rmdir.upu unnecessary_directory

 

 

 

=={{header|Gambas}}==

 

Kill User.home &/ "input.txt"

'Administrative privileges (sudo) would be required to mess about in Root - I'm not going there!

 

 

=={{header|GAP}}==

RemoveFile("input.txt");

# true

RemoveFile("docs");

 

=={{header|Go}}==

import "os"

 

os.RemoveAll("docs")

os.RemoveAll("/docs")

 

=={{header|Groovy}}==

On most *nix systems, this must be run as sudo for the files in root to be deleted. If you don't have permissions, it will silently fail to delete those files. I would recommend against running anything you find on the internet as sudo.

 

def fsRoot = File.listRoots().first()

 

files.each{

it.directory ? it.deleteDir() : it.delete()

 

=={{header|Haskell}}==

 

import System.Directory

 

removeDirectory "docs"

removeFile "/output.txt"

 

=={{header|HicEst}}==

OPEN (FILE="input.txt", "NEW") ! in current directory = docs

WRITE(FIle="input.txt", DELETE=1) ! no command to DELETE a DIRECTORY in HicEst

SYSTEM(DIR="C:\docs") ! create C:\docs (if not existent), make it current

OPEN (FILE="input.txt", "NEW") ! in current directory = C:\docs

 

=={{header|Icon}} and {{header|Unicon}}==

Icon supports 'remove' for files.

remove(f := dir || "input.txt") |stop("failure for file remove ",f)

rmdir(f := dir || "docs") |stop("failure for directory remove ",f)

}

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

 

=={{header|Io}}==

Directory directoryNamed("docs") remove

RootDir := Directory clone setPath("/")

RootDir fileNamed("input.txt") remove

 

or

Directory with("docs") remove

File with("/input.txt") remove

 

=={{header|J}}==

The J standard library comes with a set of file access utilities.

ferase 'input.txt'

ferase '\input.txt'

 

NB. Or all at once...

 

The function above actually uses a foreign conjunction and defined in the <tt>files</tt> library like so:

NB.*ferase v erases a file

NB. Returns 1 if successful, otherwise _1

 

This means that you can directly erase files and directories without loading the <tt>files</tt> library.

1!:55 <'\input.txt'

1!:55 <'docs'

 

=={{header|Java}}==

 

 

public class FileDeleteTest {

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

}

 

=={{header|JavaScript}}==

{{works with|JScript}}

 

fso.DeleteFile('input.txt');

 

fso.DeleteFolder('docs');

 

or

 

var f;

f = fso.GetFile('input.txt');

f.Delete();

f = fso.GetFolder('c:/docs');

 

{{works with|Node.js}}

Synchronous

Asynchronous

fs.unlink('myfile.txt', ()=>{

console.log("Done!");

 

=={{header|Julia}}==

# Delete a file

rm("input.txt")

# Delete a directory

rm("docs", recursive = true)

 

=={{header|Kotlin}}==

 

/* testing on Windows 10 which needs administrative privileges

println("$path could not be deleted")

}

 

{{out}}

{{libheader|LabVIEW_CWD}}

{{VI solution|LabVIEW_Delete_a_file.png}}

 

=={{header|Lasso}}==

local(f = file('input.txt'))

#f->delete

// directory must be empty before it can be successfully deleted. A failure is generated if the operation fails.

local(d = file('//docs'))

 

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

print DefaultDir$

 

kill "\input.txt"

result=rmdir("\Docs")

 

=={{header|Lingo}}==

 

Delete file "input.txt" in cwd:

fp = xtra("fileIO").new()

fp.openFile("input.txt", 0)

 

Delete file "input.txt" in root of current volume:

pd = the last char of _movie.path -- "\" for win, ":" for mac

_player.itemDelimiter = pd

fp = xtra("fileIO").new()

fp.openFile(vol&pd&"input.txt", 0)

 

Deleting a directory requires a 3rd party xtra, but there are various free xtras that allow this. Here as example usage of BinFile xtra:

 

bx_folder_delete("docs")

 

_player.itemDelimiter = pd

vol = _movie.path.item[1]

 

=={{header|Locomotive Basic}}==

 

([[wp:AMSDOS|AMSDOS]] RSX command, therefore prefixed with a vertical bar. Also, there are no subdirectories in AMSDOS.)

 

{{works with|UCB Logo}}

UCB Logo has no means to delete directories.

 

=={{header|Lua}}==

os.remove("/input.txt")

os.remove("docs")

 

=={{header|Maple}}==

FileTools:-RemoveDirectory("docs");

FileTools:-Remove("/input.txt");

FileTools:-RemoveDirectory("/docs");

 

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

DeleteFile[wd <> "input.txt"]

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

DeleteDirectory[wd <> "docs"]

 

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

 

delete('/input.txt'); % delete file /input.txt

rmdir('docs'); % remove local directory docs

rmdir('/docs'); % remove directory /docs

 

On Unix-Systems:

disp('input.txt removed')

end

if system('rmdir /docs') == 0

disp('/docs removed')

 

=={{header|MAXScript}}==

There's no way to delete folders in MAXScript

deleteFile "input.txt"

-- Root

 

=={{header|Mercury}}==

:- interface.

 

io.remove_file("/input.txt", _, !IO),

io.remove_file("docs", _, !IO),

 

=={{header|Nanoquery}}==

{{trans|Ursa}}

f.delete("input.txt")

f.delete("docs")

f.delete("/input.txt")

 

=={{header|Nemerle}}==

using System.IO;

using System.Console;

when (Directory.Exists(@"\docs")) Directory.Delete(@"\docs");

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

 

return

 

=={{header|NewLISP}}==

(delete-file "/input.txt")

(remove-dir "docs")

 

=={{header|Nim}}==

removeFile("input.txt")

removeFile("/input.txt")

removeDir("docs")

 

=={{header|Objeck}}==

use IO;

 

}

}

 

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

 

 

// Pre-OS X 10.5

[fm removeItemAtPath:@"/input.txt" error:NULL];

[fm removeItemAtPath:@"docs" error:NULL];

 

=={{header|OCaml}}==

 

 

with the Unix library:

Unix.unlink "input.txt";;

Unix.unlink "/input.txt";;

Unix.rmdir "docs";;

 

=={{header|ooRexx}}==

file= 'afile.txt' /*name of a file to be deleted.*/

res=sysFileDelete(file); Say file 'res='res

File= 'bfile.txt' /*name of a file to be deleted.*/

{{out}}

<pre>afile.txt res=0

 

=={{header|Oz}}==

try {OS.unlink Dir#"output.txt"}

catch _ then {System.showInfo "File does not exist."} end

try {OS.rmDir Dir#"docs"}

catch _ then {System.showInfo "Directory does not exist."} end

 

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

GP has no built-in facilities for deleting files, but can use a system call:

system("rm input.txt");

system("rm -rf /docs");

PARI, as usual, has access to all the standard [[#C|C]] methods.

 

=={{header|Perl}}==

 

# here

unlink 'input.txt';

# root dir

unlink catfile rootdir, 'input.txt';

 

'''Without Perl Modules'''

 

=={{header|Phix}}==

output is 0 0 0 0 or 1 1 1 1 or some combination thereof

 

=={{header|PHP}}==

unlink('input.txt');

unlink('/input.txt');

rmdir('docs');

rmdir('/docs');

 

=={{header|PicoLisp}}==

(call 'rmdir "docs")

(call 'rm "/input.txt")

 

=={{header|Pike}}==

rm("input.txt");

rm("/input.txt");

rm("docs");

rm("/docs");

 

=={{header|PowerShell}}==

Remove-Item input.txt

Remove-Item \input.txt # file system root

 

Remove-Item -Recurse docs # recurse for deleting folders including content

 

=={{header|ProDOS}}==

Because input.txt is located inside of "docs" this will delete it when it deletes "docs"

 

=={{header|PureBasic}}==

DeleteDirectory("docs","") ; needs to delete all included files

DeleteFile("/input.txt")

DeleteDirectory("/docs","*.*") ; deletes all files according to a pattern

 

 

=={{header|Python}}==

 

# current directory

os.remove("output.txt")

# root directory

os.remove("/output.txt")

If you wanted to remove a directory and all its contents, recursively, you would do:

 

=={{header|R}}==

file.remove("/input.txt")

 

# directories needs the recursive flag

unlink("docs", recursive = TRUE)

 

The function <tt>unlink</tt> allows wildcards (* and ?)

=={{header|Racket}}==

 

#lang racket

 

(delete-directory "docs")

(delete-directory/files "docs"))

 

=={{header|Raku}}==

(formerly Perl 6)

unlink '/input.txt';

rmdir 'docs';

 

=={{header|Raven}}==

 

'/input.txt' delete

'docs' rmdir

 

=={{header|REBOL}}==

delete %input.txt

delete-dir %docs/

; Root.

delete %/input.txt

 

=={{header|Retro}}==

 

=={{header|REXX}}==

Note that this REXX program will work on the Next family of Microsoft Windows systems as well as DOS &nbsp; (both under Windows in a DOS-prompt window or stand-alone DOS).

trace off /*suppress REXX error messages from DOS*/

aFile= 'input.txt' /*name of a file to be deleted. */

if j==1 then 'CD \' /*make the current dir the root dir.*/

end /* [↑] just do CD \ command once.*/

 

=={{header|Ring}}==

 

remove("output.txt")

system("rmdir docs")

 

=={{header|Ruby}}==

 

Dir.delete("docs")

 

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

kill "input.txt" ' this is where we are

kill "/input.txt" ' this is the root

' ---- delete directory docs ----------

result = rmdir("Docs") ' directory where we are

 

=={{header|Rust}}==

use std::fs::{remove_file,remove_dir};

use std::path::Path;

let _ = writeln!(&mut io::stderr(), "{:?}", error);

process::exit(code)

 

=={{header|Scala}}==

{{libheader|Scala}}

import java.io.File

 

test("directory", "docs")

test("directory", File.separatorChar + "docs" + File.separatorChar)

 

=={{header|Scheme}}==

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

 

=={{header|Seed7}}==

The library [http://seed7.sourceforge.net/libraries/osfiles.htm osfiles.s7i] provides the functions [http://seed7.sourceforge.net/libraries/osfiles.htm#removeFile%28in_string%29 removeFile] and [http://seed7.sourceforge.net/libraries/osfiles.htm#removeTree%28in_string%29 removeTree]. RemoveFile removes a file of any type unless it is a directory that is not empty. RemoveTree remove a file of any type inclusive a directory tree. Note that removeFile and removeTree fail with the exception [http://seed7.sourceforge.net/manual/errors.htm#FILE_ERROR FILE_ERROR] when the file does not exist.

include "osfiles.s7i";

 

removeTree("docs");

removeTree("/docs");

 

=={{header|SenseTalk}}==

delete file "input.txt"

delete folder "docs"

delete file "/input.txt"

delete folder "/docs"

 

=={{header|Sidef}}==

%f'input.txt' -> delete;

%d'docs' -> delete;

# root dir

Dir.root + %f'input.txt' -> delete;

 

=={{header|Slate}}==

(It will succeed deleting the directory if it is empty)

 

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

(Directory newNamed: 'docs') delete.

 

Also:

 

(Directory current / 'input.txt') delete.

 

=={{header|Smalltalk}}==

(It will succeed deleting the directory if it is empty)

 

File remove: 'docs'.

File remove: '/input.txt'.

 

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

 

OS.FileSys.remove "/input.txt";

OS.FileSys.rmDir "docs";

 

=={{header|Stata}}==

 

=={{header|Tcl}}==

 

 

# preserve directory if non-empty

 

# delete even if non-empty

 

=={{header|Toka}}==

 

" docs" remove

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

- delete file

- delete directory

SET status = DELETE ("docs",-std-)

 

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

rm input.txt

rm -rf /docs

 

=={{header|Ursa}}==

f.delete "input.txt"

f.delete "docs"

f.delete "/input.txt"

 

=={{header|VAX Assembly}}==

64 2E 73 63 6F 64 2C 3B 74 78 74 2E 000C

3B 72 69 0018

0071 12 .end main

 

 

=={{header|VBA}}==

 

Sub DeleteFileOrDirectory()

'delete Directory

RmDir myPath

 

=={{header|VBScript}}==

 

oFSO.DeleteFile "input.txt"

fld.Delete

 

 

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

File_Delete("input.txt", OK)

File_Rmdir("docs")

// In the root directory

File_Delete("/input.txt", OK)

 

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

 

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

IO.Directory.Delete("docs")

IO.Directory.Delete("docs", True) 'also delete files and sub-directories

'Root, platform independent

IO.Directory.Delete(IO.Path.DirectorySeparatorChar & "docs")

 

=={{header|Wren}}==

 

Wren does not currently support the removal of directories.

 

File.delete("input.txt")

 

// check it worked

 

{{out}}

{{works with|NASM|Linux}}

 

;syscall numbers for readability. :]

%define sys_rmdir 40

err_msg db "Something went wrong! :[",0xa

err_len equ $-err_msg

 

=={{header|Yorick}}==

Yorick does not have a built-in function to recursively delete a directory; the rmdir function only works on empty directories.

remove, "/input.txt";

rmdir, "docs";

 

=={{header|zkl}}==

zkl doesn't have built ins to delete files or directories but you can let a shell do it:

0

zkl: System.cmd((System.isWindows and "del" or "unlink") + " /input.txt")

zkl: System.cmd("rm -r /docs")

rm: cannot remove ‘/docs’: No such file or directory

 

{{omit from|Befunge}} <!-- No filesystem support -->

{{omit from|HTML}}

{{omit from|Openscad}}