Rename a file: Difference between revisions
(PascalABC.NET) |
|||
(33 intermediate revisions by 21 users not shown) | |||
Line 15: | Line 15: | ||
sufficient permissions in the filesystem root.) |
sufficient permissions in the filesystem root.) |
||
<br><br> |
<br><br> |
||
=={{header|11l}}== |
|||
{{trans|Python}} |
|||
<syntaxhighlight lang="11l">fs:rename(‘input.txt’, ‘output.txt’) |
|||
fs:rename(‘docs’, ‘mydocs’) |
|||
fs:rename(fs:path:sep‘input.txt’, fs:path:sep‘output.txt’) |
|||
fs:rename(fs:path:sep‘docs’, fs:path:sep‘mydocs’)</syntaxhighlight> |
|||
=={{header|Action!}}== |
|||
The attached result has been obtained under DOS 2.5. |
|||
{{libheader|Action! Tool Kit}} |
|||
<syntaxhighlight lang="action!">INCLUDE "D2:IO.ACT" ;from the Action! Tool Kit |
|||
PROC Dir(CHAR ARRAY filter) |
|||
BYTE dev=[1] |
|||
CHAR ARRAY line(255) |
|||
Close(dev) |
|||
Open(dev,filter,6) |
|||
DO |
|||
InputSD(dev,line) |
|||
PrintE(line) |
|||
IF line(0)=0 THEN |
|||
EXIT |
|||
FI |
|||
OD |
|||
Close(dev) |
|||
RETURN |
|||
PROC Main() |
|||
CHAR ARRAY filter="D:*.*", |
|||
cmd="D:INPUT.TXT OUTPUT.TXT" |
|||
Put(125) PutE() ;clear screen |
|||
PrintF("Dir ""%S""%E",filter) |
|||
Dir(filter) |
|||
PrintF("Rename ""%S""%E%E",cmd) |
|||
Rename(cmd) |
|||
PrintF("Dir ""%S""%E",filter) |
|||
Dir(filter) |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Rename_a_file.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
Dir "D:*.*" |
|||
DOS SYS 037 |
|||
DUP SYS 042 |
|||
INPUT TXT 011 |
|||
617 FREE SECTORS |
|||
Rename "D:INPUT.TXT OUTPUT.TXT" |
|||
Dir "D:*.*" |
|||
DOS SYS 037 |
|||
DUP SYS 042 |
|||
OUTPUT TXT 011 |
|||
617 FREE SECTORS |
|||
</pre> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">with Ada.Directories; use Ada.Directories; |
||
... |
... |
||
Rename ("input.txt", "output.txt"); |
Rename ("input.txt", "output.txt"); |
||
Rename ("docs", "mydocs"); |
Rename ("docs", "mydocs"); |
||
Rename ("/input.txt", "/output.txt"); |
Rename ("/input.txt", "/output.txt"); |
||
Rename ("/docs", "/mydocs");</ |
Rename ("/docs", "/mydocs");</syntaxhighlight> |
||
The behavior depends on the concrete [[OS | operating system]] regarding: |
The behavior depends on the concrete [[OS | operating system]] regarding: |
||
* file name encoding issues; |
* file name encoding issues; |
||
Line 35: | Line 98: | ||
<!-- {{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}} --> |
<!-- {{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. |
Note: <tt>reidf</tt> does not appear to be included in [[ALGOL 68G]]. Also note that file names would be Operating System dependent. |
||
< |
<syntaxhighlight lang="algol68">main:( |
||
PROC rename = (STRING source name, dest name)INT: |
PROC rename = (STRING source name, dest name)INT: |
||
BEGIN |
BEGIN |
||
Line 56: | Line 119: | ||
rename("docs", "mydocs"); |
rename("docs", "mydocs"); |
||
rename("/docs", "/mydocs") |
rename("/docs", "/mydocs") |
||
)</ |
)</syntaxhighlight> |
||
=={{header| |
=={{header|Arturo}}== |
||
<syntaxhighlight lang="rebol">fileFrom: "input.txt" |
|||
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: |
|||
fileTo: "output.txt" |
|||
docsFrom: "docs" |
|||
$ awk 'BEGIN{system("mv docs mydocs")}' |
|||
docsTo: "mydocs" |
|||
$ awk 'BEGIN{system("mv /input.txt /output.txt")}' |
|||
$ awk 'BEGIN{system("mv docs mydocs")}'</lang> |
|||
rename fileFrom fileTo |
|||
rename.directory docsFrom docsTo |
|||
rename join.path ["/" fileFrom] |
|||
join.path ["/" fileTo] |
|||
rename.directory join.path ["/" docsFrom] |
|||
join.path ["/" docsTo]</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
<lang |
<syntaxhighlight lang="autohotkey">FileMove, oldname, newname</syntaxhighlight> |
||
=={{header|AutoIt}}== |
=={{header|AutoIt}}== |
||
Line 73: | Line 144: | ||
DirMove("docs", "mydocs") |
DirMove("docs", "mydocs") |
||
DirMove("\docs", "\mydocs") |
DirMove("\docs", "\mydocs") |
||
=={{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: |
|||
<syntaxhighlight lang="awk">$ awk 'BEGIN{system("mv input.txt output.txt")}' |
|||
$ awk 'BEGIN{system("mv docs mydocs")}' |
|||
$ awk 'BEGIN{system("mv /input.txt /output.txt")}' |
|||
$ awk 'BEGIN{system("mv docs mydocs")}'</syntaxhighlight> |
|||
=={{header|BaCon}}== |
=={{header|BaCon}}== |
||
< |
<syntaxhighlight lang="freebasic">RENAME "input.txt" TO "output.txt" |
||
RENAME "/input.txt" TO "/output.txt" |
RENAME "/input.txt" TO "/output.txt" |
||
RENAME "docs" TO "mydocs" |
RENAME "docs" TO "mydocs" |
||
RENAME "/docs" TO "/mydocs" |
RENAME "/docs" TO "/mydocs" |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
< |
<syntaxhighlight lang="qbasic">NAME "input.txt" AS "output.txt" |
||
NAME "\input.txt" AS "\output.txt" |
NAME "\input.txt" AS "\output.txt" |
||
NAME "docs" AS "mydocs" |
NAME "docs" AS "mydocs" |
||
NAME "\docs" AS "\mydocs"</ |
NAME "\docs" AS "\mydocs"</syntaxhighlight> |
||
==={{header|Applesoft BASIC}}=== |
==={{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. |
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. |
||
<lang |
<syntaxhighlight lang="basic">RENAME INPUT.TXT,OUTPUT.TXT</syntaxhighlight> |
||
To use a DOS command from a program, use the BASIC statement PRINT followed by CHR$(4) and the string containing the DOS command. |
To use a DOS command from a program, use the BASIC statement PRINT followed by CHR$(4) and the string containing the DOS command. |
||
< |
<syntaxhighlight lang="basic">10 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"</syntaxhighlight> |
||
Apple ProDOS does have directories. To change the current working directory to the "root" directory, issue a PREFIX / command. |
Apple ProDOS does have directories. To change the current working directory to the "root" directory, issue a PREFIX / command. |
||
< |
<syntaxhighlight lang="basic">10 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT" |
||
20 PRINT CHR$ (4)"RENAME DOCS,MYDOCS" |
20 PRINT CHR$ (4)"RENAME DOCS,MYDOCS" |
||
30 PRINT CHR$ (4)"PREFIX /" |
30 PRINT CHR$ (4)"PREFIX /" |
||
40 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT" |
40 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT" |
||
50 PRINT CHR$ (4)"RENAME DOCS,MYDOCS"</ |
50 PRINT CHR$ (4)"RENAME DOCS,MYDOCS"</syntaxhighlight> |
||
==={{header|Commodore BASIC}}=== |
|||
'''Works with''' Commodore BASIC V2.0 as follows: |
|||
<syntaxhighlight lang="basic">OPEN 15,<Device>,15,"R<DRIVE>:FilenameOLD=FilenameNEW":CLOSE 15</syntaxhighlight> |
|||
'''Works with''' Commodore BASIC 3.5 and above as follows: |
|||
<syntaxhighlight lang="basic">RENAME <FilenameOLD>[,D<DRIVE>] TO <FilenameNEW> [ON U<Deviceadress>]</syntaxhighlight> |
|||
==={{header|ZX Spectrum Basic}}=== |
==={{header|ZX Spectrum Basic}}=== |
||
Line 108: | Line 194: | ||
=={{header|Batch File}}== |
=={{header|Batch File}}== |
||
< |
<syntaxhighlight lang="dos">ren input.txt output.txt |
||
ren \input.txt output.txt |
ren \input.txt output.txt |
||
ren docs mydocs |
ren docs mydocs |
||
ren \docs mydocs</ |
ren \docs mydocs</syntaxhighlight> |
||
=={{header|BBC BASIC}}== |
=={{header|BBC BASIC}}== |
||
{{works with|BBC BASIC for Windows}} |
{{works with|BBC BASIC for Windows}} |
||
When the file or directory names are known as constants at 'compile time': |
When the file or directory names are known as constants at 'compile time': |
||
< |
<syntaxhighlight lang="bbcbasic"> *RENAME input.txt output.txt |
||
*RENAME \input.txt \output.txt |
*RENAME \input.txt \output.txt |
||
*RENAME docs. mydocs. |
*RENAME docs. mydocs. |
||
*RENAME \docs. \mydocs.</ |
*RENAME \docs. \mydocs.</syntaxhighlight> |
||
When the file or directory names are known only at run time: |
When the file or directory names are known only at run time: |
||
< |
<syntaxhighlight lang="bbcbasic"> OSCLI "RENAME input.txt output.txt" |
||
OSCLI "RENAME \input.txt \output.txt" |
OSCLI "RENAME \input.txt \output.txt" |
||
OSCLI "RENAME docs. mydocs." |
OSCLI "RENAME docs. mydocs." |
||
OSCLI "RENAME \docs. \mydocs."</ |
OSCLI "RENAME \docs. \mydocs."</syntaxhighlight> |
||
=={{header|Bracmat}}== |
=={{header|Bracmat}}== |
||
< |
<syntaxhighlight lang="bracmat">ren$("input.txt"."output.txt") { 'ren' is based on standard C function 'rename()' } |
||
ren$(docs.mydocs) { No quotes needed: names don't contain dots or colons. } |
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:\\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. } |
ren$(@"d:\docs".@"d:\mydocs") { @ used as syntactic sugar as in C# for inhibiting escape. } |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
int main() |
int main() |
||
Line 143: | Line 229: | ||
rename("/docs", "/mydocs"); |
rename("/docs", "/mydocs"); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C sharp}}== |
|||
<syntaxhighlight lang="csharp">using System; |
|||
using System.IO; |
|||
class Program { |
|||
static void Main(string[] args) { |
|||
File.Move("input.txt","output.txt"); |
|||
File.Move(@"\input.txt",@"\output.txt"); |
|||
Directory.Move("docs","mydocs"); |
|||
Directory.Move(@"\docs",@"\mydocs"); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|C++}}== |
=={{header|C++}}== |
||
{{trans|C}} |
{{trans|C}} |
||
< |
<syntaxhighlight lang="cpp">#include <cstdio> |
||
int main() |
int main() |
||
Line 156: | Line 257: | ||
std::rename("/docs", "/mydocs"); |
std::rename("/docs", "/mydocs"); |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
{{libheader|Boost}} |
{{libheader|Boost}} |
||
Line 162: | Line 263: | ||
compiled with g++ -lboost_system -lboost_filesystem |
compiled with g++ -lboost_system -lboost_filesystem |
||
< |
<syntaxhighlight lang="cpp">#include "boost/filesystem.hpp" |
||
int main() |
int main() |
||
Line 179: | Line 280: | ||
boost::filesystem::path("/mydocs"));*/ |
boost::filesystem::path("/mydocs"));*/ |
||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C sharp}}== |
|||
<lang csharp>using System; |
|||
using System.IO; |
|||
class Program { |
|||
static void Main(string[] args) { |
|||
File.Move("input.txt","output.txt"); |
|||
File.Move(@"\input.txt",@"\output.txt"); |
|||
Directory.Move("docs","mydocs"); |
|||
Directory.Move(@"\docs",@"\mydocs"); |
|||
} |
|||
}</lang> |
|||
=={{header|Clipper}}== |
=={{header|Clipper}}== |
||
< |
<syntaxhighlight lang="clipper">FRename( "input.txt","output.txt") |
||
or |
or |
||
RENAME input.txt TO output.txt |
RENAME input.txt TO output.txt |
||
Line 204: | Line 290: | ||
FRename("\input.txt","\output.txt") |
FRename("\input.txt","\output.txt") |
||
or |
or |
||
RENAME \input.txt TO \output.txt</ |
RENAME \input.txt TO \output.txt</syntaxhighlight> |
||
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. |
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}}== |
=={{header|Clojure}}== |
||
< |
<syntaxhighlight lang="clojure">(import '(java.io File)) |
||
(.renameTo (File. "input.txt") (File. "output.txt")) |
(.renameTo (File. "input.txt") (File. "output.txt")) |
||
Line 219: | Line 305: | ||
(.renameTo |
(.renameTo |
||
(File. (str (File/separator) "docs")) |
(File. (str (File/separator) "docs")) |
||
(File. (str (File/separator) "mydocs")))</ |
(File. (str (File/separator) "mydocs")))</syntaxhighlight> |
||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
<code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_rn_fil.htm rename-file]</code> |
<code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_rn_fil.htm rename-file]</code> |
||
< |
<syntaxhighlight lang="lisp">(rename-file "input.txt" "output.txt") |
||
(rename-file "docs" "mydocs") |
(rename-file "docs" "mydocs") |
||
(rename-file "/input.txt" "/output.txt") |
(rename-file "/input.txt" "/output.txt") |
||
(rename-file "/docs" "/mydocs")</ |
(rename-file "/docs" "/mydocs")</syntaxhighlight> |
||
=={{header|D}}== |
=={{header|D}}== |
||
< |
<syntaxhighlight lang="d">std.file.rename("input.txt","output.txt"); |
||
std.file.rename("/input.txt","/output.txt"); |
std.file.rename("/input.txt","/output.txt"); |
||
std.file.rename("docs","mydocs"); |
std.file.rename("docs","mydocs"); |
||
std.file.rename("/docs","/mydocs");</ |
std.file.rename("/docs","/mydocs");</syntaxhighlight> |
||
=={{header|DBL}}== |
|||
<syntaxhighlight lang="dbl">XCALL RENAM ("output.txt","input.txt") |
|||
.IFDEF UNIX |
|||
XCALL SPAWN ("mv docs mydocs") |
|||
.ENDC |
|||
.IFDEF DOS |
|||
XCALL SPAWN ("ren docs mydocs") |
|||
.ENDC |
|||
.IFDEF VMS |
|||
XCALL SPAWN ("rename docs.dir mydocs.dir") |
|||
.ENDC</syntaxhighlight> |
|||
=={{header|DCL}}== |
=={{header|DCL}}== |
||
< |
<syntaxhighlight lang="dcl">rename input.txt output.txt |
||
rename docs.dir mydocs.dir |
rename docs.dir mydocs.dir |
||
rename [000000]input.txt [000000]output.txt |
rename [000000]input.txt [000000]output.txt |
||
rename [000000]docs.dir [000000]mydocs.dir</ |
rename [000000]docs.dir [000000]mydocs.dir</syntaxhighlight> |
||
=={{header|Delphi}}== |
=={{header|Delphi}}== |
||
< |
<syntaxhighlight lang="delphi">program RenameFile; |
||
{$APPTYPE CONSOLE} |
{$APPTYPE CONSOLE} |
||
Line 255: | Line 353: | ||
SysUtils.RenameFile('docs', 'MyDocs'); |
SysUtils.RenameFile('docs', 'MyDocs'); |
||
SysUtils.RenameFile('\docs', '\MyDocs'); |
SysUtils.RenameFile('\docs', '\MyDocs'); |
||
end.</ |
end.</syntaxhighlight> |
||
=={{header|E}}== |
=={{header|E}}== |
||
< |
<syntaxhighlight lang="e">for where in [<file:.>, <file:///>] { |
||
where["input.txt"].renameTo(where["output.txt"], null) |
where["input.txt"].renameTo(where["output.txt"], null) |
||
where["docs"].renameTo(where["mydocs"], null) |
where["docs"].renameTo(where["mydocs"], null) |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Elixir}}== |
=={{header|Elixir}}== |
||
< |
<syntaxhighlight lang="elixir">File.rename "input.txt","output.txt" |
||
File.rename "docs", "mydocs" |
File.rename "docs", "mydocs" |
||
File.rename "/input.txt", "/output.txt" |
File.rename "/input.txt", "/output.txt" |
||
File.rename "/docs", "/mydocs"</ |
File.rename "/docs", "/mydocs"</syntaxhighlight> |
||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(rename-file "input.txt" "output.txt") |
||
(rename-file "/input.txt" "/output.txt") |
(rename-file "/input.txt" "/output.txt") |
||
(rename-file "docs" "mydocs") |
(rename-file "docs" "mydocs") |
||
(rename-file "/docs" "/mydocs")</ |
(rename-file "/docs" "/mydocs")</syntaxhighlight> |
||
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. |
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. |
||
Line 280: | Line 378: | ||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
< |
<syntaxhighlight lang="erlang"> |
||
file:rename("input.txt","output.txt"), |
file:rename("input.txt","output.txt"), |
||
file:rename( "docs", "mydocs" ), |
file:rename( "docs", "mydocs" ), |
||
file:rename( "/input.txt", "/output.txt" ), |
file:rename( "/input.txt", "/output.txt" ), |
||
file:rename( "/docs", "/mydocs" ). |
file:rename( "/docs", "/mydocs" ). |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|ERRE}}== |
=={{header|ERRE}}== |
||
Line 305: | Line 403: | ||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
{{trans|C#}} |
{{trans|C#}} |
||
< |
<syntaxhighlight lang="fsharp">open System.IO |
||
[<EntryPoint>] |
[<EntryPoint>] |
||
Line 313: | Line 411: | ||
Directory.Move("docs","mydocs") |
Directory.Move("docs","mydocs") |
||
Directory.Move(@"\docs",@"\mydocs") |
Directory.Move(@"\docs",@"\mydocs") |
||
0</ |
0</syntaxhighlight> |
||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
< |
<syntaxhighlight lang="factor">"" "/" [ |
||
[ "input.txt" "output.txt" move-file "docs" "mydocs" move-file ] with-directory |
[ "input.txt" "output.txt" move-file "docs" "mydocs" move-file ] with-directory |
||
] bi@</ |
] bi@</syntaxhighlight> |
||
=={{header|Fantom}}== |
=={{header|Fantom}}== |
||
< |
<syntaxhighlight lang="fantom"> |
||
class Rename |
class Rename |
||
{ |
{ |
||
Line 334: | Line 432: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
< |
<syntaxhighlight lang="forth"> s" input.txt" s" output.txt" rename-file throw |
||
s" /input.txt" s" /output.txt" rename-file throw</ |
s" /input.txt" s" /output.txt" rename-file throw</syntaxhighlight> |
||
=={{header|Fortran}}== |
=={{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]) : |
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]) : |
||
< |
<syntaxhighlight lang="fortran"> PROGRAM EX_RENAME |
||
CALL RENAME('input.txt','output.txt') |
CALL RENAME('input.txt','output.txt') |
||
CALL RENAME('docs','mydocs') |
CALL RENAME('docs','mydocs') |
||
CALL RENAME('/input.txt','/output.txt') |
CALL RENAME('/input.txt','/output.txt') |
||
CALL RENAME('/docs','/mydocs') |
CALL RENAME('/docs','/mydocs') |
||
END</ |
END</syntaxhighlight> |
||
=={{header|FreeBASIC}}== |
=={{header|FreeBASIC}}== |
||
< |
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
||
Dim result As Long |
Dim result As Long |
||
Line 363: | Line 461: | ||
End If |
End If |
||
Sleep</ |
Sleep</syntaxhighlight> |
||
=={{header|FutureBasic}}== |
|||
<syntaxhighlight lang="futurebasic"> |
|||
CFURLRef inputText, outputText, docs, myDocs |
|||
inputText = fn URLFileURLWithPath( @"~/Desktop/input.txt" ) |
|||
outputText = fn URLFileURLWithPath( @"~/Desktop/output.txt" ) |
|||
docs = fn URLFileURLWithPath( @"~/Desktop/docs/" ) |
|||
myDocs = fn URLFileURLWithPath( @"~/Desktop/myDocs/" ) |
|||
fn FileManagerMoveItemAtURL( inputText, outputText ) |
|||
fn FileManagerMoveItemAtURL( docs, myDocs ) |
|||
</syntaxhighlight> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
< |
<syntaxhighlight lang="go">package main |
||
import "os" |
import "os" |
||
Line 374: | Line 486: | ||
os.Rename("/input.txt", "/output.txt") |
os.Rename("/input.txt", "/output.txt") |
||
os.Rename("/docs", "/mydocs") |
os.Rename("/docs", "/mydocs") |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
Using File |
Using File |
||
< |
<syntaxhighlight lang="groovy">['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst -> |
||
['.', ''].each { dir -> |
['.', ''].each { dir -> |
||
new File("$dir/$src").renameTo(new File("$dir/$dst")) |
new File("$dir/$src").renameTo(new File("$dir/$dst")) |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
Using Ant |
Using Ant |
||
< |
<syntaxhighlight lang="groovy">['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst -> |
||
['.', ''].each { dir -> |
['.', ''].each { dir -> |
||
new AntBuilder().move(file:"$dir/$src", toFile:"$dir/$dst") |
new AntBuilder().move(file:"$dir/$src", toFile:"$dir/$dst") |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Harbour}}== |
=={{header|Harbour}}== |
||
< |
<syntaxhighlight lang="visualfoxpro">FRename( "input.txt","output.txt") |
||
// or |
// or |
||
RENAME input.txt TO output.txt |
RENAME input.txt TO output.txt |
||
FRename( hb_ps() + "input.txt", hb_ps() + "output.txt")</ |
FRename( hb_ps() + "input.txt", hb_ps() + "output.txt")</syntaxhighlight> |
||
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. |
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}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="haskell">import System.IO |
||
import System.Directory |
import System.Directory |
||
Line 409: | Line 521: | ||
renameDirectory "docs" "mydocs" |
renameDirectory "docs" "mydocs" |
||
renameFile "/input.txt" "/output.txt" |
renameFile "/input.txt" "/output.txt" |
||
renameDirectory "/docs" "/mydocs"</ |
renameDirectory "/docs" "/mydocs"</syntaxhighlight> |
||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
< |
<syntaxhighlight lang="hicest">WRITE(FIle='input.txt', REName='.\output.txt') |
||
SYSTEM(DIR='E:\HicEst\Rosetta') |
SYSTEM(DIR='E:\HicEst\Rosetta') |
||
WRITE(FIle='.\docs', REName='.\mydocs') |
WRITE(FIle='.\docs', REName='.\mydocs') |
||
Line 418: | Line 530: | ||
WRITE(FIle='\input.txt', REName='\output.txt') |
WRITE(FIle='\input.txt', REName='\output.txt') |
||
SYSTEM(DIR='\') |
SYSTEM(DIR='\') |
||
WRITE(FIle='\docs', REName='\mydocs') </ |
WRITE(FIle='\docs', REName='\mydocs') </syntaxhighlight> |
||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
Icon supports 'rename' for files only. |
Icon supports 'rename' for files only. |
||
< |
<syntaxhighlight lang="unicon">every dir := !["./","/"] do { |
||
rename(f := dir || "input.txt", dir || "output.txt") |stop("failure for file rename ",f) |
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) |
rename(f := dir || "docs", dir || "mydocs") |stop("failure for directory rename ",f) |
||
}</ |
}</syntaxhighlight> |
||
Note: Icon and Unicon accept both / and \ for directory separators. |
Note: Icon and Unicon accept both / and \ for directory separators. |
||
=={{header|Io}}== |
=={{header|Io}}== |
||
<syntaxhighlight lang="io"> |
|||
<lang Io> |
|||
// rename file in current directory |
// rename file in current directory |
||
f := File with("input.txt") |
f := File with("input.txt") |
||
Line 446: | Line 558: | ||
d := Directory with("/docs") |
d := Directory with("/docs") |
||
d moveTo("/mydocs") |
d moveTo("/mydocs") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Line 453: | Line 565: | ||
The following will work on Windows, Linux and Macs: |
The following will work on Windows, Linux and Macs: |
||
< |
<syntaxhighlight lang="j">frename=: 4 : 0 |
||
if. x -: y do. return. end. |
if. x -: y do. return. end. |
||
if. IFUNIX do. |
if. IFUNIX do. |
||
Line 461: | Line 573: | ||
'kernel32 MoveFileA i *c *c' 15!:0 y;x |
'kernel32 MoveFileA i *c *c' 15!:0 y;x |
||
end. |
end. |
||
)</ |
)</syntaxhighlight> |
||
Useage: |
Useage: |
||
< |
<syntaxhighlight lang="j">'output.txt' frename 'input.txt' |
||
'/output.txt' frename '/input.txt' |
'/output.txt' frename '/input.txt' |
||
'mydocs' frename 'docs' |
'mydocs' frename 'docs' |
||
'/mydocs' frename '/docs'</ |
'/mydocs' frename '/docs'</syntaxhighlight> |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java">import java.io.File; |
||
public class FileRenameTest { |
public class FileRenameTest { |
||
public static boolean renameFile(String oldname, String newname) { |
public static boolean renameFile(String oldname, String newname) { |
||
Line 495: | Line 607: | ||
test("directory", File.separator + "docs" + File.separator, File.separator + "mydocs" + File.separator); |
test("directory", File.separator + "docs" + File.separator, File.separator + "mydocs" + File.separator); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
{{works with|JScript}} |
{{works with|JScript}} |
||
Throws an error if the destination file/folder exists. |
Throws an error if the destination file/folder exists. |
||
< |
<syntaxhighlight lang="javascript">var fso = new ActiveXObject("Scripting.FileSystemObject") |
||
fso.MoveFile("input.txt", "output.txt") |
fso.MoveFile("input.txt", "output.txt") |
||
fso.MoveFile("c:/input.txt", "c:/output.txt") |
fso.MoveFile("c:/input.txt", "c:/output.txt") |
||
fso.MoveFolder("docs", "mydocs") |
fso.MoveFolder("docs", "mydocs") |
||
fso.MoveFolder("c:/docs", "c:/mydocs")</ |
fso.MoveFolder("c:/docs", "c:/mydocs")</syntaxhighlight> |
||
=={{header|Joy}}== |
=={{header|Joy}}== |
||
<syntaxhighlight lang="joy"> |
|||
<lang Joy> |
|||
"input.txt" "output.txt" frename |
"input.txt" "output.txt" frename |
||
"/input.txt" "/output.txt" frename |
"/input.txt" "/output.txt" frename |
||
"docs" "mydocs" frename |
"docs" "mydocs" frename |
||
"/docs" "/mydocs" frename. |
"/docs" "/mydocs" frename. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Jsish}}== |
|||
<syntaxhighlight lang="javascript">/* File rename, in jsish */ |
|||
try { File.rename('input.txt', 'output.txt', false); } catch (str) { puts(str); } |
|||
exec('touch input.txt'); |
|||
puts("overwrite set true if output.txt exists"); |
|||
File.rename('input.txt', 'output.txt', true); |
|||
try { File.rename('docs', 'mydocs', false); } catch (str) { puts(str); } |
|||
try { File.rename('/docs', '/mydocs', false); } catch (str) { puts(str); }</syntaxhighlight> |
|||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia"> |
||
mv("input.txt", "output.txt") |
mv("input.txt", "output.txt") |
||
mv("docs", "mydocs") |
mv("docs", "mydocs") |
||
mv("/input.txt", "/output.txt") |
mv("/input.txt", "/output.txt") |
||
mv("/docs", "/mydocs")</ |
mv("/docs", "/mydocs")</syntaxhighlight> |
||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
< |
<syntaxhighlight lang="scala">// version 1.0.6 |
||
/* testing on Windows 10 which needs administrative privileges |
/* testing on Windows 10 which needs administrative privileges |
||
Line 542: | Line 665: | ||
println("${oldPaths[i]} could not be renamed") |
println("${oldPaths[i]} could not be renamed") |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 551: | Line 674: | ||
c:\docs successfully renamed to c:\mydocs |
c:\docs successfully renamed to c:\mydocs |
||
</pre> |
</pre> |
||
=={{header|Lang}}== |
|||
{{libheader|lang-io-module}} |
|||
<syntaxhighlight lang="lang"> |
|||
# Load the IO module |
|||
# Replace "<pathToIO.lm>" with the location where the io.lm Lang module was installed to without "<" and ">" |
|||
ln.loadModule(<pathToIO.lm>) |
|||
fp.rename = ($from, $to) -> { |
|||
$fileFrom = [[io]]::fp.openFile($from) |
|||
$fileTo = [[io]]::fp.openFile($to) |
|||
[[io]]::fp.rename($fileFrom, $fileTo) |
|||
[[io]]::fp.closeFile($fileFrom) |
|||
[[io]]::fp.closeFile($fileTo) |
|||
} |
|||
fp.rename(input.txt, output.txt) |
|||
fp.rename(/input.txt, /output.txt) |
|||
fp.rename(docs, mydocs) |
|||
fp.rename(/docs, /mydocs) |
|||
</syntaxhighlight> |
|||
=={{header|Lasso}}== |
=={{header|Lasso}}== |
||
< |
<syntaxhighlight lang="lasso ">// move file |
||
local(f = file('input.txt')) |
local(f = file('input.txt')) |
||
#f->moveTo('output.txt') |
#f->moveTo('output.txt') |
||
Line 569: | Line 715: | ||
// move directory in root file system (requires permissions at user OS level) |
// move directory in root file system (requires permissions at user OS level) |
||
local(d = file('//docs')) |
local(d = file('//docs')) |
||
#d->moveTo('//mydocs')</ |
#d->moveTo('//mydocs')</syntaxhighlight> |
||
=={{header|LFE}}== |
=={{header|LFE}}== |
||
< |
<syntaxhighlight lang="lisp"> |
||
(file:rename "input.txt" "output.txt") |
(file:rename "input.txt" "output.txt") |
||
(file:rename "docs" "mydocs") |
(file:rename "docs" "mydocs") |
||
(file:rename "/input.txt" "/output.txt") |
(file:rename "/input.txt" "/output.txt") |
||
(file:rename "/docs" "/mydocs") |
(file:rename "/docs" "/mydocs") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Liberty BASIC}}== |
=={{header|Liberty BASIC}}== |
||
< |
<syntaxhighlight lang="lb">' LB has inbuilt 'name' command, but can also run batch files |
||
nomainwin |
nomainwin |
||
Line 590: | Line 736: | ||
run "cmd.exe /c ren C:\docs mydocs", HIDE |
run "cmd.exe /c ren C:\docs mydocs", HIDE |
||
end</ |
end</syntaxhighlight> |
||
=={{header|LiveCode}}== |
=={{header|LiveCode}}== |
||
< |
<syntaxhighlight lang="livecode">rename file "input.txt" to "output.txt" |
||
rename folder "docs" to "mydocs" |
rename folder "docs" to "mydocs" |
||
rename file "/input.txt" to "/output.txt" |
rename file "/input.txt" to "/output.txt" |
||
rename folder "/docs" to "/mydocs"</ |
rename folder "/docs" to "/mydocs"</syntaxhighlight> |
||
=={{header|Locomotive Basic}}== |
=={{header|Locomotive Basic}}== |
||
< |
<syntaxhighlight lang="locobasic">|ren,"input.txt","output.txt"</syntaxhighlight> |
||
([[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.) |
([[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}}== |
=={{header|Lua}}== |
||
< |
<syntaxhighlight lang="lua">os.rename( "input.txt", "output.txt" ) |
||
os.rename( "/input.txt", "/output.txt" ) |
os.rename( "/input.txt", "/output.txt" ) |
||
os.rename( "docs", "mydocs" ) |
os.rename( "docs", "mydocs" ) |
||
os.rename( "/docs", "/mydocs" )</ |
os.rename( "/docs", "/mydocs" )</syntaxhighlight> |
||
=={{header|M2000 Interpreter}}== |
=={{header|M2000 Interpreter}}== |
||
To delete a file we have to use Dos shell,so this can be done using Dos command |
To delete a file we have to use Dos shell,so this can be done using Dos command |
||
<syntaxhighlight lang="m2000 interpreter"> |
|||
<lang M2000 Interpreter> |
|||
Module checkit { |
Module checkit { |
||
Document A$={Alfa, beta} |
Document A$={Alfa, beta} |
||
Line 622: | Line 768: | ||
} |
} |
||
checkit |
checkit |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Maple}}== |
=={{header|Maple}}== |
||
< |
<syntaxhighlight lang="maple">use FileTools in |
||
Rename( "input.txt", "output.txt" ); |
Rename( "input.txt", "output.txt" ); |
||
Rename( "docs", "mydocs" ); |
Rename( "docs", "mydocs" ); |
||
Rename( "/input.txt", "/output.txt" ); # assuming permissions in / |
Rename( "/input.txt", "/output.txt" ); # assuming permissions in / |
||
Rename( "/docs", "/mydocs" ) # assuming permissions in / |
Rename( "/docs", "/mydocs" ) # assuming permissions in / |
||
end use:</ |
end use:</syntaxhighlight> |
||
=={{header|Mathematica}}== |
=={{header|Mathematica}}/{{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">SetDirectory[NotebookDirectory[]] |
||
RenameFile["input.txt", "output.txt"] |
RenameFile["input.txt", "output.txt"] |
||
RenameDirectory["docs", "mydocs"] |
RenameDirectory["docs", "mydocs"] |
||
SetDirectory[$RootDirectory] |
SetDirectory[$RootDirectory] |
||
RenameFile["input.txt", "output.txt"] |
RenameFile["input.txt", "output.txt"] |
||
RenameDirectory["docs", "mydocs"]</ |
RenameDirectory["docs", "mydocs"]</syntaxhighlight> |
||
=={{header|MATLAB}} / {{header|Octave}}== |
=={{header|MATLAB}} / {{header|Octave}}== |
||
< |
<syntaxhighlight lang="matlab"> [STATUS, MSG, MSGID] = movefile (F1, F2); </syntaxhighlight> |
||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
MAXScript has no folder rename method |
MAXScript has no folder rename method |
||
< |
<syntaxhighlight lang="maxscript">-- Here |
||
renameFile "input.txt" "output.txt" |
renameFile "input.txt" "output.txt" |
||
-- Root |
-- Root |
||
renameFile "/input.txt" "/output.txt"</ |
renameFile "/input.txt" "/output.txt"</syntaxhighlight> |
||
=={{header|Mercury}}== |
=={{header|Mercury}}== |
||
< |
<syntaxhighlight lang="mercury">:- module rename_file. |
||
:- interface. |
:- interface. |
||
Line 685: | Line 831: | ||
io.write_string(Stderr, io.error_message(Error), !IO), |
io.write_string(Stderr, io.error_message(Error), !IO), |
||
io.nl(Stderr, !IO), |
io.nl(Stderr, !IO), |
||
io.set_exit_status(1, !IO).</ |
io.set_exit_status(1, !IO).</syntaxhighlight> |
||
=={{header|min}}== |
|||
{{works with|min|0.37.0}} |
|||
<syntaxhighlight lang="min">"input.txt" "output.txt" mv |
|||
"docs" "mydocs" mv |
|||
"/input.txt" "/output.txt" mv |
|||
"/docs" "/mydocs" mv</syntaxhighlight> |
|||
=={{header|MUMPS}}== |
=={{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>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> |
<p>In Cache on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:</p> |
||
< |
<syntaxhighlight lang="mumps"> ;Local |
||
S X=$ZF(-1,"rename input.txt output.txt") |
S X=$ZF(-1,"rename input.txt output.txt") |
||
S X=$ZF(-1,"rename docs.dir mydocs.dir") |
S X=$ZF(-1,"rename docs.dir mydocs.dir") |
||
;Root of current device |
;Root of current device |
||
S X=$ZF(-1,"rename [000000]input.txt [000000]output.txt") |
S X=$ZF(-1,"rename [000000]input.txt [000000]output.txt") |
||
S X=$ZF(-1,"rename [000000]docs.dir [000000]mydocs.dir")</ |
S X=$ZF(-1,"rename [000000]docs.dir [000000]mydocs.dir")</syntaxhighlight> |
||
=={{header|NetRexx}}== |
=={{header|NetRexx}}== |
||
< |
<syntaxhighlight lang="netrexx">/* NetRexx */ |
||
options replace format comments java crossref symbols binary |
options replace format comments java crossref symbols binary |
||
Line 711: | Line 865: | ||
return fRenamed |
return fRenamed |
||
-- 09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)~~ |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
method runSample(arg) private static |
method runSample(arg) private static |
||
parse arg files |
parse arg files |
||
Line 734: | Line 888: | ||
return |
return |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|NewLISP}}== |
=={{header|NewLISP}}== |
||
< |
<syntaxhighlight lang="newlisp">(rename-file "./input.txt" "./output.txt") |
||
(rename-file "./docs" "./mydocs") |
(rename-file "./docs" "./mydocs") |
||
(rename-file "/input.txt" "/output.txt") |
(rename-file "/input.txt" "/output.txt") |
||
(rename-file "/docs" "/mydocs")</ |
(rename-file "/docs" "/mydocs")</syntaxhighlight> |
||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
< |
<syntaxhighlight lang="nim">import os |
||
moveFile("input.txt", "output.txt") |
moveFile("input.txt", "output.txt") |
||
Line 749: | Line 903: | ||
moveFile(DirSep & "input.txt", DirSep & "output.txt") |
moveFile(DirSep & "input.txt", DirSep & "output.txt") |
||
moveFile(DirSep & "docs", DirSep & "mydocs")</ |
moveFile(DirSep & "docs", DirSep & "mydocs")</syntaxhighlight> |
||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
< |
<syntaxhighlight lang="objeck"> |
||
use IO; |
use IO; |
||
bundle Default { |
bundle Default { |
||
Line 764: | Line 918: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Objective-C}}== |
=={{header|Objective-C}}== |
||
Line 771: | Line 925: | ||
{{works with|GNUstep}} |
{{works with|GNUstep}} |
||
< |
<syntaxhighlight lang="objc">NSFileManager *fm = [NSFileManager defaultManager]; |
||
// Pre-OS X 10.5 |
// Pre-OS X 10.5 |
||
Line 779: | Line 933: | ||
// OS X 10.5+ |
// OS X 10.5+ |
||
[fm moveItemAtPath:@"input.txt" toPath:@"output.txt" error:NULL]; |
[fm moveItemAtPath:@"input.txt" toPath:@"output.txt" error:NULL]; |
||
[fm moveItemAtPath:@"docs" toPath:@"mydocs" error:NULL];</ |
[fm moveItemAtPath:@"docs" toPath:@"mydocs" error:NULL];</syntaxhighlight> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml"> |
||
let () = |
let () = |
||
Sys.rename "input.txt" "output.txt"; |
Sys.rename "input.txt" "output.txt"; |
||
Sys.rename "docs" "mydocs"; |
Sys.rename "docs" "mydocs"; |
||
Sys.rename "/input.txt" "/output.txt"; |
Sys.rename "/input.txt" "/output.txt"; |
||
Sys.rename "/docs" "/mydocs";</ |
Sys.rename "/docs" "/mydocs";</syntaxhighlight> |
||
=={{header|Octave}}== |
=={{header|Octave}}== |
||
< |
<syntaxhighlight lang="octave"> |
||
rename('docs','mydocs'); |
rename('docs','mydocs'); |
||
rename('input.txt','/output.txt'); |
rename('input.txt','/output.txt'); |
||
rename('/docs','/mydocs'); |
rename('/docs','/mydocs'); |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|OpenEdge/Progress}}== |
=={{header|OpenEdge/Progress}}== |
||
< |
<syntaxhighlight lang="progress">OS-RENAME "input.txt" "output.txt". |
||
OS-RENAME "docs" "mydocs". |
OS-RENAME "docs" "mydocs". |
||
OS-RENAME "/input.txt" "/output.txt". |
OS-RENAME "/input.txt" "/output.txt". |
||
OS-RENAME "/docs" "/mydocs".</ |
OS-RENAME "/docs" "/mydocs".</syntaxhighlight> |
||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
GP has no built-in facilities for renaming, but can use a system call: |
GP has no built-in facilities for renaming, but can use a system call: |
||
< |
<syntaxhighlight lang="parigp">system("mv input.txt output.txt"); |
||
system("mv /input.txt /output.txt"); |
system("mv /input.txt /output.txt"); |
||
system("mv docs mydocs"); |
system("mv docs mydocs"); |
||
system("mv /docs /mydocs");</ |
system("mv /docs /mydocs");</syntaxhighlight> |
||
PARI, as usual, has access to all the standard [[#C|C]] methods. |
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: |
Alternatively it's possible to bind rename() system call to a new function: |
||
< |
<syntaxhighlight lang="parigp">install("rename","iss","rename"); |
||
rename("input.txt", "output.txt");</ |
rename("input.txt", "output.txt");</syntaxhighlight> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
< |
<syntaxhighlight lang="pascal"> var |
||
f : file ; // Untyped file |
f : file ; // Untyped file |
||
begin |
begin |
||
Line 837: | Line 991: | ||
Rename(f,'\mydocs'); |
Rename(f,'\mydocs'); |
||
end;</ |
end;</syntaxhighlight> |
||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
uses System.IO; |
|||
begin |
|||
&File.Move('input.txt','output.txt'); |
|||
&File.Move('\input.txt','\output.txt'); |
|||
Directory.Move('docs','mydocs'); |
|||
Directory.Move('\docs','\mydocs'); |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">use File::Copy qw(move); |
||
use File::Spec::Functions qw(catfile rootdir); |
use File::Spec::Functions qw(catfile rootdir); |
||
# here |
# here |
||
Line 847: | Line 1,014: | ||
# root dir |
# root dir |
||
move (catfile rootdir, 'input.txt'), (catfile rootdir, 'output.txt'); |
move (catfile rootdir, 'input.txt'), (catfile rootdir, 'output.txt'); |
||
move (catfile rootdir, 'docs'), (catfile rootdir, 'mydocs');</ |
move (catfile rootdir, 'docs'), (catfile rootdir, 'mydocs');</syntaxhighlight> |
||
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. |
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. |
||
=={{header|Perl 6}}== |
|||
<lang perl6>rename 'input.txt', 'output.txt'; |
|||
rename 'docs', 'mydocs'; |
|||
rename '/input.txt', '/output.txt'; |
|||
rename '/docs', '/mydocs';</lang> |
|||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
Windows now makes it fairly difficult to rename files in the root directory, even by hand. |
Windows now makes it fairly difficult to rename files in the root directory, even by hand. |
||
Output is 0 for success, 1 for failure. |
Output is 0 for success, 1 for failure. |
||
<!--<syntaxhighlight lang="phix">(notonline)--> |
|||
<lang Phix>?rename_file("input.txt","output.txt") |
|||
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span> |
|||
?rename_file("docs","mydocs") |
|||
<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> |
|||
?rename_file("C:\\Copy.txt","Copy.xxx") |
|||
<span style="color: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"docs"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"mydocs"</span><span style="color: #0000FF;">)</span> |
|||
?rename_file("C:\\docs","C:\\mydocs")</lang> |
|||
<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> |
|||
<!--</syntaxhighlight>--> |
|||
=={{header|Phixmonti}}== |
|||
<syntaxhighlight lang="phixmonti">_platform "windows" == if "\\" "ren " else "/" "mv " endif |
|||
var com var slash |
|||
com "input.txt output.txt" chain cmd |
|||
com "docs mydocs" chain cmd |
|||
com slash chain "input.txt " chain slash chain "output.txt" chain cmd |
|||
com slash chain "docs " chain slash chain "mydocs" chain cmd</syntaxhighlight> |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
< |
<syntaxhighlight lang="php"><?php |
||
rename('input.txt', 'output.txt'); |
rename('input.txt', 'output.txt'); |
||
rename('docs', 'mydocs'); |
rename('docs', 'mydocs'); |
||
rename('/input.txt', '/output.txt'); |
rename('/input.txt', '/output.txt'); |
||
rename('/docs', '/mydocs'); |
rename('/docs', '/mydocs'); |
||
?></ |
?></syntaxhighlight> |
||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(call 'mv "input.txt" "output.txt") |
||
(call 'mv "docs" "mydocs") |
(call 'mv "docs" "mydocs") |
||
(call 'mv "/input.txt" "/output.txt") |
(call 'mv "/input.txt" "/output.txt") |
||
(call 'mv "/docs" "/mydocs")</ |
(call 'mv "/docs" "/mydocs")</syntaxhighlight> |
||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
< |
<syntaxhighlight lang="pike">int main(){ |
||
mv("input.txt", "output.txt"); |
mv("input.txt", "output.txt"); |
||
mv("/input.txt", "/output.txt"); |
mv("/input.txt", "/output.txt"); |
||
mv("docs", "mydocs"); |
mv("docs", "mydocs"); |
||
mv("/docs", "/mydocs"); |
mv("/docs", "/mydocs"); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Plain English}}== |
|||
<syntaxhighlight lang="text"> |
|||
To run: |
|||
Start up. |
|||
\ In the current working directory |
|||
Rename ".\input.txt" to ".\output.txt" in the file system. |
|||
Rename ".\docs\" to ".\mydocs\" in the file system. |
|||
\ In the filesystem root |
|||
Rename "C:\input.txt" to "C:\output.txt" in the file system. |
|||
Rename "C:\docs\" to "C:\mydocs\" in the file system. |
|||
Shut down. |
|||
</syntaxhighlight> |
|||
=={{header|Pop11}}== |
=={{header|Pop11}}== |
||
< |
<syntaxhighlight lang="pop11">sys_file_move('inputs.txt', 'output.txt'); |
||
sys_file_move('docs', 'mydocs'); |
sys_file_move('docs', 'mydocs'); |
||
sys_file_move('/inputs.txt', '/output.txt'); |
sys_file_move('/inputs.txt', '/output.txt'); |
||
sys_file_move(/'docs', '/mydocs');</ |
sys_file_move(/'docs', '/mydocs');</syntaxhighlight> |
||
Note that notion of the root of filesystem is Unix specific, so above we |
Note that notion of the root of filesystem is Unix specific, so above we |
||
Line 897: | Line 1,083: | ||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
< |
<syntaxhighlight lang="powershell">Rename-Item input.txt output.txt |
||
# The Rename-item has the alias ren |
# The Rename-item has the alias ren |
||
ren input.txt output.txt</ |
ren input.txt output.txt</syntaxhighlight> |
||
=={{header|Processing}}== |
|||
<syntaxhighlight lang="processing">void setup(){ |
|||
boolean sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt")); |
|||
boolean sketchfold = rename(sketchPath("docs"), sketchPath("mydocs")); |
|||
// sketches will seldom have write permission to root files/folders |
|||
boolean rootfile = rename("input.txt", "output.txt"); |
|||
boolean rootfold = rename("docs", "mydocs"); |
|||
// true if succeeded, false if failed |
|||
println(sketchfile, sketchfold, rootfile, rootfold); |
|||
} |
|||
boolean rename(String oldname, String newname) { |
|||
// File (or directory) with old name |
|||
File file = new File(oldname); |
|||
// File (or directory) with new name |
|||
File file2 = new File(newname); |
|||
// Rename file (or directory) |
|||
boolean success = file.renameTo(file2); |
|||
return success; |
|||
}</syntaxhighlight> |
|||
===Processing Python mode=== |
|||
<syntaxhighlight lang="python">from java.io import File |
|||
def setup(): |
|||
# rename local file |
|||
sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt")) |
|||
# rename local folder |
|||
sketchfold = rename(sketchPath("docs"), sketchPath("mydocs")) |
|||
# rename root file (if permitted) |
|||
rootfile = rename("input.txt", "output.txt") |
|||
# rename root folder (if permitted) |
|||
rootfold = rename("docs", "mydocs") |
|||
# display results of four operations: True=success, False=fail |
|||
println(str(sketchfile) + ' ' + |
|||
str(sketchfold) + ' ' + |
|||
str(rootfile) + ' ' + |
|||
str(rootfold)) |
|||
# output: |
|||
# True True False False |
|||
def rename(oldname, newname): |
|||
# File (or directory) with old name |
|||
file = File(oldname) |
|||
# File (or directory) with new name |
|||
file2 = File(newname) |
|||
# Rename file (or directory) |
|||
success = file.renameTo(file2) |
|||
return success</syntaxhighlight> |
|||
=={{header|ProDOS}}== |
=={{header|ProDOS}}== |
||
< |
<syntaxhighlight lang="prodos">rename input.txt to output.txt |
||
rename docs to mydocs</ |
rename docs to mydocs</syntaxhighlight> |
||
=={{header|PureBasic}}== |
=={{header|PureBasic}}== |
||
< |
<syntaxhighlight lang="purebasic">RenameFile("input.txt", "output.txt") |
||
RenameFile("docs\", "mydocs\") |
RenameFile("docs\", "mydocs\") |
||
RenameFile("/input.txt","/output.txt") |
RenameFile("/input.txt","/output.txt") |
||
RenameFile("/docs\","/mydocs\")</ |
RenameFile("/docs\","/mydocs\")</syntaxhighlight> |
||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">import os |
||
os.rename("input.txt", "output.txt") |
os.rename("input.txt", "output.txt") |
||
Line 922: | Line 1,160: | ||
os.rename(os.sep + "input.txt", os.sep + "output.txt") |
os.rename(os.sep + "input.txt", os.sep + "output.txt") |
||
os.rename(os.sep + "docs", os.sep + "mydocs")</ |
os.rename(os.sep + "docs", os.sep + "mydocs")</syntaxhighlight> |
||
Or the alternative: |
Or the alternative: |
||
< |
<syntaxhighlight lang="python">import shutil |
||
shutil.move("input.txt", "output.txt") |
shutil.move("input.txt", "output.txt") |
||
Line 932: | Line 1,170: | ||
shutil.move("/input.txt", "/output.txt") |
shutil.move("/input.txt", "/output.txt") |
||
shutil.move("/docs", "/mydocs")</ |
shutil.move("/docs", "/mydocs")</syntaxhighlight> |
||
=={{header| |
=={{header|Quackery}}== |
||
<lang R>file.rename("input.txt", "output.txt") |
|||
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. |
|||
file.rename("/input.txt", "/output.txt") |
|||
file.rename("docs", "mydocs") |
|||
<syntaxhighlight lang="quackery"> $ " |
|||
file.rename("/docs", "/mydocs")</lang> |
|||
import os |
|||
if os.path.exists('input.txt'): |
|||
os.rename('input.txt', 'output.txt') |
|||
" python |
|||
$ " |
|||
import os |
|||
if os.path.exists('docs'): |
|||
os.rename('docs', 'mydocs') |
|||
" python |
|||
$ " |
|||
import os |
|||
if os.path.exists('/input.txt'): |
|||
os.rename('/input.txt', '/output.txt') |
|||
" python |
|||
$ " |
|||
import os |
|||
if os.path.exists('/docs'): |
|||
os.rename('/docs', '/mydocs') |
|||
" python</syntaxhighlight> |
|||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
< |
<syntaxhighlight lang="racket"> |
||
#lang racket |
#lang racket |
||
Line 955: | Line 1,215: | ||
(rename-file-or-directory (build-path root "docs") |
(rename-file-or-directory (build-path root "docs") |
||
(build-path root "mydocs")) |
(build-path root "mydocs")) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
<syntaxhighlight lang="raku" line>rename 'input.txt', 'output.txt'; |
|||
rename 'docs', 'mydocs'; |
|||
rename '/input.txt', '/output.txt'; |
|||
rename '/docs', '/mydocs';</syntaxhighlight> |
|||
=={{header|Raven}}== |
=={{header|Raven}}== |
||
< |
<syntaxhighlight lang="raven">`mv /path/to/file/oldfile /path/to/file/newfile` shell</syntaxhighlight> |
||
=={{header|REALbasic}}== |
=={{header|REALbasic}}== |
||
Line 964: | Line 1,231: | ||
This ''should'' work regardless of what OS it's running under (but untested under [[Mac OS]]). |
This ''should'' work regardless of what OS it's running under (but untested under [[Mac OS]]). |
||
< |
<syntaxhighlight lang="vb">Sub Renamer() |
||
Dim f As FolderItem, r As FolderItem |
Dim f As FolderItem, r As FolderItem |
||
Line 992: | Line 1,259: | ||
Return what |
Return what |
||
End If |
End If |
||
End Function</ |
End Function</syntaxhighlight> |
||
=={{header|REBOL}}== |
=={{header|REBOL}}== |
||
< |
<syntaxhighlight lang="rebol">rename %input.txt %output.txt |
||
rename %docs/ %mydocs/ |
rename %docs/ %mydocs/ |
||
Line 1,014: | Line 1,281: | ||
rename ftp://username:password@ftp.site.com/www/input.txt %output.txt |
rename ftp://username:password@ftp.site.com/www/input.txt %output.txt |
||
rename ftp://username:password@ftp.site.com/www/docs/ %mydocs/ |
rename ftp://username:password@ftp.site.com/www/docs/ %mydocs/ |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
===error messages shown=== |
===error messages shown=== |
||
< |
<syntaxhighlight lang="rexx">/*REXX program renames a file & a directory (in current dir & in root).*/ |
||
trace off /*suppress error messages, bad RC*/ |
trace off /*suppress error messages, bad RC*/ |
||
Line 1,026: | Line 1,293: | ||
'CD' "\" /*for 2nd pass, change──►root dir*/ |
'CD' "\" /*for 2nd pass, change──►root dir*/ |
||
end /*2*/ |
end /*2*/ |
||
/*stick a fork in it, we're done.*/</ |
/*stick a fork in it, we're done.*/</syntaxhighlight> |
||
===error messages suppressed=== |
===error messages suppressed=== |
||
< |
<syntaxhighlight lang="rexx">/*REXX program renames a file & a directory (in current dir & in root).*/ |
||
trace off /*suppress error messages, bad RC*/ |
trace off /*suppress error messages, bad RC*/ |
||
$ = '2> NUL' /*used to suppress error messages*/ |
$ = '2> NUL' /*used to suppress error messages*/ |
||
Line 1,038: | Line 1,305: | ||
'CD' "\" $ /*for 2nd pass, change──►root dir*/ |
'CD' "\" $ /*for 2nd pass, change──►root dir*/ |
||
end /*2*/ |
end /*2*/ |
||
/*stick a fork in it, we're done.*/</ |
/*stick a fork in it, we're done.*/</syntaxhighlight> |
||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
rename("input.txt", "output.txt") |
rename("input.txt", "output.txt") |
||
rename("docs", "mydocs") |
rename("docs", "mydocs") |
||
rename("/input.txt", "/output.txt") |
rename("/input.txt", "/output.txt") |
||
rename("/docs", "/mydocs") |
rename("/docs", "/mydocs") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|RPL}}== |
|||
RPL’s tree file system is made of variables, which can contain either programs or data, and directories. Variables and directories handling features are basic. |
|||
{{works with|Halcyon Calc|4.2.7}} |
|||
{| class="wikitable" |
|||
! RPL code |
|||
! Comment |
|||
|- |
|||
| |
|||
≪ |
|||
PATH { HOME } == 1 ROT '''IFTE''' |
|||
→ old new here |
|||
≪ '''IF''' here NOT '''THEN''' PATH HOME '''END''' |
|||
'''IFERR''' old RCL '''THEN''' |
|||
new CRDIR PURGE |
|||
'''ELSE''' |
|||
new STO old PURGE '''END''' |
|||
'''IF''' here NOT '''THEN''' |
|||
2 OVER SIZE '''FOR''' j DUP j GET EVAL '''NEXT''' |
|||
DROP '''END''' |
|||
≫ ≫ ''''RNAME'''' STO |
|||
| |
|||
'''RNAME''' ''( ‘old’ ‘new’ boolean -- )'' |
|||
Set ''here'' to true if already at root |
|||
Store arguments |
|||
Store current path in stack and go to the root |
|||
Detect if ''old'' is a directory by recalling its content |
|||
If yes, create ''new'' then delete ''old'' |
|||
Otherwise, store content in ''new'', then delete ''old'' |
|||
Go back to current directory |
|||
following the path in stack |
|||
Forget path |
|||
|} |
|||
{{in}} |
|||
<pre> |
|||
'Input' 'Output' 1 RNAME |
|||
'DOCS' 'MYDOCS' 0 RNAME |
|||
</pre> |
|||
The boolean argument indicates if the renaming must be achieved in the current directory (1) or at the root (0). |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
< |
<syntaxhighlight lang="ruby">File.rename('input.txt', 'output.txt') |
||
File.rename('/input.txt', '/output.txt') |
File.rename('/input.txt', '/output.txt') |
||
File.rename('docs', 'mydocs') |
File.rename('docs', 'mydocs') |
||
File.rename('/docs', '/mydocs')</ |
File.rename('/docs', '/mydocs')</syntaxhighlight> |
||
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). |
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). |
||
< |
<syntaxhighlight lang="ruby">require 'fileutils' |
||
moves = { "input.txt" => "output.txt", "/input.txt" => "/output.txt", "docs" => "mydocs","/docs" => "/mydocs"} |
moves = { "input.txt" => "output.txt", "/input.txt" => "/output.txt", "docs" => "mydocs","/docs" => "/mydocs"} |
||
moves.each{ |src, dest| FileUtils.move( src, dest, :verbose => true ) }</ |
moves.each{ |src, dest| FileUtils.move( src, dest, :verbose => true ) }</syntaxhighlight> |
||
=={{header|Run BASIC}}== |
=={{header|Run BASIC}}== |
||
RB has no direct command. You Shell out to windows or unix. |
RB has no direct command. You Shell out to windows or unix. |
||
< |
<syntaxhighlight lang="runbasic">a$ = shell$("RENAME input.txt output.txt") |
||
a$ = shell$("RENAME docs mydocs") |
a$ = shell$("RENAME docs mydocs") |
||
a$ = shell$("RENAME \input.txt \output.txt") |
a$ = shell$("RENAME \input.txt \output.txt") |
||
a$ = shell$("RENAME \docs \mydocs")</ |
a$ = shell$("RENAME \docs \mydocs")</syntaxhighlight> |
||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
< |
<syntaxhighlight lang="rust"> |
||
use std::fs; |
use std::fs; |
||
Line 1,078: | Line 1,385: | ||
fs::rename("/docs", "/mydocs").ok().expect(err); |
fs::rename("/docs", "/mydocs").ok().expect(err); |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
{{libheader|Scala}} |
{{libheader|Scala}} |
||
===Straight forward=== |
===Straight forward=== |
||
< |
<syntaxhighlight lang="scala">import scala.language.implicitConversions |
||
import java.io.File |
import java.io.File |
||
Line 1,094: | Line 1,401: | ||
"/tmp/mydir" renameTo "/tmp/anotherdir" |
"/tmp/mydir" renameTo "/tmp/anotherdir" |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
===Alternative=== |
===Alternative=== |
||
<syntaxhighlight lang="scala"> |
|||
<lang Scala> |
|||
object Rename1 { |
object Rename1 { |
||
def main(args: Array[String]) { |
def main(args: Array[String]) { |
||
Line 1,106: | Line 1,413: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
{{works with|Chicken Scheme}} |
{{works with|Chicken Scheme}} |
||
{{works with|Guile}} |
{{works with|Guile}} |
||
< |
<syntaxhighlight lang="scheme">(rename-file "input.txt" "output.txt") |
||
(rename-file "docs" "mydocs") |
(rename-file "docs" "mydocs") |
||
(rename-file "/input.txt" "/output.txt") |
(rename-file "/input.txt" "/output.txt") |
||
(rename-file "/docs" "/mydocs")</ |
(rename-file "/docs" "/mydocs")</syntaxhighlight> |
||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
Line 1,126: | Line 1,433: | ||
when it is started by a normal user. |
when it is started by a normal user. |
||
< |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
include "osfiles.s7i"; |
include "osfiles.s7i"; |
||
Line 1,135: | Line 1,442: | ||
moveFile("/input.txt", "/output.txt"); |
moveFile("/input.txt", "/output.txt"); |
||
moveFile("/docs", "/mydocs"); |
moveFile("/docs", "/mydocs"); |
||
end func;</ |
end func;</syntaxhighlight> |
||
Under Windows each filesystem has its own root. |
Under Windows each filesystem has its own root. |
||
Line 1,142: | Line 1,449: | ||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
< |
<syntaxhighlight lang="ruby"># Here |
||
File.rename('input.txt', 'output.txt'); |
File.rename('input.txt', 'output.txt'); |
||
File.rename('docs', 'mydocs'); |
File.rename('docs', 'mydocs'); |
||
Line 1,148: | Line 1,455: | ||
# Root dir |
# Root dir |
||
File.rename(Dir.root + %f'input.txt', Dir.root + %f'output.txt'); |
File.rename(Dir.root + %f'input.txt', Dir.root + %f'output.txt'); |
||
File.rename(Dir.root + %f'docs', Dir.root + %f'mydocs');</ |
File.rename(Dir.root + %f'docs', Dir.root + %f'mydocs');</syntaxhighlight> |
||
=={{header|Slate}}== |
=={{header|Slate}}== |
||
< |
<syntaxhighlight lang="slate">(File newNamed: 'input.txt') renameTo: 'output.txt'. |
||
(File newNamed: '/input.txt') renameTo: '/output.txt'. |
(File newNamed: '/input.txt') renameTo: '/output.txt'. |
||
(Directory newNamed: 'docs') renameTo: 'mydocs'. |
(Directory newNamed: 'docs') renameTo: 'mydocs'. |
||
(Directory newNamed: '/docs') renameTo: '/mydocs'.</ |
(Directory newNamed: '/docs') renameTo: '/mydocs'.</syntaxhighlight> |
||
=={{header|Smalltalk}}== |
=={{header|Smalltalk}}== |
||
{{works with|GNU Smalltalk}} |
{{works with|GNU Smalltalk}} |
||
< |
<syntaxhighlight lang="smalltalk">File rename: 'input.txt' to: 'output.txt'. |
||
File rename: 'docs' to: 'mydocs'. |
File rename: 'docs' to: 'mydocs'. |
||
"as for other example, this works on systems |
"as for other example, this works on systems |
||
where the root is / ..." |
where the root is / ..." |
||
File rename: '/input.txt' to: '/output.txt'. |
File rename: '/input.txt' to: '/output.txt'. |
||
File rename: '/docs' to: '/mydocs'</ |
File rename: '/docs' to: '/mydocs'</syntaxhighlight> |
||
{{works with|Smalltalk/X}} |
{{works with|Smalltalk/X}} |
||
{{works with|VisualWorks Smalltalk}} |
{{works with|VisualWorks Smalltalk}} |
||
< |
<syntaxhighlight lang="smalltalk">'input.txt' asFilename renameTo: 'output.txt'. |
||
'docs' asFilename renameTo: 'mydocs'. |
'docs' asFilename renameTo: 'mydocs'. |
||
'/input.txt' asFilename renameTo: '/output.txt'. |
'/input.txt' asFilename renameTo: '/output.txt'. |
||
'/docs' asFilename renameTo: '/mydocs'</ |
'/docs' asFilename renameTo: '/mydocs'</syntaxhighlight> |
||
{{works with|Pharo Smalltalk}} |
{{works with|Pharo Smalltalk}} |
||
< |
<syntaxhighlight lang="smalltalk">'input.txt' asFileReference renameTo: 'output.txt'. |
||
'docs' asFileReference renameTo: 'mydocs'. |
'docs' asFileReference renameTo: 'mydocs'. |
||
'/input.txt' asFileReference renameTo: '/output.txt'. |
'/input.txt' asFileReference renameTo: '/output.txt'. |
||
'/docs' asFileReference renameTo: '/mydocs'</ |
'/docs' asFileReference renameTo: '/mydocs'</syntaxhighlight> |
||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
< |
<syntaxhighlight lang="sml">OS.FileSys.rename {old = "input.txt", new = "output.txt"}; |
||
OS.FileSys.rename {old = "docs", new = "mydocs"}; |
OS.FileSys.rename {old = "docs", new = "mydocs"}; |
||
OS.FileSys.rename {old = "/input.txt", new = "/output.txt"}; |
OS.FileSys.rename {old = "/input.txt", new = "/output.txt"}; |
||
OS.FileSys.rename {old = "/docs", new = "/mydocs"};</ |
OS.FileSys.rename {old = "/docs", new = "/mydocs"};</syntaxhighlight> |
||
=={{header|Stata}}== |
=={{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. |
Use a '''[http://www.stata.com/help.cgi?shell shell]''' command. The following works on Windows, there are similar commands on other operating systems. |
||
< |
<syntaxhighlight lang="stata">!ren input.txt output.txt |
||
!ren docs mydocs</ |
!ren docs mydocs</syntaxhighlight> |
||
=={{header|Tcl}}== |
=={{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): |
<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): |
||
< |
<syntaxhighlight lang="tcl">file rename inputs.txt output.txt |
||
file rename docs mydocs |
file rename docs mydocs |
||
file rename [file nativename /inputs.txt] [file nativename /output.txt] |
file rename [file nativename /inputs.txt] [file nativename /output.txt] |
||
file rename [file nativename /docs] [file nativename /mydocs]</ |
file rename [file nativename /docs] [file nativename /mydocs]</syntaxhighlight> |
||
Without the need to work on unusual platforms like Mac OS 9, the code could be just: |
Without the need to work on unusual platforms like Mac OS 9, the code could be just: |
||
< |
<syntaxhighlight lang="tcl">file rename inputs.txt output.txt |
||
file rename docs mydocs |
file rename docs mydocs |
||
file rename /inputs.txt /output.txt |
file rename /inputs.txt /output.txt |
||
file rename /docs /mydocs</ |
file rename /docs /mydocs</syntaxhighlight> |
||
=={{header|Toka}}== |
=={{header|Toka}}== |
||
< |
<syntaxhighlight lang="toka">needs shell |
||
" input.txt" " output.txt" rename |
" input.txt" " output.txt" rename |
||
" /input.txt" " /output.txt" rename |
" /input.txt" " /output.txt" rename |
||
" docs" " mydocs" rename |
" docs" " mydocs" rename |
||
" /docs" " /mydocs" rename</ |
" /docs" " /mydocs" rename</syntaxhighlight> |
||
=={{header|TorqueScript}}== |
=={{header|TorqueScript}}== |
||
< |
<syntaxhighlight lang="torque">fileCopy("Input.txt", "Output.txt"); |
||
fileDelete("Input.txt"); |
fileDelete("Input.txt"); |
||
Line 1,218: | Line 1,525: | ||
fileCopy(%File, "OtherPath/" @ %File); |
fileCopy(%File, "OtherPath/" @ %File); |
||
fileDelete(%File); |
fileDelete(%File); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|TUSCRIPT}}== |
=={{header|TUSCRIPT}}== |
||
< |
<syntaxhighlight lang="tuscript"> |
||
$$ MODE TUSCRIPT |
$$ MODE TUSCRIPT |
||
- rename file |
- rename file |
||
Line 1,227: | Line 1,534: | ||
- rename directory |
- rename directory |
||
ERROR/STOP RENAME ("docs","mydocs",-std-) |
ERROR/STOP RENAME ("docs","mydocs",-std-) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|TXR}}== |
=={{header|TXR}}== |
||
Line 1,233: | Line 1,540: | ||
TXR works with native paths. |
TXR works with native paths. |
||
< |
<syntaxhighlight lang="txrlisp">(rename-path "input.txt" "output.txt") |
||
;; Windows (MinGW based port) |
;; Windows (MinGW based port) |
||
(rename-path "C:\\input.txt" "C:\\output.txt") |
(rename-path "C:\\input.txt" "C:\\output.txt") |
||
;; Unix; Windows (Cygwin port) |
;; Unix; Windows (Cygwin port) |
||
(rename-path "/input.txt" "/output.txt"))</ |
(rename-path "/input.txt" "/output.txt"))</syntaxhighlight> |
||
Directories are renamed the same way; <code>input.txt</code> could be a directory. |
Directories are renamed the same way; <code>input.txt</code> could be a directory. |
||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
< |
<syntaxhighlight lang="bash">mv input.txt output.txt |
||
mv /input.txt /output.txt |
mv /input.txt /output.txt |
||
mv docs mydocs |
mv docs mydocs |
||
mv /docs /mydocs</ |
mv /docs /mydocs</syntaxhighlight> |
||
=={{header|Vedit macro language}}== |
=={{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. |
Vedit allows using either '\' or '/' as directory separator character, it is automatically converted to the one used by the operating system. |
||
< |
<syntaxhighlight lang="vedit">// In current directory |
||
File_Rename("input.txt", "output.txt") |
File_Rename("input.txt", "output.txt") |
||
File_Rename("docs", "mydocs") |
File_Rename("docs", "mydocs") |
||
Line 1,255: | Line 1,562: | ||
// In the root directory |
// In the root directory |
||
File_Rename("/input.txt", "/output.txt") |
File_Rename("/input.txt", "/output.txt") |
||
File_Rename("/docs", "/mydocs")</ |
File_Rename("/docs", "/mydocs")</syntaxhighlight> |
||
=={{header|Visual Basic .NET}}== |
=={{header|Visual Basic .NET}}== |
||
Line 1,261: | Line 1,568: | ||
{{works with|Visual Basic .NET|9.0+}} |
{{works with|Visual Basic .NET|9.0+}} |
||
< |
<syntaxhighlight lang="vbnet">'Current Directory |
||
IO.Directory.Move("docs", "mydocs") |
IO.Directory.Move("docs", "mydocs") |
||
IO.File.Move("input.txt", "output.txt") |
IO.File.Move("input.txt", "output.txt") |
||
Line 1,273: | Line 1,580: | ||
IO.Path.DirectorySeparatorChar & "mydocs") |
IO.Path.DirectorySeparatorChar & "mydocs") |
||
IO.File.Move(IO.Path.DirectorySeparatorChar & "input.txt", _ |
IO.File.Move(IO.Path.DirectorySeparatorChar & "input.txt", _ |
||
IO.Path.DirectorySeparatorChar & "output.txt")</ |
IO.Path.DirectorySeparatorChar & "output.txt")</syntaxhighlight> |
||
=={{header|Wren}}== |
|||
{{libheader|Wren-ioutil}} |
|||
Wren-cli does not currently have the ability to rename directories, just files. |
|||
<syntaxhighlight lang="wren">import "./ioutil" for FileUtil |
|||
FileUtil.move("input.txt", "output.txt") |
|||
FileUtil.move("/input.txt", "/output.txt")</syntaxhighlight> |
|||
=={{header|Yabasic}}== |
|||
<syntaxhighlight lang="yabasic">if peek$("os") = "windows" then |
|||
slash$ = "\\" : com$ = "ren " |
|||
else |
|||
slash$ = "/" : com$ = "mv " |
|||
end if |
|||
system(com$ + "input.txt output.txt") |
|||
system(com$ + "docs mydocs") |
|||
system(com$ + slash$ + "input.txt " + slash$ + "output.txt") |
|||
system(com$ + slash$ + "docs " + slash$ + "mydocs")</syntaxhighlight> |
|||
=={{header|Yorick}}== |
=={{header|Yorick}}== |
||
{{trans|UNIX Shell}} |
{{trans|UNIX Shell}} |
||
< |
<syntaxhighlight lang="yorick">rename, "input.txt", "output.txt"; |
||
rename, "/input.txt", "/output.txt"; |
rename, "/input.txt", "/output.txt"; |
||
rename, "docs", "mydocs"; |
rename, "docs", "mydocs"; |
||
rename, "/docs", "/mydocs";</ |
rename, "/docs", "/mydocs";</syntaxhighlight> |
||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
Line 1,312: | Line 1,639: | ||
{{omit from|Befunge}} <!-- No filesystem support --> |
{{omit from|Befunge}} <!-- No filesystem support --> |
||
{{omit from|Brlcad}} |
{{omit from|Brlcad}} |
||
{{omit from|EasyLang}} |
|||
{{omit from|Lilypond}} |
{{omit from|Lilypond}} |
||
{{omit from|ML/I}} |
{{omit from|ML/I}} |
Latest revision as of 21:56, 16 June 2024
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Rename:
- a file called input.txt into output.txt and
- a directory called docs into mydocs.
This should be done twice:
once "here", i.e. in the current working directory and once in the filesystem root.
It can be assumed that the user has the rights to do so.
(In unix-type systems, only the user root would have
sufficient permissions in the filesystem root.)
11l
fs:rename(‘input.txt’, ‘output.txt’)
fs:rename(‘docs’, ‘mydocs’)
fs:rename(fs:path:sep‘input.txt’, fs:path:sep‘output.txt’)
fs:rename(fs:path:sep‘docs’, fs:path:sep‘mydocs’)
Action!
The attached result has been obtained under DOS 2.5.
INCLUDE "D2:IO.ACT" ;from the Action! Tool Kit
PROC Dir(CHAR ARRAY filter)
BYTE dev=[1]
CHAR ARRAY line(255)
Close(dev)
Open(dev,filter,6)
DO
InputSD(dev,line)
PrintE(line)
IF line(0)=0 THEN
EXIT
FI
OD
Close(dev)
RETURN
PROC Main()
CHAR ARRAY filter="D:*.*",
cmd="D:INPUT.TXT OUTPUT.TXT"
Put(125) PutE() ;clear screen
PrintF("Dir ""%S""%E",filter)
Dir(filter)
PrintF("Rename ""%S""%E%E",cmd)
Rename(cmd)
PrintF("Dir ""%S""%E",filter)
Dir(filter)
RETURN
- Output:
Screenshot from Atari 8-bit computer
Dir "D:*.*" DOS SYS 037 DUP SYS 042 INPUT TXT 011 617 FREE SECTORS Rename "D:INPUT.TXT OUTPUT.TXT" Dir "D:*.*" DOS SYS 037 DUP SYS 042 OUTPUT TXT 011 617 FREE SECTORS
Ada
with Ada.Directories; use Ada.Directories;
...
Rename ("input.txt", "output.txt");
Rename ("docs", "mydocs");
Rename ("/input.txt", "/output.txt");
Rename ("/docs", "/mydocs");
The behavior depends on the concrete operating system regarding:
- file name encoding issues;
- file path notation (directory separator, directory syntax etc);
- file extension syntax;
- file system root (provided there is any).
ALGOL 68
Note: reidf does not appear to be included in ALGOL 68G. Also note that file names would be Operating System dependent.
main:(
PROC rename = (STRING source name, dest name)INT:
BEGIN
FILE actual file;
INT errno = open(actual file, source name, stand back channel);
IF errno NE 0 THEN
errno
ELSE
IF reidf possible(actual file) THEN
reidf(actual file, dest name); # change the identification of the book #
errno
ELSE
close(actual file);
-1
FI
FI
END;
rename("input.txt", "output.txt");
rename("/input.txt", "/output.txt");
rename("docs", "mydocs");
rename("/docs", "/mydocs")
)
Arturo
fileFrom: "input.txt"
fileTo: "output.txt"
docsFrom: "docs"
docsTo: "mydocs"
rename fileFrom fileTo
rename.directory docsFrom docsTo
rename join.path ["/" fileFrom]
join.path ["/" fileTo]
rename.directory join.path ["/" docsFrom]
join.path ["/" docsTo]
AutoHotkey
FileMove, oldname, newname
AutoIt
FileMove("input.txt", "output.txt") FileMove("\input.txt", "\output.txt") DirMove("docs", "mydocs") DirMove("\docs", "\mydocs")
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 input.txt output.txt")}'
$ awk 'BEGIN{system("mv docs mydocs")}'
$ awk 'BEGIN{system("mv /input.txt /output.txt")}'
$ awk 'BEGIN{system("mv docs mydocs")}'
BaCon
RENAME "input.txt" TO "output.txt"
RENAME "/input.txt" TO "/output.txt"
RENAME "docs" TO "mydocs"
RENAME "/docs" TO "/mydocs"
BASIC
NAME "input.txt" AS "output.txt"
NAME "\input.txt" AS "\output.txt"
NAME "docs" AS "mydocs"
NAME "\docs" AS "\mydocs"
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.
RENAME INPUT.TXT,OUTPUT.TXT
To use a DOS command from a program, use the BASIC statement PRINT followed by CHR$(4) and the string containing the DOS command.
10 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"
Apple ProDOS does have directories. To change the current working directory to the "root" directory, issue a PREFIX / command.
10 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"
20 PRINT CHR$ (4)"RENAME DOCS,MYDOCS"
30 PRINT CHR$ (4)"PREFIX /"
40 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"
50 PRINT CHR$ (4)"RENAME DOCS,MYDOCS"
Commodore BASIC
Works with Commodore BASIC V2.0 as follows:
OPEN 15,<Device>,15,"R<DRIVE>:FilenameOLD=FilenameNEW":CLOSE 15
Works with Commodore BASIC 3.5 and above as follows:
RENAME <FilenameOLD>[,D<DRIVE>] TO <FilenameNEW> [ON U<Deviceadress>]
ZX Spectrum Basic
The ZX Spectrum basic does not not have a facility to rename a file on the microdrive. To rename a file, it is necessary to delete the file and recreate it. Alternatively, a machine code program can be used to achieve this.
Batch File
ren input.txt output.txt
ren \input.txt output.txt
ren docs mydocs
ren \docs mydocs
BBC BASIC
When the file or directory names are known as constants at 'compile time':
*RENAME input.txt output.txt
*RENAME \input.txt \output.txt
*RENAME docs. mydocs.
*RENAME \docs. \mydocs.
When the file or directory names are known only at run time:
OSCLI "RENAME input.txt output.txt"
OSCLI "RENAME \input.txt \output.txt"
OSCLI "RENAME docs. mydocs."
OSCLI "RENAME \docs. \mydocs."
Bracmat
ren$("input.txt"."output.txt") { 'ren' is based on standard C function 'rename()' }
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. }
C
#include <stdio.h>
int main()
{
rename("input.txt", "output.txt");
rename("docs", "mydocs");
rename("/input.txt", "/output.txt");
rename("/docs", "/mydocs");
return 0;
}
C#
using System;
using System.IO;
class Program {
static void Main(string[] args) {
File.Move("input.txt","output.txt");
File.Move(@"\input.txt",@"\output.txt");
Directory.Move("docs","mydocs");
Directory.Move(@"\docs",@"\mydocs");
}
}
C++
#include <cstdio>
int main()
{
std::rename("input.txt", "output.txt");
std::rename("docs", "mydocs");
std::rename("/input.txt", "/output.txt");
std::rename("/docs", "/mydocs");
return 0;
}
compiled with g++ -lboost_system -lboost_filesystem
#include "boost/filesystem.hpp"
int main()
{
boost::filesystem::rename(
boost::filesystem::path("input.txt"),
boost::filesystem::path("output.txt"));
boost::filesystem::rename(
boost::filesystem::path("docs"),
boost::filesystem::path("mydocs"));
boost::filesystem::rename(
boost::filesystem::path("/input.txt"),
boost::filesystem::path("/output.txt"));
boost::filesystem::rename(
boost::filesystem::path("/docs"),
boost::filesystem::path("/mydocs"));*/
return 0;
}
Clipper
FRename( "input.txt","output.txt")
or
RENAME input.txt TO output.txt
FRename("\input.txt","\output.txt")
or
RENAME \input.txt TO \output.txt
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.
Clojure
(import '(java.io File))
(.renameTo (File. "input.txt") (File. "output.txt"))
(.renameTo (File. "docs") (File. "mydocs"))
(.renameTo
(File. (str (File/separator) "input.txt"))
(File. (str (File/separator) "output.txt")))
(.renameTo
(File. (str (File/separator) "docs"))
(File. (str (File/separator) "mydocs")))
Common Lisp
(rename-file "input.txt" "output.txt")
(rename-file "docs" "mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")
D
std.file.rename("input.txt","output.txt");
std.file.rename("/input.txt","/output.txt");
std.file.rename("docs","mydocs");
std.file.rename("/docs","/mydocs");
DBL
XCALL RENAM ("output.txt","input.txt")
.IFDEF UNIX
XCALL SPAWN ("mv docs mydocs")
.ENDC
.IFDEF DOS
XCALL SPAWN ("ren docs mydocs")
.ENDC
.IFDEF VMS
XCALL SPAWN ("rename docs.dir mydocs.dir")
.ENDC
DCL
rename input.txt output.txt
rename docs.dir mydocs.dir
rename [000000]input.txt [000000]output.txt
rename [000000]docs.dir [000000]mydocs.dir
Delphi
program RenameFile;
{$APPTYPE CONSOLE}
uses SysUtils;
begin
SysUtils.RenameFile('input.txt', 'output.txt');
SysUtils.RenameFile('\input.txt', '\output.txt');
// RenameFile works for both files and folders
SysUtils.RenameFile('docs', 'MyDocs');
SysUtils.RenameFile('\docs', '\MyDocs');
end.
E
for where in [<file:.>, <file:///>] {
where["input.txt"].renameTo(where["output.txt"], null)
where["docs"].renameTo(where["mydocs"], null)
}
Elixir
File.rename "input.txt","output.txt"
File.rename "docs", "mydocs"
File.rename "/input.txt", "/output.txt"
File.rename "/docs", "/mydocs"
Emacs Lisp
(rename-file "input.txt" "output.txt")
(rename-file "/input.txt" "/output.txt")
(rename-file "docs" "mydocs")
(rename-file "/docs" "/mydocs")
This can also be done interactively with M-x rename-file
. 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.
Erlang
file:rename("input.txt","output.txt"),
file:rename( "docs", "mydocs" ),
file:rename( "/input.txt", "/output.txt" ),
file:rename( "/docs", "/mydocs" ).
ERRE
Renaming a file using ERRE language is a operating system-dependant operation. In PC version you must use the SHELL command like:
CMD$="REN "+OLDFILENAME$+" "+NEWFILENAME$ SHELL CMD$
with an obvious meaning of the string variables. You can specify a path using DOS conventions. In C64 version you must use
OPEN(15,8,15,"R0:"+NF$+"="+OF$) CLOSE(15)
with an obvious meaning of the string variables.
F#
open System.IO
[<EntryPoint>]
let main args =
File.Move("input.txt","output.txt")
File.Move(@"\input.txt",@"\output.txt")
Directory.Move("docs","mydocs")
Directory.Move(@"\docs",@"\mydocs")
0
Factor
"" "/" [
[ "input.txt" "output.txt" move-file "docs" "mydocs" move-file ] with-directory
] bi@
Fantom
class Rename
{
public static Void main ()
{
// rename file/dir in current directory
File.rename("input.txt".toUri).rename("output.txt")
File.rename("docs/".toUri).rename("mydocs/")
// rename file/dir in root directory
File.rename("/input.txt".toUri).rename("/output.txt")
File.rename("/docs/".toUri).rename("/mydocs/")
}
}
Forth
s" input.txt" s" output.txt" rename-file throw
s" /input.txt" s" /output.txt" rename-file throw
Fortran
Using UNIX extensions to Fortran 77 (see e.g. g77 manual) :
PROGRAM EX_RENAME
CALL RENAME('input.txt','output.txt')
CALL RENAME('docs','mydocs')
CALL RENAME('/input.txt','/output.txt')
CALL RENAME('/docs','/mydocs')
END
FreeBASIC
' FB 1.05.0 Win64
Dim result As Long
result = Name("input.txt", "output.txt")
If result <> 0 Then
Print "Renaming file failed"
End If
result = Name("docs", "mydocs")
If result <> 0 Then
Print "Renaming directory failed"
End If
Sleep
FutureBasic
CFURLRef inputText, outputText, docs, myDocs
inputText = fn URLFileURLWithPath( @"~/Desktop/input.txt" )
outputText = fn URLFileURLWithPath( @"~/Desktop/output.txt" )
docs = fn URLFileURLWithPath( @"~/Desktop/docs/" )
myDocs = fn URLFileURLWithPath( @"~/Desktop/myDocs/" )
fn FileManagerMoveItemAtURL( inputText, outputText )
fn FileManagerMoveItemAtURL( docs, myDocs )
Go
package main
import "os"
func main() {
os.Rename("input.txt", "output.txt")
os.Rename("docs", "mydocs")
os.Rename("/input.txt", "/output.txt")
os.Rename("/docs", "/mydocs")
}
Groovy
Using File
['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst ->
['.', ''].each { dir ->
new File("$dir/$src").renameTo(new File("$dir/$dst"))
}
}
Using Ant
['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst ->
['.', ''].each { dir ->
new AntBuilder().move(file:"$dir/$src", toFile:"$dir/$dst")
}
}
Harbour
FRename( "input.txt","output.txt")
// or
RENAME input.txt TO output.txt
FRename( hb_ps() + "input.txt", hb_ps() + "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.
Haskell
import System.IO
import System.Directory
main = do
renameFile "input.txt" "output.txt"
renameDirectory "docs" "mydocs"
renameFile "/input.txt" "/output.txt"
renameDirectory "/docs" "/mydocs"
HicEst
WRITE(FIle='input.txt', REName='.\output.txt')
SYSTEM(DIR='E:\HicEst\Rosetta')
WRITE(FIle='.\docs', REName='.\mydocs')
WRITE(FIle='\input.txt', REName='\output.txt')
SYSTEM(DIR='\')
WRITE(FIle='\docs', REName='\mydocs')
Icon and Unicon
Icon supports 'rename' for files only.
every dir := !["./","/"] do {
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.
Io
// rename file in current directory
f := File with("input.txt")
f moveTo("output.txt")
// rename file in root directory
f := File with("/input.txt")
f moveTo("/output.txt")
// rename directory in current directory
d := Directory with("docs")
d moveTo("mydocs")
// rename directory in root directory
d := Directory with("/docs")
d moveTo("/mydocs")
J
J does not ship with a built-in utility for renaming files. The following will work on Windows, Linux and Macs:
frename=: 4 : 0
if. x -: y do. return. end.
if. IFUNIX do.
hostcmd=. [: 2!:0 '('"_ , ] , ' || true)'"_
hostcmd 'mv "',y,'" "',x,'"'
else.
'kernel32 MoveFileA i *c *c' 15!:0 y;x
end.
)
Useage:
'output.txt' frename 'input.txt'
'/output.txt' frename '/input.txt'
'mydocs' frename 'docs'
'/mydocs' frename '/docs'
Java
import java.io.File;
public class FileRenameTest {
public static boolean renameFile(String oldname, String newname) {
// File (or directory) with old name
File file = new File(oldname);
// File (or directory) with new name
File file2 = new File(newname);
// Rename file (or directory)
boolean success = file.renameTo(file2);
return success;
}
public static void test(String type, String oldname, String newname) {
System.out.println("The following " + type + " called " + oldname +
( renameFile(oldname, newname) ? " was renamed as " : " could not be renamed into ")
+ newname + "."
);
}
public static void main(String args[]) {
test("file", "input.txt", "output.txt");
test("file", File.separator + "input.txt", File.separator + "output.txt");
test("directory", "docs", "mydocs");
test("directory", File.separator + "docs" + File.separator, File.separator + "mydocs" + File.separator);
}
}
JavaScript
Throws an error if the destination file/folder exists.
var fso = new ActiveXObject("Scripting.FileSystemObject")
fso.MoveFile("input.txt", "output.txt")
fso.MoveFile("c:/input.txt", "c:/output.txt")
fso.MoveFolder("docs", "mydocs")
fso.MoveFolder("c:/docs", "c:/mydocs")
Joy
"input.txt" "output.txt" frename
"/input.txt" "/output.txt" frename
"docs" "mydocs" frename
"/docs" "/mydocs" frename.
Jsish
/* File rename, in jsish */
try { File.rename('input.txt', 'output.txt', false); } catch (str) { puts(str); }
exec('touch input.txt');
puts("overwrite set true if output.txt exists");
File.rename('input.txt', 'output.txt', true);
try { File.rename('docs', 'mydocs', false); } catch (str) { puts(str); }
try { File.rename('/docs', '/mydocs', false); } catch (str) { puts(str); }
Julia
mv("input.txt", "output.txt")
mv("docs", "mydocs")
mv("/input.txt", "/output.txt")
mv("/docs", "/mydocs")
Kotlin
// version 1.0.6
/* testing on Windows 10 which needs administrative privileges
to rename files in the root */
import java.io.File
fun main(args: Array<String>) {
val oldPaths = arrayOf("input.txt", "docs", "c:\\input.txt", "c:\\docs")
val newPaths = arrayOf("output.txt", "mydocs", "c:\\output.txt", "c:\\mydocs")
var oldFile: File
var newFile: File
for (i in 0 until oldPaths.size) {
oldFile = File(oldPaths[i])
newFile = File(newPaths[i])
if (oldFile.renameTo(newFile))
println("${oldPaths[i]} successfully renamed to ${newPaths[i]}")
else
println("${oldPaths[i]} could not be renamed")
}
}
- Output:
input.txt successfully renamed to output.txt docs successfully renamed to mydocs c:\input.txt successfully renamed to c:\output.txt c:\docs successfully renamed to c:\mydocs
Lang
# Load the IO module
# Replace "<pathToIO.lm>" with the location where the io.lm Lang module was installed to without "<" and ">"
ln.loadModule(<pathToIO.lm>)
fp.rename = ($from, $to) -> {
$fileFrom = [[io]]::fp.openFile($from)
$fileTo = [[io]]::fp.openFile($to)
[[io]]::fp.rename($fileFrom, $fileTo)
[[io]]::fp.closeFile($fileFrom)
[[io]]::fp.closeFile($fileTo)
}
fp.rename(input.txt, output.txt)
fp.rename(/input.txt, /output.txt)
fp.rename(docs, mydocs)
fp.rename(/docs, /mydocs)
Lasso
// move file
local(f = file('input.txt'))
#f->moveTo('output.txt')
#f->close
// move directory, just like a file
local(d = dir('docs'))
#d->moveTo('mydocs')
// move file in root file system (requires permissions at user OS level)
local(f = file('//input.txt'))
#f->moveTo('//output.txt')
#f->close
// move directory in root file system (requires permissions at user OS level)
local(d = file('//docs'))
#d->moveTo('//mydocs')
LFE
(file:rename "input.txt" "output.txt")
(file:rename "docs" "mydocs")
(file:rename "/input.txt" "/output.txt")
(file:rename "/docs" "/mydocs")
Liberty BASIC
' LB has inbuilt 'name' command, but can also run batch files
nomainwin
name "input.txt" as "output.txt"
run "cmd.exe /c ren docs mydocs", HIDE
name "C:\input.txt" as "C:\output.txt"
run "cmd.exe /c ren C:\docs mydocs", HIDE
end
LiveCode
rename file "input.txt" to "output.txt"
rename folder "docs" to "mydocs"
rename file "/input.txt" to "/output.txt"
rename folder "/docs" to "/mydocs"
Locomotive Basic
|ren,"input.txt","output.txt"
(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.)
Lua
os.rename( "input.txt", "output.txt" )
os.rename( "/input.txt", "/output.txt" )
os.rename( "docs", "mydocs" )
os.rename( "/docs", "/mydocs" )
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}
Save.Doc A$, "this.aaa"
Print Exist("this.aaa")=true
dos "cd "+quote$(dir$)+" && del this.bbb", 100; ' using; to close dos window, and 100ms for waiting
Name this.aaa as this.bbb
Rem : Name "this.aaa" as "this.bbb" ' we can use strings or variables
Print Exist("this.bbb")=true
}
checkit
Maple
use FileTools in
Rename( "input.txt", "output.txt" );
Rename( "docs", "mydocs" );
Rename( "/input.txt", "/output.txt" ); # assuming permissions in /
Rename( "/docs", "/mydocs" ) # assuming permissions in /
end use:
Mathematica/Wolfram Language
SetDirectory[NotebookDirectory[]]
RenameFile["input.txt", "output.txt"]
RenameDirectory["docs", "mydocs"]
SetDirectory[$RootDirectory]
RenameFile["input.txt", "output.txt"]
RenameDirectory["docs", "mydocs"]
MATLAB / Octave
[STATUS, MSG, MSGID] = movefile (F1, F2);
MAXScript
MAXScript has no folder rename method
-- Here
renameFile "input.txt" "output.txt"
-- Root
renameFile "/input.txt" "/output.txt"
Mercury
:- module rename_file.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module dir.
main(!IO) :-
rename_file("input.txt", "output.txt", !IO),
rename_file("docs", "mydocs", !IO),
rename_file("/input.txt", "/output.txt", !IO),
rename_file("/docs", "/mydocs", !IO).
:- pred rename_file(string::in, string::in, io::di, io::uo) is det.
rename_file(OldName, NewName, !IO) :-
io.rename_file(OldName, NewName, Result, !IO),
(
Result = ok
;
Result = error(Error),
print_io_error(Error, !IO)
).
:- pred print_io_error(io.error::in, io::di, io::uo) is det.
print_io_error(Error, !IO) :-
io.stderr_stream(Stderr, !IO),
io.write_string(Stderr, io.error_message(Error), !IO),
io.nl(Stderr, !IO),
io.set_exit_status(1, !IO).
min
"input.txt" "output.txt" mv
"docs" "mydocs" mv
"/input.txt" "/output.txt" mv
"/docs" "/mydocs" mv
MUMPS
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.
In Cache on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:
;Local
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")
S X=$ZF(-1,"rename [000000]docs.dir [000000]mydocs.dir")
NetRexx
/* NetRexx */
options replace format comments java crossref symbols binary
runSample(arg)
return
-- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
method isFileRenamed(oldFile, newFile) public static returns boolean
fo = File(oldFile)
fn = File(newFile)
fRenamed = fo.renameTo(fn)
return fRenamed
-- 09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)09:11, 27 August 2022 (UTC)~~
method runSample(arg) private static
parse arg files
if files = '' then files = 'input.txt output.txt F docs mydocs D /input.txt /output.txt F /docs /mydocs D'
loop while files.length > 0
parse files of nf ft files
select case(ft.upper())
when 'F' then do
ft = 'File'
end
when 'D' then do
ft = 'Directory'
end
otherwise do
ft = 'File'
end
end
if isFileRenamed(of, nf) then dl = 'renamed'
else dl = 'not renamed'
say ft ''''of'''' dl 'to' nf
end
return
NewLISP
(rename-file "./input.txt" "./output.txt")
(rename-file "./docs" "./mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")
Nim
import os
moveFile("input.txt", "output.txt")
moveFile("docs", "mydocs")
moveFile(DirSep & "input.txt", DirSep & "output.txt")
moveFile(DirSep & "docs", DirSep & "mydocs")
Objeck
use IO;
bundle Default {
class FileExample {
function : Main(args : String[]) ~ Nil {
File->Rename("input.txt", "output.txt");
File->Rename("docs", "mydocs");
File->Rename("/input.txt", "/output.txt");
File->Rename("/docs", "/mydocs");
}
}
}
Objective-C
NSFileManager *fm = [NSFileManager defaultManager];
// Pre-OS X 10.5
[fm movePath:@"input.txt" toPath:@"output.txt" handler:nil];
[fm movePath:@"docs" toPath:@"mydocs" handler:nil];
// OS X 10.5+
[fm moveItemAtPath:@"input.txt" toPath:@"output.txt" error:NULL];
[fm moveItemAtPath:@"docs" toPath:@"mydocs" error:NULL];
OCaml
let () =
Sys.rename "input.txt" "output.txt";
Sys.rename "docs" "mydocs";
Sys.rename "/input.txt" "/output.txt";
Sys.rename "/docs" "/mydocs";
Octave
rename('docs','mydocs');
rename('input.txt','/output.txt');
rename('/docs','/mydocs');
OpenEdge/Progress
OS-RENAME "input.txt" "output.txt".
OS-RENAME "docs" "mydocs".
OS-RENAME "/input.txt" "/output.txt".
OS-RENAME "/docs" "/mydocs".
PARI/GP
GP has no built-in facilities for renaming, but can use a system call:
system("mv input.txt output.txt");
system("mv /input.txt /output.txt");
system("mv docs mydocs");
system("mv /docs /mydocs");
PARI, as usual, has access to all the standard C methods.
Alternatively it's possible to bind rename() system call to a new function:
install("rename","iss","rename");
rename("input.txt", "output.txt");
Pascal
var
f : file ; // Untyped file
begin
// as current directory
AssignFile(f,'input.doc');
Rename(f,'output.doc');
// as root directory
AssignFile(f,'\input.doc');
Rename(f,'\output.doc');
// rename a directory
AssignFile(f,'docs');
Rename(f,'mydocs');
//rename a directory off the root
AssignFile(f,'\docs');
Rename(f,'\mydocs');
end;
PascalABC.NET
uses System.IO;
begin
&File.Move('input.txt','output.txt');
&File.Move('\input.txt','\output.txt');
Directory.Move('docs','mydocs');
Directory.Move('\docs','\mydocs');
end.
Perl
use File::Copy qw(move);
use File::Spec::Functions qw(catfile rootdir);
# here
move 'input.txt', 'output.txt';
move 'docs', 'mydocs';
# root dir
move (catfile rootdir, 'input.txt'), (catfile rootdir, 'output.txt');
move (catfile rootdir, 'docs'), (catfile rootdir, 'mydocs');
The core rename($oldfile,$newfile)
can rename a file within a directory, but has the usual limitations of the rename()
system call or C library function, which means generally not working across filesystems, and perhaps not working to rename directories. move()
does a copy and delete when necessary.
Phix
Windows now makes it fairly difficult to rename files in the root directory, even by hand. Output is 0 for success, 1 for failure.
without js -- (file i/o) ?rename_file("input.txt","output.txt") ?rename_file("docs","mydocs") ?rename_file("C:\\Copy.txt","Copy.xxx") ?rename_file("C:\\docs","C:\\mydocs")
Phixmonti
_platform "windows" == if "\\" "ren " else "/" "mv " endif
var com var slash
com "input.txt output.txt" chain cmd
com "docs mydocs" chain cmd
com slash chain "input.txt " chain slash chain "output.txt" chain cmd
com slash chain "docs " chain slash chain "mydocs" chain cmd
PHP
<?php
rename('input.txt', 'output.txt');
rename('docs', 'mydocs');
rename('/input.txt', '/output.txt');
rename('/docs', '/mydocs');
?>
PicoLisp
(call 'mv "input.txt" "output.txt")
(call 'mv "docs" "mydocs")
(call 'mv "/input.txt" "/output.txt")
(call 'mv "/docs" "/mydocs")
Pike
int main(){
mv("input.txt", "output.txt");
mv("/input.txt", "/output.txt");
mv("docs", "mydocs");
mv("/docs", "/mydocs");
}
Plain English
To run:
Start up.
\ In the current working directory
Rename ".\input.txt" to ".\output.txt" in the file system.
Rename ".\docs\" to ".\mydocs\" in the file system.
\ In the filesystem root
Rename "C:\input.txt" to "C:\output.txt" in the file system.
Rename "C:\docs\" to "C:\mydocs\" in the file system.
Shut down.
Pop11
sys_file_move('inputs.txt', 'output.txt');
sys_file_move('docs', 'mydocs');
sys_file_move('/inputs.txt', '/output.txt');
sys_file_move(/'docs', '/mydocs');
Note that notion of the root of filesystem is Unix specific, so above we do not try to suport other systems.
PowerShell
Rename-Item input.txt output.txt
# The Rename-item has the alias ren
ren input.txt output.txt
Processing
void setup(){
boolean sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt"));
boolean sketchfold = rename(sketchPath("docs"), sketchPath("mydocs"));
// sketches will seldom have write permission to root files/folders
boolean rootfile = rename("input.txt", "output.txt");
boolean rootfold = rename("docs", "mydocs");
// true if succeeded, false if failed
println(sketchfile, sketchfold, rootfile, rootfold);
}
boolean rename(String oldname, String newname) {
// File (or directory) with old name
File file = new File(oldname);
// File (or directory) with new name
File file2 = new File(newname);
// Rename file (or directory)
boolean success = file.renameTo(file2);
return success;
}
Processing Python mode
from java.io import File
def setup():
# rename local file
sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt"))
# rename local folder
sketchfold = rename(sketchPath("docs"), sketchPath("mydocs"))
# rename root file (if permitted)
rootfile = rename("input.txt", "output.txt")
# rename root folder (if permitted)
rootfold = rename("docs", "mydocs")
# display results of four operations: True=success, False=fail
println(str(sketchfile) + ' ' +
str(sketchfold) + ' ' +
str(rootfile) + ' ' +
str(rootfold))
# output:
# True True False False
def rename(oldname, newname):
# File (or directory) with old name
file = File(oldname)
# File (or directory) with new name
file2 = File(newname)
# Rename file (or directory)
success = file.renameTo(file2)
return success
ProDOS
rename input.txt to output.txt
rename docs to mydocs
PureBasic
RenameFile("input.txt", "output.txt")
RenameFile("docs\", "mydocs\")
RenameFile("/input.txt","/output.txt")
RenameFile("/docs\","/mydocs\")
Python
import os
os.rename("input.txt", "output.txt")
os.rename("docs", "mydocs")
os.rename(os.sep + "input.txt", os.sep + "output.txt")
os.rename(os.sep + "docs", os.sep + "mydocs")
Or the alternative:
import shutil
shutil.move("input.txt", "output.txt")
shutil.move("docs", "mydocs")
shutil.move("/input.txt", "/output.txt")
shutil.move("/docs", "/mydocs")
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'):
os.rename('input.txt', 'output.txt')
" python
$ "
import os
if os.path.exists('docs'):
os.rename('docs', 'mydocs')
" python
$ "
import os
if os.path.exists('/input.txt'):
os.rename('/input.txt', '/output.txt')
" python
$ "
import os
if os.path.exists('/docs'):
os.rename('/docs', '/mydocs')
" python
Racket
#lang racket
(rename-file-or-directory "input.txt" "output.txt")
(rename-file-or-directory "docs" "mydocs")
;; find the filesystem roots, and pick the first one
(define root (first (filesystem-root-list)))
(rename-file-or-directory (build-path root "input.txt")
(build-path root "output.txt"))
(rename-file-or-directory (build-path root "docs")
(build-path root "mydocs"))
Raku
(formerly Perl 6)
rename 'input.txt', 'output.txt';
rename 'docs', 'mydocs';
rename '/input.txt', '/output.txt';
rename '/docs', '/mydocs';
Raven
`mv /path/to/file/oldfile /path/to/file/newfile` shell
REALbasic
This should work regardless of what OS it's running under (but untested under Mac OS).
Sub Renamer()
Dim f As FolderItem, r As FolderItem
f = GetFolderItem("input.txt")
'Changing a FolderItem's Name attribute renames the file or directory.
If f.Exists Then f.Name = "output.txt"
'Files and directories are handled almost identically in RB.
f = GetFolderItem("docs")
If f.Exists Then f.Name = "mydocs"
'Jump through hoops to find the root directory.
r = RootDir(GetFolderItem("."))
f = r.Child("input.txt")
'Renaming in a different directory identical to renaming in current directory.
If f.Exists Then f.Name = "output.txt"
f = r.Child("docs")
If f.Exists Then f.Name = "mydocs"
End Sub
Function RootDir(what As FolderItem) As FolderItem
'RB doesn't have an easy way to find the root of the current drive;
'not an issue under *nix but troublesome under Windows.
If what.Parent <> Nil Then 'Nil = no parent = root.
Return RootDir(what.Parent) 'Recursive.
Else
Return what
End If
End Function
REBOL
rename %input.txt %output.txt
rename %docs/ %mydocs/
; Unix. Note that there's no path specification used for the
; new name. "Rename" is not "move".
rename %/input.txt %output.txt
rename %/docs/ %mydocs/
; DOS/Windows:
rename %/c/input.txt %output.txt
rename %/c/docs/ %mydocs/
; Because REBOL treats data access schemes as uniformly as possible,
; you can do tricks like this:
rename ftp://username:password@ftp.site.com/www/input.txt %output.txt
rename ftp://username:password@ftp.site.com/www/docs/ %mydocs/
REXX
error messages shown
/*REXX program renames a file & a directory (in current dir & in root).*/
trace off /*suppress error messages, bad RC*/
do 2 /* [↓] perform this code twice. */
'RENAME' "input.txt output.txt" /*rename a particular DOS file. */
'MOVE' "\docs \mydocs" /*use (DOS) MOVE to rename a dir.*/
'CD' "\" /*for 2nd pass, change──►root dir*/
end /*2*/
/*stick a fork in it, we're done.*/
error messages suppressed
/*REXX program renames a file & a directory (in current dir & in root).*/
trace off /*suppress error messages, bad RC*/
$ = '2> NUL' /*used to suppress error messages*/
do 2 /* [↓] perform this code twice. */
'RENAME' "input.txt output.txt" $ /*rename a particular DOS file. */
'MOVE' "\docs \mydocs" $ /*use (DOS) MOVE to rename a dir.*/
'CD' "\" $ /*for 2nd pass, change──►root dir*/
end /*2*/
/*stick a fork in it, we're done.*/
Ring
rename("input.txt", "output.txt")
rename("docs", "mydocs")
rename("/input.txt", "/output.txt")
rename("/docs", "/mydocs")
RPL
RPL’s tree file system is made of variables, which can contain either programs or data, and directories. Variables and directories handling features are basic.
RPL code | Comment |
---|---|
≪ PATH { HOME } == 1 ROT IFTE → old new here ≪ IF here NOT THEN PATH HOME END IFERR old RCL THEN new CRDIR PURGE ELSE new STO old PURGE END IF here NOT THEN 2 OVER SIZE FOR j DUP j GET EVAL NEXT DROP END ≫ ≫ 'RNAME' STO |
RNAME ( ‘old’ ‘new’ boolean -- ) Set here to true if already at root Store arguments Store current path in stack and go to the root Detect if old is a directory by recalling its content If yes, create new then delete old Otherwise, store content in new, then delete old Go back to current directory following the path in stack Forget path |
- Input:
'Input' 'Output' 1 RNAME 'DOCS' 'MYDOCS' 0 RNAME
The boolean argument indicates if the renaming must be achieved in the current directory (1) or at the root (0).
Ruby
File.rename('input.txt', 'output.txt')
File.rename('/input.txt', '/output.txt')
File.rename('docs', 'mydocs')
File.rename('/docs', '/mydocs')
With 'fileutils' from the standard library: The FileUtils#move method has some more flexibility than the core File#rename method (not really demonstrated here).
require 'fileutils'
moves = { "input.txt" => "output.txt", "/input.txt" => "/output.txt", "docs" => "mydocs","/docs" => "/mydocs"}
moves.each{ |src, dest| FileUtils.move( src, dest, :verbose => true ) }
Run BASIC
RB has no direct command. You Shell out to windows or unix.
a$ = shell$("RENAME input.txt output.txt")
a$ = shell$("RENAME docs mydocs")
a$ = shell$("RENAME \input.txt \output.txt")
a$ = shell$("RENAME \docs \mydocs")
Rust
use std::fs;
fn main() {
let err = "File move error";
fs::rename("input.txt", "output.txt").ok().expect(err);
fs::rename("docs", "mydocs").ok().expect(err);
fs::rename("/input.txt", "/output.txt").ok().expect(err);
fs::rename("/docs", "/mydocs").ok().expect(err);
}
Scala
Straight forward
import scala.language.implicitConversions
import java.io.File
object Rename0 {
def main(args: Array[String]) { // The implicit causes every String to File mapping,
implicit def file(s: String) = new File(s) // will be converted to new File(String)
"myfile.txt" renameTo "anotherfile.txt"
"/tmp/myfile.txt" renameTo "/tmp/anotherfile.txt"
"mydir" renameTo "anotherdir"
"/tmp/mydir" renameTo "/tmp/anotherdir"
}
}
Alternative
object Rename1 {
def main(args: Array[String]) {
List(("myfile.txt", "anotherfile.txt"),("/tmp/myfile.txt", "/tmp/anotherfile.txt"),
("mydir", "anotherdir"),("/tmp/mydir", "/tmp/anotherdir")).foreach{ case (oldf, newf) ⇒
new java.io.File(oldf) renameTo new java.io.File(newf)
}
}
}
Scheme
(rename-file "input.txt" "output.txt")
(rename-file "docs" "mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")
Seed7
The library osfiles.s7i defines the function moveFile, which renames / moves a file. Seed7 uses a standard path representation to make paths operating system independent. In the standard path representation a / is used as path delimiter and drive letters like C: must be written as /c instead. Creating files and directories in a file system root may need privileges, so the program may fail, when it is started by a normal user.
$ include "seed7_05.s7i";
include "osfiles.s7i";
const proc: main is func
begin
moveFile("input.txt", "output.txt");
moveFile("docs", "mydocs");
moveFile("/input.txt", "/output.txt");
moveFile("/docs", "/mydocs");
end func;
Under Windows each filesystem has its own root. Therefore you need to replace "/input.txt", "/output.txt", "/docs" and "/mydocs" with "/c/input.txt", "/c/output.txt", "/c/docs" and "/c/mydocs".
Sidef
# Here
File.rename('input.txt', 'output.txt');
File.rename('docs', 'mydocs');
# Root dir
File.rename(Dir.root + %f'input.txt', Dir.root + %f'output.txt');
File.rename(Dir.root + %f'docs', Dir.root + %f'mydocs');
Slate
(File newNamed: 'input.txt') renameTo: 'output.txt'.
(File newNamed: '/input.txt') renameTo: '/output.txt'.
(Directory newNamed: 'docs') renameTo: 'mydocs'.
(Directory newNamed: '/docs') renameTo: '/mydocs'.
Smalltalk
File rename: 'input.txt' to: 'output.txt'.
File rename: 'docs' to: 'mydocs'.
"as for other example, this works on systems
where the root is / ..."
File rename: '/input.txt' to: '/output.txt'.
File rename: '/docs' to: '/mydocs'
'input.txt' asFilename renameTo: 'output.txt'.
'docs' asFilename renameTo: 'mydocs'.
'/input.txt' asFilename renameTo: '/output.txt'.
'/docs' asFilename renameTo: '/mydocs'
'input.txt' asFileReference renameTo: 'output.txt'.
'docs' asFileReference renameTo: 'mydocs'.
'/input.txt' asFileReference renameTo: '/output.txt'.
'/docs' asFileReference renameTo: '/mydocs'
Standard ML
OS.FileSys.rename {old = "input.txt", new = "output.txt"};
OS.FileSys.rename {old = "docs", new = "mydocs"};
OS.FileSys.rename {old = "/input.txt", new = "/output.txt"};
OS.FileSys.rename {old = "/docs", new = "/mydocs"};
Stata
Use a shell command. The following works on Windows, there are similar commands on other operating systems.
!ren input.txt output.txt
!ren docs mydocs
Tcl
Assuming 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 inputs.txt output.txt
file rename docs mydocs
file rename [file nativename /inputs.txt] [file nativename /output.txt]
file rename [file nativename /docs] [file nativename /mydocs]
Without the need to work on unusual platforms like Mac OS 9, the code could be just:
file rename inputs.txt output.txt
file rename docs mydocs
file rename /inputs.txt /output.txt
file rename /docs /mydocs
Toka
needs shell
" input.txt" " output.txt" rename
" /input.txt" " /output.txt" rename
" docs" " mydocs" rename
" /docs" " /mydocs" rename
TorqueScript
fileCopy("Input.txt", "Output.txt");
fileDelete("Input.txt");
for(%File = FindFirstFile("Path/*.*"); %File !$= ""; %File = FindNextFile("Path/*.*"))
{
fileCopy(%File, "OtherPath/" @ %File);
fileDelete(%File);
}
TUSCRIPT
$$ MODE TUSCRIPT
- rename file
ERROR/STOP RENAME ("input.txt","output.txt")
- rename directory
ERROR/STOP RENAME ("docs","mydocs",-std-)
TXR
TXR works with native paths.
(rename-path "input.txt" "output.txt")
;; Windows (MinGW based port)
(rename-path "C:\\input.txt" "C:\\output.txt")
;; Unix; Windows (Cygwin port)
(rename-path "/input.txt" "/output.txt"))
Directories are renamed the same way; input.txt
could be a directory.
UNIX Shell
mv input.txt output.txt
mv /input.txt /output.txt
mv docs mydocs
mv /docs /mydocs
Vedit macro language
Vedit allows using either '\' or '/' as directory separator character, it is automatically converted to the one used by the operating system.
// In current directory
File_Rename("input.txt", "output.txt")
File_Rename("docs", "mydocs")
// In the root directory
File_Rename("/input.txt", "/output.txt")
File_Rename("/docs", "/mydocs")
Visual Basic .NET
Platform: .NET
'Current Directory
IO.Directory.Move("docs", "mydocs")
IO.File.Move("input.txt", "output.txt")
'Root
IO.Directory.Move("\docs", "\mydocs")
IO.File.Move("\input.txt", "\output.txt")
'Root, platform independent
IO.Directory.Move(IO.Path.DirectorySeparatorChar & "docs", _
IO.Path.DirectorySeparatorChar & "mydocs")
IO.File.Move(IO.Path.DirectorySeparatorChar & "input.txt", _
IO.Path.DirectorySeparatorChar & "output.txt")
Wren
Wren-cli does not currently have the ability to rename directories, just files.
import "./ioutil" for FileUtil
FileUtil.move("input.txt", "output.txt")
FileUtil.move("/input.txt", "/output.txt")
Yabasic
if peek$("os") = "windows" then
slash$ = "\\" : com$ = "ren "
else
slash$ = "/" : com$ = "mv "
end if
system(com$ + "input.txt output.txt")
system(com$ + "docs mydocs")
system(com$ + slash$ + "input.txt " + slash$ + "output.txt")
system(com$ + slash$ + "docs " + slash$ + "mydocs")
Yorick
rename, "input.txt", "output.txt";
rename, "/input.txt", "/output.txt";
rename, "docs", "mydocs";
rename, "/docs", "/mydocs";
zkl
Tested on Linux and Windows 10.
- Output:
ls -ld input.txt docs output.txt mydocs ls: cannot access 'output.txt': No such file or directory ls: cannot access 'mydocs': No such file or directory drwxr-xr-x 2 craigd craigd 4096 Aug 10 16:24 docs -rw-r--r-- 1 craigd craigd 0 Aug 10 16:24 input.txt $ zkl zkl: File.rename("input.txt","output.txt") True zkl: File.rename("docs","mydocs") True zkl: ^D $ ls -ld input.txt docs output.txt mydocs ls: cannot access 'input.txt': No such file or directory ls: cannot access 'docs': No such file or directory drwxr-xr-x 2 craigd craigd 4096 Aug 10 16:24 mydocs -rw-r--r-- 1 craigd craigd 0 Aug 10 16:24 output.txt
If don't have permissions (amongst other things):
zkl: File.rename("/input.txt","/output.txt") Exception thrown: IOError(rename(/input.txt,/output.txt): Permission denied)
- Programming Tasks
- File System Operations
- 11l
- Action!
- Action! Tool Kit
- Ada
- ALGOL 68
- Arturo
- AutoHotkey
- AutoIt
- AWK
- BaCon
- BASIC
- Applesoft BASIC
- Commodore BASIC
- ZX Spectrum Basic
- Batch File
- BBC BASIC
- Bracmat
- C
- C sharp
- C++
- Boost
- Clipper
- Clojure
- Common Lisp
- D
- DBL
- DCL
- Delphi
- E
- Elixir
- Emacs Lisp
- Erlang
- ERRE
- F Sharp
- Factor
- Fantom
- Forth
- Fortran
- FreeBASIC
- FutureBasic
- Go
- Groovy
- Harbour
- Haskell
- HicEst
- Icon
- Unicon
- Io
- J
- Java
- JavaScript
- Joy
- Jsish
- Julia
- Kotlin
- Lang
- Lang-io-module
- Lasso
- LFE
- Liberty BASIC
- LiveCode
- Locomotive Basic
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- MAXScript
- Mercury
- Min
- MUMPS
- NetRexx
- NewLISP
- Nim
- Objeck
- Objective-C
- OCaml
- OpenEdge/Progress
- PARI/GP
- Pascal
- PascalABC.NET
- Perl
- Phix
- Phixmonti
- PHP
- PicoLisp
- Pike
- Plain English
- Pop11
- PowerShell
- Processing
- ProDOS
- PureBasic
- Python
- Quackery
- Racket
- Raku
- Raven
- REALbasic
- REBOL
- REXX
- Ring
- RPL
- Ruby
- Run BASIC
- Rust
- Scala
- Scheme
- Seed7
- Sidef
- Slate
- Smalltalk
- Standard ML
- Stata
- Tcl
- Toka
- TorqueScript
- TUSCRIPT
- TXR
- UNIX Shell
- Vedit macro language
- Visual Basic .NET
- Wren
- Wren-ioutil
- Yabasic
- Yorick
- Zkl
- Befunge/Omit
- Brlcad/Omit
- EasyLang/Omit
- Lilypond/Omit
- ML/I/Omit
- Retro/Omit
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit
- TPP/Omit
- Unlambda/Omit