Rename a file: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
(89 intermediate revisions by 58 users not shown) | |||
Line 1:
{{task|File System Operations}}
;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.)
<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 15 ⟶ 91:
* file extension syntax;
* file system root (provided there is any).
=={{header|ALGOL 68}}==
{{works with|ALGOL 68|Standard - no extensions to language used}}
Line 21 ⟶ 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 42 ⟶ 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 59 ⟶ 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}}==
<syntaxhighlight lang="freebasic">RENAME "input.txt" TO "output.txt"
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''' 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}}===
Line 87 ⟶ 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 122 ⟶ 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 135 ⟶ 257:
std::rename("/docs", "/mydocs");
return 0;
}</
{{libheader|Boost}}
Line 141 ⟶ 263:
compiled with g++ -lboost_system -lboost_filesystem
<
int main()
Line 158 ⟶ 280:
boost::filesystem::path("/mydocs"));*/
return 0;
}</
=={{header|
<syntaxhighlight lang="clipper">FRename( "input.txt","output.txt")
or
RENAME input.txt TO output.txt
FRename("\input.txt","\output.txt")
or
RENAME
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 186 ⟶ 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 221 ⟶ 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}}==
<syntaxhighlight lang="elixir">File.rename "input.txt","output.txt"
File.rename "docs", "mydocs"
File.rename "/input.txt", "/output.txt"
File.rename "/docs", "/mydocs"</syntaxhighlight>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(rename-file "input.txt" "output.txt")
(rename-file "/input.txt" "/output.txt")
(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.
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
file:rename("input.txt","output.txt"),
file:rename( "docs", "mydocs" ),
file:rename( "/input.txt", "/output.txt" ),
file:rename( "/docs", "/mydocs" ).
</syntaxhighlight>
=={{header|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.
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<syntaxhighlight lang="fsharp">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</syntaxhighlight>
=={{header|Factor}}==
<
[ "input.txt" "output.txt" move-file "docs" "mydocs" move-file ] with-directory
] bi@</
=={{header|Fantom}}==
<
class Rename
{
Line 253 ⟶ 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}}==
<syntaxhighlight lang="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</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}}==
<
import "os"
Line 277 ⟶ 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}}==
<syntaxhighlight lang="visualfoxpro">FRename( "input.txt","output.txt")
// or
RENAME input.txt TO 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.
=={{header|Haskell}}==
<
import System.Directory
Line 302 ⟶ 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 311 ⟶ 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")
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")
</syntaxhighlight>
=={{header|J}}==
Line 326 ⟶ 565:
The following will work on Windows, Linux and Macs:
<
if. x -: y do. return. end.
if. IFUNIX do.
Line 334 ⟶ 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 368 ⟶ 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(
fso.MoveFile(
fso.MoveFolder(
fso.MoveFolder(
=={{header|Joy}}==
<syntaxhighlight lang="joy">
"input.txt" "output.txt" frename
"/input.txt" "/output.txt" frename
"docs" "mydocs" frename
"/docs" "/mydocs" frename.
</syntaxhighlight>
=={{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}}==
<syntaxhighlight lang="julia">
mv("input.txt", "output.txt")
mv("docs", "mydocs")
mv("/input.txt", "/output.txt")
mv("/docs", "/mydocs")</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// 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")
}
}</syntaxhighlight>
{{out}}
<pre>
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
</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}}==
<syntaxhighlight lang="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')</syntaxhighlight>
=={{header|LFE}}==
<syntaxhighlight lang="lisp">
(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 397 ⟶ 736:
run "cmd.exe /c ren C:\docs mydocs", HIDE
end</
=={{header|LiveCode}}==
<syntaxhighlight lang="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"</syntaxhighlight>
=={{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}
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
</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}}==
<syntaxhighlight lang="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).</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}}==
<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}}==
<syntaxhighlight lang="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
</syntaxhighlight>
=={{header|NewLISP}}==
<
(rename-file "./docs" "./mydocs")
(rename-file "/input.txt" "/output.txt")
(rename-file "/docs" "/mydocs")</
=={{header|Nim}}==
<syntaxhighlight lang="nim">import os
moveFile("input.txt", "output.txt")
moveFile("docs", "mydocs")
moveFile(DirSep & "input.txt", DirSep & "output.txt")
moveFile(DirSep & "docs", DirSep & "mydocs")</syntaxhighlight>
=={{header|Objeck}}==
<
use IO;
bundle Default {
class FileExample {
function
File->Rename("input.txt", "output.txt");
File->Rename("docs", "mydocs");
Line 481 ⟶ 918:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
{{works with|Cocoa}}
{{works with|GNUstep}}
<syntaxhighlight lang="objc">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];</syntaxhighlight>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">
let () =
Sys.rename "
Sys.rename "
Sys.rename "/input.txt" "/output.txt";
Sys.rename "/docs" "/mydocs";</syntaxhighlight>
=={{header|Octave}}==
<syntaxhighlight lang
rename('docs','mydocs');
rename('input.txt','/output.txt');
rename('/docs','/mydocs');
</syntaxhighlight>
=={{header|
<syntaxhighlight lang
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:
<syntaxhighlight lang="parigp">install("rename","iss","rename");
rename("input.txt", "output.txt");</syntaxhighlight>
=={{header|Pascal}}==
<
f : file ; // Untyped file
begin
Line 532 ⟶ 991:
Rename(f,'\mydocs');
end;</
=={{header|Perl}}==
<
use File::Spec::Functions qw(catfile rootdir);
# here
Line 542 ⟶ 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}}==
<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}}==
<
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 581 ⟶ 1,070:
=={{header|PowerShell}}==
<
# The Rename-item has the alias ren
ren input.txt output.txt</
=={{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}}==
<
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 606 ⟶ 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 616 ⟶ 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}}==
<syntaxhighlight lang="racket">
#lang racket
Line 639 ⟶ 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}}==
<syntaxhighlight lang="raven">`mv /path/to/file/oldfile /path/to/file/newfile` shell</syntaxhighlight>
=={{header|REALbasic}}==
Line 645 ⟶ 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 673 ⟶ 1,246:
Return what
End If
End Function</
=={{header|REBOL}}==
<
rename %docs/ %mydocs/
Line 695 ⟶ 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===
<syntaxhighlight lang="rexx">/*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*/
/*stick a fork in it, we're done.*/</syntaxhighlight>
===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*/
$ = '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.*/</syntaxhighlight>
=={{header|Ring}}==
<syntaxhighlight lang="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.
<syntaxhighlight lang="runbasic">a$ = shell$("RENAME input.txt output.txt")
a$ = shell$("RENAME docs mydocs")
a$ = shell$("RENAME \input.txt \output.txt")
a$ = shell$("RENAME \docs \mydocs")</syntaxhighlight>
=={{header|Rust}}==
<syntaxhighlight lang="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);
}
</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}
===Straight forward===
<syntaxhighlight lang="scala">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"
Line 733 ⟶ 1,388:
"/tmp/mydir" renameTo "/tmp/anotherdir"
}
}</
===Alternative===
<syntaxhighlight lang="scala">
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)
}
}
}
</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 753 ⟶ 1,420:
when it is started by a normal user.
<
include "osfiles.s7i";
Line 762 ⟶ 1,429:
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".
=={{header|Sidef}}==
<syntaxhighlight lang="ruby"># 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');</syntaxhighlight>
=={{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}}
<syntaxhighlight lang="smalltalk">'input.txt' asFileReference renameTo: 'output.txt'.
'docs' asFileReference renameTo: 'mydocs'.
'/input.txt' asFileReference renameTo: '/output.txt'.
'/docs' asFileReference renameTo: '/mydocs'</syntaxhighlight>
=={{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.
<syntaxhighlight lang="stata">!ren input.txt output.txt
!ren docs mydocs</syntaxhighlight>
=={{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 825 ⟶ 1,512:
fileCopy(%File, "OtherPath/" @ %File);
fileDelete(%File);
}</
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
- rename file
Line 834 ⟶ 1,521:
- rename directory
ERROR/STOP RENAME ("docs","mydocs",-std-)
</syntaxhighlight>
=={{header|TXR}}==
TXR works with native paths.
<syntaxhighlight lang="txrlisp">(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"))</syntaxhighlight>
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 850 ⟶ 1,549:
// In the root directory
File_Rename("/input.txt", "/output.txt")
File_Rename("/docs", "/mydocs")</
=={{header|Visual Basic .NET}}==
Line 856 ⟶ 1,555:
{{works with|Visual Basic .NET|9.0+}}
<
IO.Directory.Move("docs", "mydocs")
IO.File.Move("input.txt", "output.txt")
Line 868 ⟶ 1,567:
IO.Path.DirectorySeparatorChar & "mydocs")
IO.File.Move(IO.Path.DirectorySeparatorChar & "input.txt", _
IO.Path.DirectorySeparatorChar & "output.txt")</
=={{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}}==
{{trans|UNIX Shell}}
<
rename, "/input.txt", "/output.txt";
rename, "docs", "mydocs";
rename, "/docs", "/mydocs";</
=={{header|zkl}}==
Tested on Linux and Windows 10.
{{out}}
<pre>
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
</pre>
If don't have permissions (amongst other things):
<pre>
zkl: File.rename("/input.txt","/output.txt")
Exception thrown: IOError(rename(/input.txt,/output.txt): Permission denied)
</pre>
{{omit from|Befunge}} <!-- No filesystem support -->
{{omit from|Brlcad}}
{{omit from|EasyLang}}
{{omit from|Lilypond}}
{{omit from|ML/I}}
|