Rename a file: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
(23 intermediate revisions by 18 users not shown) | |||
Line 15:
sufficient permissions in the filesystem root.)
<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}}==
<
...
Rename ("input.txt", "output.txt");
Rename ("docs", "mydocs");
Rename ("/input.txt", "/output.txt");
Rename ("/docs", "/mydocs");</
The behavior depends on the concrete [[OS | operating system]] regarding:
* file name encoding issues;
Line 35 ⟶ 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}} -->
Note: <tt>reidf</tt> does not appear to be included in [[ALGOL 68G]]. Also note that file names would be Operating System dependent.
<
PROC rename = (STRING source name, dest name)INT:
BEGIN
Line 56 ⟶ 119:
rename("docs", "mydocs");
rename("/docs", "/mydocs")
)</
=={{header|
<syntaxhighlight lang="rebol">fileFrom: "input.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]</syntaxhighlight>
=={{header|AutoHotkey}}==
<syntaxhighlight lang
=={{header|AutoIt}}==
Line 73 ⟶ 144:
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}}==
<
RENAME "/input.txt" TO "/output.txt"
RENAME "docs" TO "mydocs"
RENAME "/docs" TO "/mydocs"
</syntaxhighlight>
=={{header|BASIC}}==
<
NAME "\input.txt" AS "\output.txt"
NAME "docs" AS "mydocs"
NAME "\docs" AS "\mydocs"</
==={{header|Applesoft BASIC}}===
Apple DOS 3.3 has a flat filesystem with no concept of directories. DOS commands such as RENAME are run directly from the Applesoft prompt but are not technically part of Applesoft BASIC. Thus, attempting to add this line to a program and run it results in a syntax error on that line.
<syntaxhighlight lang
To use a DOS command from a program, use the BASIC statement PRINT followed by CHR$(4) and the string containing the DOS command.
<
Apple ProDOS does have directories. To change the current working directory to the "root" directory, issue a PREFIX / command.
<
20 PRINT CHR$ (4)"RENAME DOCS,MYDOCS"
30 PRINT CHR$ (4)"PREFIX /"
40 PRINT CHR$ (4)"RENAME INPUT.TXT,OUTPUT.TXT"
50 PRINT CHR$ (4)"RENAME DOCS,MYDOCS"</
==={{header|Commodore BASIC}}===
'''Works with'''
<
'''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}}===
Line 113 ⟶ 194:
=={{header|Batch File}}==
<
ren \input.txt output.txt
ren docs mydocs
ren \docs mydocs</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
When the file or directory names are known as constants at 'compile time':
<
*RENAME \input.txt \output.txt
*RENAME docs. mydocs.
*RENAME \docs. \mydocs.</
When the file or directory names are known only at run time:
<
OSCLI "RENAME \input.txt \output.txt"
OSCLI "RENAME docs. mydocs."
OSCLI "RENAME \docs. \mydocs."</
=={{header|Bracmat}}==
<
ren$(docs.mydocs) { No quotes needed: names don't contain dots or colons. }
ren$("d:\\input.txt"."d:\\output.txt") { Backslash is escape character, so we need to escape it. }
ren$(@"d:\docs".@"d:\mydocs") { @ used as syntactic sugar as in C# for inhibiting escape. }
</syntaxhighlight>
=={{header|C}}==
<
int main()
Line 148 ⟶ 229:
rename("/docs", "/mydocs");
return 0;
}</
=={{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++}}==
{{trans|C}}
<
int main()
Line 161 ⟶ 257:
std::rename("/docs", "/mydocs");
return 0;
}</
{{libheader|Boost}}
Line 167 ⟶ 263:
compiled with g++ -lboost_system -lboost_filesystem
<
int main()
Line 184 ⟶ 280:
boost::filesystem::path("/mydocs"));*/
return 0;
}</
=={{header|Clipper}}==
<
or
RENAME input.txt TO output.txt
Line 209 ⟶ 290:
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.
=={{header|Clojure}}==
<
(.renameTo (File. "input.txt") (File. "output.txt"))
Line 224 ⟶ 305:
(.renameTo
(File. (str (File/separator) "docs"))
(File. (str (File/separator) "mydocs")))</
=={{header|Common Lisp}}==
<code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_rn_fil.htm rename-file]</code>
<
(rename-file "docs" "mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")</
=={{header|D}}==
<
std.file.rename("/input.txt","/output.txt");
std.file.rename("docs","mydocs");
std.file.rename("/docs","/mydocs");</
=={{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}}==
<
rename docs.dir mydocs.dir
rename [000000]input.txt [000000]output.txt
rename [000000]docs.dir [000000]mydocs.dir</
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 260 ⟶ 353:
SysUtils.RenameFile('docs', 'MyDocs');
SysUtils.RenameFile('\docs', '\MyDocs');
end.</
=={{header|E}}==
<
where["input.txt"].renameTo(where["output.txt"], null)
where["docs"].renameTo(where["mydocs"], null)
}</
=={{header|Elixir}}==
<
File.rename "docs", "mydocs"
File.rename "/input.txt", "/output.txt"
File.rename "/docs", "/mydocs"</
=={{header|Emacs Lisp}}==
<
(rename-file "/input.txt" "/output.txt")
(rename-file "docs" "mydocs")
(rename-file "/docs" "/mydocs")</
This can also be done interactively with <code>M-x rename-file</code>. Programmatically the default is to throw an error if the new name already exists but the "ok-if-already-exists" parameter can either forcibly overwrite or query the user. Query is the default interactively.
Line 285 ⟶ 378:
=={{header|Erlang}}==
<
file:rename("input.txt","output.txt"),
file:rename( "docs", "mydocs" ),
file:rename( "/input.txt", "/output.txt" ),
file:rename( "/docs", "/mydocs" ).
</syntaxhighlight>
=={{header|ERRE}}==
Line 310 ⟶ 403:
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<
[<EntryPoint>]
Line 318 ⟶ 411:
Directory.Move("docs","mydocs")
Directory.Move(@"\docs",@"\mydocs")
0</
=={{header|Factor}}==
<
[ "input.txt" "output.txt" move-file "docs" "mydocs" move-file ] with-directory
] bi@</
=={{header|Fantom}}==
<
class Rename
{
Line 339 ⟶ 432:
}
}
</syntaxhighlight>
=={{header|Forth}}==
<
s" /input.txt" s" /output.txt" rename-file throw</
=={{header|Fortran}}==
Using UNIX extensions to '''Fortran 77''' (see e.g. [http://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Rename-Intrinsic-_0028subroutine_0029.html#Rename-Intrinsic-_0028subroutine_0029 g77 manual]) :
<
CALL RENAME('input.txt','output.txt')
CALL RENAME('docs','mydocs')
CALL RENAME('/input.txt','/output.txt')
CALL RENAME('/docs','/mydocs')
END</
=={{header|FreeBASIC}}==
<
Dim result As Long
Line 368 ⟶ 461:
End If
Sleep</
=={{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}}==
<
import "os"
Line 379 ⟶ 486:
os.Rename("/input.txt", "/output.txt")
os.Rename("/docs", "/mydocs")
}</
=={{header|Groovy}}==
Using File
<
['.', ''].each { dir ->
new File("$dir/$src").renameTo(new File("$dir/$dst"))
}
}</
Using Ant
<
['.', ''].each { dir ->
new AntBuilder().move(file:"$dir/$src", toFile:"$dir/$dst")
}
}</
=={{header|Harbour}}==
<
// or
RENAME input.txt TO output.txt
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.
=={{header|Haskell}}==
<
import System.Directory
Line 414 ⟶ 521:
renameDirectory "docs" "mydocs"
renameFile "/input.txt" "/output.txt"
renameDirectory "/docs" "/mydocs"</
=={{header|HicEst}}==
<
SYSTEM(DIR='E:\HicEst\Rosetta')
WRITE(FIle='.\docs', REName='.\mydocs')
Line 423 ⟶ 530:
WRITE(FIle='\input.txt', REName='\output.txt')
SYSTEM(DIR='\')
WRITE(FIle='\docs', REName='\mydocs') </
=={{header|Icon}} and {{header|Unicon}}==
Icon supports 'rename' for files only.
<
rename(f := dir || "input.txt", dir || "output.txt") |stop("failure for file rename ",f)
rename(f := dir || "docs", dir || "mydocs") |stop("failure for directory rename ",f)
}</
Note: Icon and Unicon accept both / and \ for directory separators.
=={{header|Io}}==
<syntaxhighlight lang="io">
// rename file in current directory
f := File with("input.txt")
Line 451 ⟶ 558:
d := Directory with("/docs")
d moveTo("/mydocs")
</syntaxhighlight>
=={{header|J}}==
Line 458 ⟶ 565:
The following will work on Windows, Linux and Macs:
<
if. x -: y do. return. end.
if. IFUNIX do.
Line 466 ⟶ 573:
'kernel32 MoveFileA i *c *c' 15!:0 y;x
end.
)</
Useage:
<
'/output.txt' frename '/input.txt'
'mydocs' frename 'docs'
'/mydocs' frename '/docs'</
=={{header|Java}}==
<
public class FileRenameTest {
public static boolean renameFile(String oldname, String newname) {
Line 500 ⟶ 607:
test("directory", File.separator + "docs" + File.separator, File.separator + "mydocs" + File.separator);
}
}</
=={{header|JavaScript}}==
{{works with|JScript}}
Throws an error if the destination file/folder exists.
<
fso.MoveFile("input.txt", "output.txt")
fso.MoveFile("c:/input.txt", "c:/output.txt")
fso.MoveFolder("docs", "mydocs")
fso.MoveFolder("c:/docs", "c:/mydocs")</
=={{header|Joy}}==
<syntaxhighlight lang="joy">
"input.txt" "output.txt" frename
"/input.txt" "/output.txt" frename
"docs" "mydocs" frename
"/docs" "/mydocs" frename.
</syntaxhighlight>
=={{header|Jsish}}==
<
try { File.rename('input.txt', 'output.txt', false); } catch (str) { puts(str); }
Line 528 ⟶ 635:
try { File.rename('docs', 'mydocs', false); } catch (str) { puts(str); }
try { File.rename('/docs', '/mydocs', false); } catch (str) { puts(str); }</
=={{header|Julia}}==
<
mv("input.txt", "output.txt")
mv("docs", "mydocs")
mv("/input.txt", "/output.txt")
mv("/docs", "/mydocs")</
=={{header|Kotlin}}==
<
/* testing on Windows 10 which needs administrative privileges
Line 558 ⟶ 665:
println("${oldPaths[i]} could not be renamed")
}
}</
{{out}}
Line 567 ⟶ 674:
c:\docs successfully renamed to c:\mydocs
</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}}==
<
local(f = file('input.txt'))
#f->moveTo('output.txt')
Line 585 ⟶ 715:
// move directory in root file system (requires permissions at user OS level)
local(d = file('//docs'))
#d->moveTo('//mydocs')</
=={{header|LFE}}==
<
(file:rename "input.txt" "output.txt")
(file:rename "docs" "mydocs")
(file:rename "/input.txt" "/output.txt")
(file:rename "/docs" "/mydocs")
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<
nomainwin
Line 606 ⟶ 736:
run "cmd.exe /c ren C:\docs mydocs", HIDE
end</
=={{header|LiveCode}}==
<
rename folder "docs" to "mydocs"
rename file "/input.txt" to "/output.txt"
rename folder "/docs" to "/mydocs"</
=={{header|Locomotive Basic}}==
<
([[wp:AMSDOS|AMSDOS]] RSX command, therefore prefixed with a vertical bar. Also, there are no subdirectories in AMSDOS, so there is no way to do the other tests.)
=={{header|Lua}}==
<
os.rename( "/input.txt", "/output.txt" )
os.rename( "docs", "mydocs" )
os.rename( "/docs", "/mydocs" )</
=={{header|M2000 Interpreter}}==
To delete a file we have to use Dos shell,so this can be done using Dos command
<syntaxhighlight lang="m2000 interpreter">
Module checkit {
Document A$={Alfa, beta}
Line 638 ⟶ 768:
}
checkit
</syntaxhighlight>
=={{header|Maple}}==
<
Rename( "input.txt", "output.txt" );
Rename( "docs", "mydocs" );
Rename( "/input.txt", "/output.txt" ); # assuming permissions in /
Rename( "/docs", "/mydocs" ) # assuming permissions in /
end use:</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
RenameFile["input.txt", "output.txt"]
RenameDirectory["docs", "mydocs"]
SetDirectory[$RootDirectory]
RenameFile["input.txt", "output.txt"]
RenameDirectory["docs", "mydocs"]</
=={{header|MATLAB}} / {{header|Octave}}==
<
=={{header|MAXScript}}==
MAXScript has no folder rename method
<
renameFile "input.txt" "output.txt"
-- Root
renameFile "/input.txt" "/output.txt"</
=={{header|Mercury}}==
<
:- interface.
Line 701 ⟶ 831:
io.write_string(Stderr, io.error_message(Error), !IO),
io.nl(Stderr, !IO),
io.set_exit_status(1, !IO).</
=={{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}}==
<p>ANSI MUMPS doesn't allow access to the operating system except possibly through the View command and $View function, both of which are implementation specific. Intersystems' Caché does allow you to create processes with the $ZF function, and if the permissions for the Caché process allow it you can perform operating system commands.</p>
<p>In Cache on OpenVMS in an FILES-11 filesystem ODS-5 mode these could work:</p>
<
S X=$ZF(-1,"rename input.txt output.txt")
S X=$ZF(-1,"rename docs.dir mydocs.dir")
;Root of current device
S X=$ZF(-1,"rename [000000]input.txt [000000]output.txt")
S X=$ZF(-1,"rename [000000]docs.dir [000000]mydocs.dir")</
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols binary
Line 727 ⟶ 865:
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
Line 750 ⟶ 888:
return
</syntaxhighlight>
=={{header|NewLISP}}==
<
(rename-file "./docs" "./mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")</
=={{header|Nim}}==
<
moveFile("input.txt", "output.txt")
Line 765 ⟶ 903:
moveFile(DirSep & "input.txt", DirSep & "output.txt")
moveFile(DirSep & "docs", DirSep & "mydocs")</
=={{header|Objeck}}==
<
use IO;
bundle Default {
Line 780 ⟶ 918:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
Line 787 ⟶ 925:
{{works with|GNUstep}}
<
// Pre-OS X 10.5
Line 795 ⟶ 933:
// OS X 10.5+
[fm moveItemAtPath:@"input.txt" toPath:@"output.txt" error:NULL];
[fm moveItemAtPath:@"docs" toPath:@"mydocs" error:NULL];</
=={{header|OCaml}}==
<
let () =
Sys.rename "input.txt" "output.txt";
Sys.rename "docs" "mydocs";
Sys.rename "/input.txt" "/output.txt";
Sys.rename "/docs" "/mydocs";</
=={{header|Octave}}==
<
rename('docs','mydocs');
rename('input.txt','/output.txt');
rename('/docs','/mydocs');
</syntaxhighlight>
=={{header|OpenEdge/Progress}}==
<
OS-RENAME "docs" "mydocs".
OS-RENAME "/input.txt" "/output.txt".
OS-RENAME "/docs" "/mydocs".</
=={{header|PARI/GP}}==
GP has no built-in facilities for renaming, but can use a system call:
<
system("mv /input.txt /output.txt");
system("mv docs mydocs");
system("mv /docs /mydocs");</
PARI, as usual, has access to all the standard [[#C|C]] methods.
Alternatively it's possible to bind rename() system call to a new function:
<
rename("input.txt", "output.txt");</
=={{header|Pascal}}==
<
f : file ; // Untyped file
begin
Line 853 ⟶ 991:
Rename(f,'\mydocs');
end;</
=={{header|Perl}}==
<
use File::Spec::Functions qw(catfile rootdir);
# here
Line 863 ⟶ 1,001:
# root dir
move (catfile rootdir, 'input.txt'), (catfile rootdir, 'output.txt');
move (catfile rootdir, 'docs'), (catfile rootdir, 'mydocs');</
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|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.
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (file i/o)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"input.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"output.txt"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"docs"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"mydocs"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"C:\\Copy.txt"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Copy.xxx"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">rename_file</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"C:\\docs"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"C:\\mydocs"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
=={{header|Phixmonti}}==
<
var com var slash
Line 888 ⟶ 1,023:
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</
=={{header|PHP}}==
<
rename('input.txt', 'output.txt');
rename('docs', 'mydocs');
rename('/input.txt', '/output.txt');
rename('/docs', '/mydocs');
?></
=={{header|PicoLisp}}==
<
(call 'mv "docs" "mydocs")
(call 'mv "/input.txt" "/output.txt")
(call 'mv "/docs" "/mydocs")</
=={{header|Pike}}==
<
mv("input.txt", "output.txt");
mv("/input.txt", "/output.txt");
mv("docs", "mydocs");
mv("/docs", "/mydocs");
}</
=={{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}}==
<
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
Line 922 ⟶ 1,070:
=={{header|PowerShell}}==
<
# The Rename-item has the alias ren
ren input.txt output.txt</
=={{header|Processing}}==
<
boolean sketchfile = rename(sketchPath("input.txt"), sketchPath("output.txt"));
boolean sketchfold = rename(sketchPath("docs"), sketchPath("mydocs"));
Line 946 ⟶ 1,094:
boolean success = file.renameTo(file2);
return success;
}</
===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}}==
<
rename docs to mydocs</
=={{header|PureBasic}}==
<
RenameFile("docs\", "mydocs\")
RenameFile("/input.txt","/output.txt")
RenameFile("/docs\","/mydocs\")</
=={{header|Python}}==
<
os.rename("input.txt", "output.txt")
Line 968 ⟶ 1,147:
os.rename(os.sep + "input.txt", os.sep + "output.txt")
os.rename(os.sep + "docs", os.sep + "mydocs")</
Or the alternative:
<
shutil.move("input.txt", "output.txt")
Line 978 ⟶ 1,157:
shutil.move("/input.txt", "/output.txt")
shutil.move("/docs", "/mydocs")</
=={{header|
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.
<syntaxhighlight lang="quackery"> $ "
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}}==
<
#lang racket
Line 1,001 ⟶ 1,202:
(rename-file-or-directory (build-path root "docs")
(build-path root "mydocs"))
</syntaxhighlight>
=={{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|REALbasic}}==
Line 1,010 ⟶ 1,218:
This ''should'' work regardless of what OS it's running under (but untested under [[Mac OS]]).
<
Dim f As FolderItem, r As FolderItem
Line 1,038 ⟶ 1,246:
Return what
End If
End Function</
=={{header|REBOL}}==
<
rename %docs/ %mydocs/
Line 1,060 ⟶ 1,268:
rename ftp://username:password@ftp.site.com/www/input.txt %output.txt
rename ftp://username:password@ftp.site.com/www/docs/ %mydocs/
</syntaxhighlight>
=={{header|REXX}}==
===error messages shown===
<
trace off /*suppress error messages, bad RC*/
Line 1,072 ⟶ 1,280:
'CD' "\" /*for 2nd pass, change──►root dir*/
end /*2*/
/*stick a fork in it, we're done.*/</
===error messages suppressed===
<
trace off /*suppress error messages, bad RC*/
$ = '2> NUL' /*used to suppress error messages*/
Line 1,084 ⟶ 1,292:
'CD' "\" $ /*for 2nd pass, change──►root dir*/
end /*2*/
/*stick a fork in it, we're done.*/</
=={{header|Ring}}==
<
rename("input.txt", "output.txt")
rename("docs", "mydocs")
rename("/input.txt", "/output.txt")
rename("/docs", "/mydocs")
</syntaxhighlight>
=={{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}}==
<
File.rename('/input.txt', '/output.txt')
File.rename('docs', 'mydocs')
File.rename('/docs', '/mydocs')</
With 'fileutils' from the standard library: The <tt>FileUtils#move</tt> method has some more flexibility than the core <tt>File#rename</tt> method (not really demonstrated here).
<
moves = { "input.txt" => "output.txt", "/input.txt" => "/output.txt", "docs" => "mydocs","/docs" => "/mydocs"}
moves.each{ |src, dest| FileUtils.move( src, dest, :verbose => true ) }</
=={{header|Run BASIC}}==
RB has no direct command. You Shell out to windows or unix.
<
a$ = shell$("RENAME docs mydocs")
a$ = shell$("RENAME \input.txt \output.txt")
a$ = shell$("RENAME \docs \mydocs")</
=={{header|Rust}}==
<
use std::fs;
Line 1,124 ⟶ 1,372:
fs::rename("/docs", "/mydocs").ok().expect(err);
}
</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}
===Straight forward===
<
import java.io.File
Line 1,140 ⟶ 1,388:
"/tmp/mydir" renameTo "/tmp/anotherdir"
}
}</
===Alternative===
<syntaxhighlight lang="scala">
object Rename1 {
def main(args: Array[String]) {
Line 1,152 ⟶ 1,400:
}
}
</syntaxhighlight>
=={{header|Scheme}}==
{{works with|Chicken Scheme}}
{{works with|Guile}}
<
(rename-file "docs" "mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")</
=={{header|Seed7}}==
Line 1,172 ⟶ 1,420:
when it is started by a normal user.
<
include "osfiles.s7i";
Line 1,181 ⟶ 1,429:
moveFile("/input.txt", "/output.txt");
moveFile("/docs", "/mydocs");
end func;</
Under Windows each filesystem has its own root.
Line 1,188 ⟶ 1,436:
=={{header|Sidef}}==
<
File.rename('input.txt', 'output.txt');
File.rename('docs', 'mydocs');
Line 1,194 ⟶ 1,442:
# Root dir
File.rename(Dir.root + %f'input.txt', Dir.root + %f'output.txt');
File.rename(Dir.root + %f'docs', Dir.root + %f'mydocs');</
=={{header|Slate}}==
<
(File newNamed: '/input.txt') renameTo: '/output.txt'.
(Directory newNamed: 'docs') renameTo: 'mydocs'.
(Directory newNamed: '/docs') renameTo: '/mydocs'.</
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<
File rename: 'docs' to: 'mydocs'.
"as for other example, this works on systems
where the root is / ..."
File rename: '/input.txt' to: '/output.txt'.
File rename: '/docs' to: '/mydocs'</
{{works with|Smalltalk/X}}
{{works with|VisualWorks Smalltalk}}
<
'docs' asFilename renameTo: 'mydocs'.
'/input.txt' asFilename renameTo: '/output.txt'.
'/docs' asFilename renameTo: '/mydocs'</
{{works with|Pharo Smalltalk}}
<
'docs' asFileReference renameTo: 'mydocs'.
'/input.txt' asFileReference renameTo: '/output.txt'.
'/docs' asFileReference renameTo: '/mydocs'</
=={{header|Standard ML}}==
<
OS.FileSys.rename {old = "docs", new = "mydocs"};
OS.FileSys.rename {old = "/input.txt", new = "/output.txt"};
OS.FileSys.rename {old = "/docs", new = "/mydocs"};</
=={{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.
<
!ren docs mydocs</
=={{header|Tcl}}==
<i>Assuming</i> that the Bash example shows what is actually meant with this task (one file and one directory here, one file and one directory in the root) and further assuming that this is supposed to be generic (i.e. OS agnostic):
<
file rename docs mydocs
file rename [file nativename /inputs.txt] [file nativename /output.txt]
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 docs mydocs
file rename /inputs.txt /output.txt
file rename /docs /mydocs</
=={{header|Toka}}==
<
" input.txt" " output.txt" rename
" /input.txt" " /output.txt" rename
" docs" " mydocs" rename
" /docs" " /mydocs" rename</
=={{header|TorqueScript}}==
<
fileDelete("Input.txt");
Line 1,264 ⟶ 1,512:
fileCopy(%File, "OtherPath/" @ %File);
fileDelete(%File);
}</
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
- rename file
Line 1,273 ⟶ 1,521:
- rename directory
ERROR/STOP RENAME ("docs","mydocs",-std-)
</syntaxhighlight>
=={{header|TXR}}==
Line 1,279 ⟶ 1,527:
TXR works with native paths.
<
;; 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; <code>input.txt</code> could be a directory.
=={{header|UNIX Shell}}==
<
mv /input.txt /output.txt
mv docs mydocs
mv /docs /mydocs</
=={{header|Vedit macro language}}==
Vedit allows using either '\' or '/' as directory separator character, it is automatically converted to the one used by the operating system.
<
File_Rename("input.txt", "output.txt")
File_Rename("docs", "mydocs")
Line 1,301 ⟶ 1,549:
// In the root directory
File_Rename("/input.txt", "/output.txt")
File_Rename("/docs", "/mydocs")</
=={{header|Visual Basic .NET}}==
Line 1,307 ⟶ 1,555:
{{works with|Visual Basic .NET|9.0+}}
<
IO.Directory.Move("docs", "mydocs")
IO.File.Move("input.txt", "output.txt")
Line 1,319 ⟶ 1,567:
IO.Path.DirectorySeparatorChar & "mydocs")
IO.File.Move(IO.Path.DirectorySeparatorChar & "input.txt", _
IO.Path.DirectorySeparatorChar & "output.txt")</
=={{header|
{{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}}==
<
slash$ = "\\" : com$ = "ren "
else
Line 1,338 ⟶ 1,587:
system(com$ + "docs mydocs")
system(com$ + slash$ + "input.txt " + slash$ + "output.txt")
system(com$ + slash$ + "docs " + slash$ + "mydocs")</
=={{header|Yorick}}==
{{trans|UNIX Shell}}
<syntaxhighlight lang="yorick">rename, "input.txt", "output.txt";
rename, "/input.txt", "/output.txt";
rename, "docs", "mydocs";
rename, "/docs", "/mydocs";</syntaxhighlight>
=={{header|zkl}}==
Line 1,370 ⟶ 1,626:
{{omit from|Befunge}} <!-- No filesystem support -->
{{omit from|Brlcad}}
{{omit from|EasyLang}}
{{omit from|Lilypond}}
{{omit from|ML/I}}
|