Rename a file: Difference between revisions

Content added Content deleted

Inline

Revision as of 08:51, 13 April 2010

In this task, the job is to rename the 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.

Ada

<lang ada>with Ada.Directories; use Ada.Directories;

...

Rename ("input.txt", "output.txt"); Rename ("docs", "mydocs"); Rename ("/input.txt", "/output.txt"); Rename ("/docs", "/mydocs");</lang> 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

Works with: ALGOL 68 version Standard - no extensions to language used

Note: reidf does not appear to be included in ALGOL 68G. Also note that file names would be Operating System dependent. <lang algol68>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")

)</lang>

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: <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")}'</lang>

AutoHotkey

<lang AutoHotkey>FileMove, oldname, newname</lang>

C

<lang c>#include <stdio.h>

int main() {

 rename("input.txt", "output.txt");
 rename("docs", "mydocs");
 rename("/input.txt", "/output.txt");
 rename("/docs", "/mydocs");
 return 0;

}</lang>

BASIC

<lang qbasic>NAME "input.txt" AS "output.txt" NAME "\input.txt" AS "\output.txt" NAME "docs" AS "mydocs" NAME "\docs" AS "\mydocs"</lang>

C++

Translation of: C

<lang cpp>#include <cstdio>

int main() {

 std::rename("input.txt", "output.txt");
 std::rename("docs", "mydocs");
 std::rename("/input.txt", "/output.txt");
 std::rename("/docs", "/mydocs");

}</lang>

C#

<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>

Clojure

<lang 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")))</lang>

Common Lisp

rename-file

<lang lisp>(rename-file "input.txt" "output.txt") (rename-file "docs" "mydocs") (rename-file "/input.txt" "/output.txt") (rename-file "/docs" "/mydocs")</lang>

D

<lang 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");</lang>

Batch File

<lang dos>ren input.txt output.txt ren \input.txt output.txt ren docs mydocs ren \docs mydocs</lang>

E

<lang e>for where in [<file:.>, <file:///>] {

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

}</lang>

Factor

<lang factor>"" "/" [

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

] bi@</lang>

Forth

<lang forth> s" input.txt" s" output.txt" rename-file throw s" /input.txt" s" /output.txt" rename-file throw</lang>

Groovy

Using File <lang groovy>['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst ->

 ['.', ].each { dir ->
   new File("$dir/$src").renameTo(new File("$dir/$dst"))
 }

}</lang>

Using Ant <lang groovy>['input.txt':'output.txt', 'docs':'mydocs'].each { src, dst ->

 ['.', ].each { dir ->
   new AntBuilder().move(file:"$dir/$src", toFile:"$dir/$dst")
 }

}</lang>

Haskell

<lang 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"</lang>

HicEst

<lang 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') </lang>

J

J does not ship with a built-in utility for renaming files. The following will work on Windows, Linux and Macs:

<lang j>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.

)</lang>

Useage: <lang j>'output.txt' frename 'input.txt' '/output.txt' frename '/input.txt' 'mydocs' frename 'docs' '/mydocs' frename '/docs'</lang>

Java

<lang java>import java.util.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 sucess;
  }
  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.seperator + "input.txt", File.seperator + "output.txt");
       test("directory", "docs", "mydocs");
       test("directory", File.seperator + "docs" + File.seperator, File.seperator + "mydocs" + File.seperator);
  }

}</lang>

JavaScript

Works with: JScript

Throws an error if the destination file/folder exists. <lang javascript>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');</lang>

Mathematica

<lang Mathematica>SetDirectory[NotebookDirectory[]] RenameFile["input.txt", "output.txt"] RenameDirectory["docs", "mydocs"] SetDirectory[$RootDirectory] RenameFile["input.txt", "output.txt"] RenameDirectory["docs", "mydocs"]</lang>

MAXScript

MAXScript has no folder rename method <lang maxscript>-- Here renameFile "input.txt" "output.txt" -- Root renameFile "/input.txt" "/output.txt"</lang>

Objective-C

Works with: Cocoa

Works with: GNUstep

<lang objc>NSFileManager *fm = [NSFileManager defaultManager];

[fm movePath:@"input.txt" toPath:@"output.txt" handler:nil]; [fm movePath:@"docs" toPath:@"mydocs" handler:nil];</lang>

OCaml

<lang ocaml>Sys.rename "input.txt" "output.txt";; Sys.rename "docs" "mydocs";; Sys.rename "/input.txt" "/output.txt";; Sys.rename "/docs" "/mydocs";;</lang>

Pascal

<lang 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;</lang>

Perl

<lang 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');</lang>

PHP

PicoLisp

<lang PicoLisp>(call 'mv "input.txt" "output.txt") (call 'mv "docs" "mydocs") (call 'mv "/input.txt" "/output.txt") (call 'mv "/docs" "/mydocs")</lang>

Pike

<lang pike>int main(){

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

}</lang>

Pop11

<lang 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');</lang>

Note that notion of the root of filesystem is Unix specific, so above we do not try to suport other systems.

PowerShell

<lang powershell>Rename-Item input.txt output.txt

The Rename-item has the alias ren

ren input.txt output.txt</lang>

PureBasic

<lang purebasic>RenameFile("input.txt", "output.txt") RenameFile("docs\", "mydocs\")

RenameFile("/input.txt","/output.txt") RenameFile("/docs\","/mydocs\")</lang>

Python

<lang 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")</lang>

R

<lang R>file.rename("input.txt", "output.txt") file.rename("/input.txt", "/output.txt") file.rename("docs", "mydocs") file.rename("/docs", "/mydocs")</lang>

REBOL

<lang 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/ </lang>

Ruby

<lang ruby>File.rename('input.txt', 'output.txt') File.rename('/input.txt', '/output.txt') File.rename('docs', 'mydocs') File.rename('/docs', '/mydocs')</lang>

Library: fileutils.rb

The FileUtils#move method has some more flexibility than the core File#rename method (not really demonstrated here).

<lang ruby>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 ) }</lang>

Seed7

<lang seed7>$ include "seed7_05.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;</lang>

Slate

<lang 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'.</lang>

Smalltalk

<lang 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'</lang>

Standard ML

<lang sml>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"};</lang>

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): <lang tcl>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]</lang> Without the need to work on unusual platforms like Mac OS 9, the code could be just: <lang tcl>file rename inputs.txt output.txt file rename docs mydocs

file rename /inputs.txt /output.txt file rename /docs /mydocs</lang>

<lang vbnet>'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")</lang>