Rename a file: Difference between revisions

{{trans|Python}}

fs:rename(‘docs’, ‘mydocs’)

fs:rename(fs:path:sep‘input.txt’, fs:path:sep‘output.txt’)

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

The attached result has been obtained under DOS 2.5.

{{libheader|Action! Tool Kit}}

PROC Dir(CHAR ARRAY filter)

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

Dir(filter)

{{out}}

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

=={{header|Ada}}==

...

Rename ("input.txt", "output.txt");

Rename ("docs", "mydocs");

Rename ("/input.txt", "/output.txt");

The behavior depends on the concrete [[OS | operating system]] regarding:

* file name encoding issues;

<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - ''get directory'' and'' grep in string'' not available in any library ... yet}} -->

Note: <tt>reidf</tt> does not appear to be included in [[ALGOL 68G]]. Also note that file names would be Operating System dependent.

PROC rename = (STRING source name, dest name)INT:

BEGIN

rename("docs", "mydocs");

rename("/docs", "/mydocs")

=={{header|Arturo}}==

fileTo: "output.txt"

docsFrom: "docs"

rename.directory join.path ["/" docsFrom]

=={{header|AutoHotkey}}==

=={{header|AutoIt}}==

=={{header|AWK}}==

Awk allows to call operating system commands with the ''system()'' function. However, the awk script won't get its output, only the return code. But this task is simple enough for the trivial implementation to work:

$ awk 'BEGIN{system("mv docs mydocs")}'

$ awk 'BEGIN{system("mv /input.txt /output.txt")}'

=={{header|BaCon}}==

RENAME "/input.txt" TO "/output.txt"

RENAME "docs" TO "mydocs"

RENAME "/docs" TO "/mydocs"

=={{header|BASIC}}==

NAME "\input.txt" AS "\output.txt"

NAME "docs" AS "mydocs"

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

Apple DOS 3.3 has a flat filesystem with no concept of directories. DOS commands such as RENAME are run directly from the Applesoft prompt but are not technically part of Applesoft BASIC. Thus, attempting to add this line to a program and run it results in a syntax error on that line.

To use a DOS command from a program, use the BASIC statement PRINT followed by CHR$(4) and the string containing the DOS command.

Apple ProDOS does have directories. To change the current working directory to the "root" directory, issue a PREFIX / command.

20 PRINT CHR$ (4)"RENAME DOCS,MYDOCS"

30 PRINT CHR$ (4)"PREFIX /"

40 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"

==={{header|Commodore BASIC}}===

'''Works with''' Commodore BASIC V2.0 as follows:

'''Works with''' Commodore BASIC 3.5 and above as follows:

==={{header|ZX Spectrum Basic}}===

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

ren \input.txt output.txt

ren docs mydocs

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

{{works with|BBC BASIC for Windows}}

When the file or directory names are known as constants at 'compile time':

*RENAME \input.txt \output.txt

*RENAME docs. mydocs.

When the file or directory names are known only at run time:

OSCLI "RENAME \input.txt \output.txt"

OSCLI "RENAME docs. mydocs."

=={{header|Bracmat}}==

ren$(docs.mydocs) { No quotes needed: names don't contain dots or colons. }

ren$("d:\\input.txt"."d:\\output.txt") { Backslash is escape character, so we need to escape it. }

ren$(@"d:\docs".@"d:\mydocs") { @ used as syntactic sugar as in C# for inhibiting escape. }

=={{header|C}}==

int main()

rename("/docs", "/mydocs");

return 0;

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

using System.IO;

Directory.Move(@"\docs",@"\mydocs");

}

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

{{trans|C}}

int main()

std::rename("/docs", "/mydocs");

return 0;

{{libheader|Boost}}

compiled with g++ -lboost_system -lboost_filesystem

int main()

boost::filesystem::path("/mydocs"));*/

return 0;

=={{header|Clipper}}==

or

RENAME input.txt TO output.txt

FRename("\input.txt","\output.txt")

or

Clipper has no it's own functions to rename a directory, it is possible, though, to write appropriate code in '''C''' and link it to Clipper application, using the Clipper's Extend system.

=={{header|Clojure}}==

(.renameTo (File. "input.txt") (File. "output.txt"))

(.renameTo

(File. (str (File/separator) "docs"))

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

<code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_rn_fil.htm rename-file]</code>

(rename-file "docs" "mydocs")

(rename-file "/input.txt" "/output.txt")

=={{header|D}}==

std.file.rename("/input.txt","/output.txt");

std.file.rename("docs","mydocs");

=={{header|DBL}}==

.IFDEF UNIX

XCALL SPAWN ("mv docs mydocs")

.IFDEF VMS

XCALL SPAWN ("rename docs.dir mydocs.dir")

=={{header|DCL}}==

rename docs.dir mydocs.dir

rename [000000]input.txt [000000]output.txt

=={{header|Delphi}}==

{$APPTYPE CONSOLE}

SysUtils.RenameFile('docs', 'MyDocs');

SysUtils.RenameFile('\docs', '\MyDocs');

=={{header|E}}==

where["input.txt"].renameTo(where["output.txt"], null)

where["docs"].renameTo(where["mydocs"], null)

=={{header|Elixir}}==

File.rename "docs", "mydocs"

File.rename "/input.txt", "/output.txt"

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

(rename-file "/input.txt" "/output.txt")

(rename-file "docs" "mydocs")

This can also be done interactively with <code>M-x rename-file</code>. Programmatically the default is to throw an error if the new name already exists but the "ok-if-already-exists" parameter can either forcibly overwrite or query the user. Query is the default interactively.

=={{header|Erlang}}==

file:rename("input.txt","output.txt"),

file:rename( "docs", "mydocs" ),

file:rename( "/input.txt", "/output.txt" ),

file:rename( "/docs", "/mydocs" ).

=={{header|ERRE}}==

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

{{trans|C#}}

[<EntryPoint>]

Directory.Move("docs","mydocs")

Directory.Move(@"\docs",@"\mydocs")

=={{header|Factor}}==

[ "input.txt" "output.txt" move-file "docs" "mydocs" move-file ] with-directory

=={{header|Fantom}}==

class Rename

{

}

}

=={{header|Forth}}==

=={{header|Fortran}}==

Using UNIX extensions to '''Fortran 77''' (see e.g. [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Rename-Intrinsic-_0028subroutine_0029.html#Rename-Intrinsic-_0028subroutine_0029 g77 manual]) :

CALL RENAME('input.txt','output.txt')

CALL RENAME('docs','mydocs')

CALL RENAME('/input.txt','/output.txt')

CALL RENAME('/docs','/mydocs')

=={{header|FreeBASIC}}==

Dim result As Long

End If

=={{header|Go}}==

import "os"

os.Rename("/input.txt", "/output.txt")

os.Rename("/docs", "/mydocs")

=={{header|Groovy}}==

Using File

['.', ''].each { dir ->

new File("$dir/$src").renameTo(new File("$dir/$dst"))

}

Using Ant

['.', ''].each { dir ->

new AntBuilder().move(file:"$dir/$src", toFile:"$dir/$dst")

}

=={{header|Harbour}}==

// or

RENAME input.txt TO output.txt

Harbour has no it's own functions to rename a directory, it is possible, though, to write appropriate code in '''C''' and link it to Harbour application, using the Harbour's Extend system.

=={{header|Haskell}}==

import System.Directory

renameDirectory "docs" "mydocs"

renameFile "/input.txt" "/output.txt"

=={{header|HicEst}}==

SYSTEM(DIR='E:\HicEst\Rosetta')

WRITE(FIle='.\docs', REName='.\mydocs')

WRITE(FIle='\input.txt', REName='\output.txt')

SYSTEM(DIR='\')

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

Icon supports 'rename' for files only.

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

rename(f := dir || "docs", dir || "mydocs") |stop("failure for directory rename ",f)

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

=={{header|Io}}==

// rename file in current directory

f := File with("input.txt")

d := Directory with("/docs")

d moveTo("/mydocs")

=={{header|J}}==

The following will work on Windows, Linux and Macs:

if. x -: y do. return. end.

if. IFUNIX do.

'kernel32 MoveFileA i *c *c' 15!:0 y;x

end.

Useage:

'/output.txt' frename '/input.txt'

'mydocs' frename 'docs'

=={{header|Java}}==

public class FileRenameTest {

public static boolean renameFile(String oldname, String newname) {

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

}

=={{header|JavaScript}}==

{{works with|JScript}}

Throws an error if the destination file/folder exists.

fso.MoveFile("input.txt", "output.txt")

fso.MoveFile("c:/input.txt", "c:/output.txt")

fso.MoveFolder("docs", "mydocs")

=={{header|Joy}}==

"input.txt" "output.txt" frename

"/input.txt" "/output.txt" frename

=={{header|Jsish}}==

try { File.rename('input.txt', 'output.txt', false); } catch (str) { puts(str); }

try { File.rename('docs', 'mydocs', false); } catch (str) { puts(str); }

=={{header|Julia}}==

mv("input.txt", "output.txt")

mv("docs", "mydocs")

mv("/input.txt", "/output.txt")

=={{header|Kotlin}}==

/* testing on Windows 10 which needs administrative privileges

println("${oldPaths[i]} could not be renamed")

}

{{out}}

=={{header|Lasso}}==

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

#f->moveTo('output.txt')

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

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

=={{header|LFE}}==

(file:rename "input.txt" "output.txt")

(file:rename "docs" "mydocs")

(file:rename "/input.txt" "/output.txt")

(file:rename "/docs" "/mydocs")

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

nomainwin

run "cmd.exe /c ren C:\docs mydocs", HIDE

=={{header|LiveCode}}==

rename folder "docs" to "mydocs"

rename file "/input.txt" to "/output.txt"

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

([[wp:AMSDOS|AMSDOS]] RSX command, therefore prefixed with a vertical bar. Also, there are no subdirectories in AMSDOS, so there is no way to do the other tests.)

=={{header|Lua}}==

os.rename( "/input.txt", "/output.txt" )

os.rename( "docs", "mydocs" )

=={{header|M2000 Interpreter}}==

To delete a file we have to use Dos shell,so this can be done using Dos command

Module checkit {

Document A$={Alfa, beta}

}

checkit

=={{header|Maple}}==

Rename( "input.txt", "output.txt" );

Rename( "docs", "mydocs" );

Rename( "/input.txt", "/output.txt" ); # assuming permissions in /

Rename( "/docs", "/mydocs" ) # assuming permissions in /

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

RenameFile["input.txt", "output.txt"]

RenameDirectory["docs", "mydocs"]

SetDirectory[$RootDirectory]

RenameFile["input.txt", "output.txt"]

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

=={{header|MAXScript}}==

MAXScript has no folder rename method

renameFile "input.txt" "output.txt"

-- Root

=={{header|Mercury}}==

:- interface.

io.write_string(Stderr, io.error_message(Error), !IO),

io.nl(Stderr, !IO),

=={{header|MUMPS}}==

<p>ANSI MUMPS doesn't allow access to the operating system except possibly through the View command and $View function, both of which are implementation specific. Intersystems' Caché does allow you to create processes with the $ZF function, and if the permissions for the Caché process allow it you can perform operating system commands.</p>

<p>In Cache on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:</p>

S X=$ZF(-1,"rename input.txt output.txt")

S X=$ZF(-1,"rename docs.dir mydocs.dir")

;Root of current device

S X=$ZF(-1,"rename [000000]input.txt [000000]output.txt")

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

return

=={{header|NewLISP}}==

(rename-file "./docs" "./mydocs")

(rename-file "/input.txt" "/output.txt")

=={{header|Nim}}==

moveFile("input.txt", "output.txt")

moveFile(DirSep & "input.txt", DirSep & "output.txt")

=={{header|Objeck}}==

use IO;

bundle Default {

}

}

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

{{works with|GNUstep}}

// Pre-OS X 10.5

// OS X 10.5+

[fm moveItemAtPath:@"input.txt" toPath:@"output.txt" error:NULL];

=={{header|OCaml}}==

let () =

Sys.rename "input.txt" "output.txt";

Sys.rename "docs" "mydocs";

Sys.rename "/input.txt" "/output.txt";

=={{header|Octave}}==

rename('docs','mydocs');

rename('input.txt','/output.txt');

rename('/docs','/mydocs');

=={{header|OpenEdge/Progress}}==

OS-RENAME "docs" "mydocs".

OS-RENAME "/input.txt" "/output.txt".

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

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

system("mv /input.txt /output.txt");

system("mv docs mydocs");

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

Alternatively it's possible to bind rename() system call to a new function:

=={{header|Pascal}}==

f : file ; // Untyped file

begin

Rename(f,'\mydocs');

=={{header|Perl}}==

use File::Spec::Functions qw(catfile rootdir);

# here

# root dir

move (catfile rootdir, 'input.txt'), (catfile rootdir, 'output.txt');

The core <code>rename($oldfile,$newfile)</code> can rename a file within a directory, but has the usual limitations of the <code>rename()</code> system call or C library function, which means generally not working across filesystems, and perhaps not working to rename directories. <code>move()</code> does a copy and delete when necessary.

Windows now makes it fairly difficult to rename files in the root directory, even by hand.

Output is 0 for success, 1 for failure.

<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: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"input.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"output.txt"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"C:\\Copy.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Copy.xxx"</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"C:\\docs"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"C:\\mydocs"</span><span style="color: #0000FF;">)</span>

=={{header|Phixmonti}}==

var com var slash

com "docs mydocs" chain cmd

com slash chain "input.txt " chain slash chain "output.txt" chain cmd

=={{header|PHP}}==

rename('input.txt', 'output.txt');

rename('docs', 'mydocs');

rename('/input.txt', '/output.txt');

rename('/docs', '/mydocs');

=={{header|PicoLisp}}==

(call 'mv "docs" "mydocs")

(call 'mv "/input.txt" "/output.txt")

=={{header|Pike}}==

mv("input.txt", "output.txt");

mv("/input.txt", "/output.txt");

mv("docs", "mydocs");

mv("/docs", "/mydocs");

=={{header|Pop11}}==

sys_file_move('docs', 'mydocs');

sys_file_move('/inputs.txt', '/output.txt');

Note that notion of the root of filesystem is Unix specific, so above we

=={{header|PowerShell}}==

# The Rename-item has the alias ren

=={{header|Processing}}==

boolean sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt"));

boolean sketchfold = rename(sketchPath("docs"), sketchPath("mydocs"));

boolean success = file.renameTo(file2);

return success;

===Processing Python mode===

def setup():

# Rename file (or directory)

success = file.renameTo(file2)

=={{header|ProDOS}}==

=={{header|PureBasic}}==

RenameFile("docs\", "mydocs\")

RenameFile("/input.txt","/output.txt")

=={{header|Python}}==

os.rename("input.txt", "output.txt")

os.rename(os.sep + "input.txt", os.sep + "output.txt")

Or the alternative:

shutil.move("input.txt", "output.txt")

shutil.move("/input.txt", "/output.txt")

=={{header|Quackery}}==

Quackery does not have a full set of file and directory handling words, so we pass a script string to the host language. A word could be defined in Quackery to construct the appropriate script string; this is the "once-off" version.

import os

if os.path.exists('input.txt'):

if os.path.exists('/docs'):

os.rename('/docs', '/mydocs')

=={{header|Racket}}==

#lang racket

(rename-file-or-directory (build-path root "docs")

(build-path root "mydocs"))

=={{header|Raku}}==

(formerly Perl 6)

rename 'docs', 'mydocs';

rename '/input.txt', '/output.txt';

=={{header|Raven}}==

=={{header|REALbasic}}==

This ''should'' work regardless of what OS it's running under (but untested under [[Mac OS]]).

Dim f As FolderItem, r As FolderItem

Return what

End If

=={{header|REBOL}}==

rename %docs/ %mydocs/

rename ftp://username:password@ftp.site.com/www/input.txt %output.txt

rename ftp://username:password@ftp.site.com/www/docs/ %mydocs/

=={{header|REXX}}==

===error messages shown===

trace off /*suppress error messages, bad RC*/

'CD' "\" /*for 2nd pass, change──►root dir*/

end /*2*/

===error messages suppressed===

trace off /*suppress error messages, bad RC*/

$ = '2> NUL' /*used to suppress error messages*/

'CD' "\" $ /*for 2nd pass, change──►root dir*/

end /*2*/

=={{header|Ring}}==

rename("input.txt", "output.txt")

rename("docs", "mydocs")

rename("/input.txt", "/output.txt")

rename("/docs", "/mydocs")

=={{header|Ruby}}==

File.rename('/input.txt', '/output.txt')

File.rename('docs', 'mydocs')

With 'fileutils' from the standard library: The <tt>FileUtils#move</tt> method has some more flexibility than the core <tt>File#rename</tt> method (not really demonstrated here).

moves = { "input.txt" => "output.txt", "/input.txt" => "/output.txt", "docs" => "mydocs","/docs" => "/mydocs"}

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

RB has no direct command. You Shell out to windows or unix.

a$ = shell$("RENAME docs mydocs")

a$ = shell$("RENAME \input.txt \output.txt")

=={{header|Rust}}==

use std::fs;

fs::rename("/docs", "/mydocs").ok().expect(err);

}

=={{header|Scala}}==

{{libheader|Scala}}

===Straight forward===

import java.io.File

"/tmp/mydir" renameTo "/tmp/anotherdir"

}

===Alternative===

object Rename1 {

def main(args: Array[String]) {

}

}

=={{header|Scheme}}==

{{works with|Chicken Scheme}}

{{works with|Guile}}

(rename-file "docs" "mydocs")

(rename-file "/input.txt" "/output.txt")

=={{header|Seed7}}==

when it is started by a normal user.

include "osfiles.s7i";

moveFile("/input.txt", "/output.txt");

moveFile("/docs", "/mydocs");

Under Windows each filesystem has its own root.

=={{header|Sidef}}==

File.rename('input.txt', 'output.txt');

File.rename('docs', 'mydocs');

# Root dir

File.rename(Dir.root + %f'input.txt', Dir.root + %f'output.txt');

=={{header|Slate}}==

(File newNamed: '/input.txt') renameTo: '/output.txt'.

(Directory newNamed: 'docs') renameTo: 'mydocs'.

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

File rename: 'docs' to: 'mydocs'.

"as for other example, this works on systems

where the root is / ..."

File rename: '/input.txt' to: '/output.txt'.

{{works with|Smalltalk/X}}

{{works with|VisualWorks Smalltalk}}

'docs' asFilename renameTo: 'mydocs'.

'/input.txt' asFilename renameTo: '/output.txt'.

{{works with|Pharo Smalltalk}}

'docs' asFileReference renameTo: 'mydocs'.

'/input.txt' asFileReference renameTo: '/output.txt'.

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

OS.FileSys.rename {old = "docs", new = "mydocs"};

OS.FileSys.rename {old = "/input.txt", new = "/output.txt"};

=={{header|Stata}}==

Use a '''[http://www.stata.com/help.cgi?shell shell]''' command. The following works on Windows, there are similar commands on other operating systems.

=={{header|Tcl}}==

<i>Assuming</i> that the Bash example shows what is actually meant with this task (one file and one directory here, one file and one directory in the root) and further assuming that this is supposed to be generic (i.e. OS agnostic):

file rename docs mydocs

file rename [file nativename /inputs.txt] [file nativename /output.txt]

Without the need to work on unusual platforms like Mac OS 9, the code could be just:

file rename docs mydocs

file rename /inputs.txt /output.txt

=={{header|Toka}}==

" input.txt" " output.txt" rename

" /input.txt" " /output.txt" rename

" docs" " mydocs" rename

=={{header|TorqueScript}}==

fileDelete("Input.txt");

fileCopy(%File, "OtherPath/" @ %File);

fileDelete(%File);

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

- rename file

- rename directory

ERROR/STOP RENAME ("docs","mydocs",-std-)

=={{header|TXR}}==

TXR works with native paths.

;; Windows (MinGW based port)

(rename-path "C:\\input.txt" "C:\\output.txt")

;; Unix; Windows (Cygwin port)

Directories are renamed the same way; <code>input.txt</code> could be a directory.

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

mv /input.txt /output.txt

mv docs mydocs

=={{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_Rename("input.txt", "output.txt")

File_Rename("docs", "mydocs")

// In the root directory

File_Rename("/input.txt", "/output.txt")

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

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

IO.Directory.Move("docs", "mydocs")

IO.File.Move("input.txt", "output.txt")

IO.Path.DirectorySeparatorChar & "mydocs")

IO.File.Move(IO.Path.DirectorySeparatorChar & "input.txt", _

=={{header|Wren}}==

{{libheader|Wren-ioutil}}

Wren-cli does not currently have the ability to rename directories, just files.

FileUtil.move("input.txt", "output.txt")

=={{header|Yabasic}}==

slash$ = "\\" : com$ = "ren "

else

system(com$ + "docs mydocs")

system(com$ + slash$ + "input.txt " + slash$ + "output.txt")

=={{header|Yorick}}==

{{trans|UNIX Shell}}

rename, "/input.txt", "/output.txt";

rename, "docs", "mydocs";

=={{header|zkl}}==