Here we present a quick overview of the file-related input/output operations. Details can be found in the documentation for the IO role, as well as the IO::Handle and IO::Path types.
One way to read the contents of a file is to open the file via the
open function with the
:r (read) file mode option and slurp in the contents:
my = open "testfile", :r;my = .slurp;.close;
Here we explicitly close the filehandle using the
close method on the
IO::Handle object. This is a very traditional way of reading the contents of a file. However, the same can be done more easily and clearly like so:
my = "testfile".IO.slurp;# or in procedural form:= slurp "testfile"
By adding the
IO role to the file name string, we are effectively able to refer to the string as the file object itself and thus slurp in its contents directly. Note that the
slurp takes care of opening and closing the file for you.
We also have the option to read a file line-by-line. The new line separator (i.e.,
$*IN.nl-in) will be excluded.
for 'huge-csv'.IO.lines -># or if you'll be processing latermy = 'huge-csv'.IO.lines;
To write data to a file, again we have the choice of the traditional method of calling the
open function – this time with the
:w (write) option – and printing the data to the file:
my = open "testfile", :w;.print("data and stuff\n");.close;
Or equivalently with
say, thus the explicit newline is no longer necessary:
my = open "testfile", :w;.say("data and stuff");.close;
We can simplify this by using
spurt to open the file in write mode, writing the data to the file and closing it again for us:
spurt "testfile", "data and stuff\n";
By default all (text) files are written as UTF-8, however if necessary, an explicit encoding can be specified via the
spurt "testfile", "latin1 text: äöüß", enc => "latin1";
To write formatted strings to a file, use the printf function of IO::Handle.
my = open "testfile", :w;.printf("formatted data %04d\n", 42);.close;
To append to a file, specify the
:a option when opening the filehandle explicitly,
my = open "testfile", :a;.print("more data\n");.close;
or equivalently with
say, thus the explicit newline is no longer necessary,
my = open "testfile", :a;.say("more data");.close;
or even simpler with the
:append option in the call to
spurt "testfile", "more data\n", :append;
To explicitly write binary data to a file, open it with the
:bin option. The input/output operations then will take place using the
Buf type instead of the
unlink are available to avoid low-level system commands. See details at copy, rename, move, and unlink. Some examples:
my = 'foo';my = 'foo.bak';my = '/disk1/foo';# note 'diskN' is assumed to be a physical storage devicecopy , ; # overwrites $fileb if it existscopy , , :createonly; # fails if $fileb existsrename , 'new-foo'; # overwrites 'new-foo' if it existsrename , 'new-foo', :createonly; # fails if 'new-foo' exists# use move when a system-level rename may not workmove , '/disk2/foo'; # overwrites '/disk2/foo' if it existsmove , '/disk2/foo', :createonly; # fails if '/disk2/foo' existsunlink ;.IO.unlink;
unlink sentences remove their argument if it exists, unless the user does not have the correct permissions to do so; in that case, it raises an exception.
e method on an
IO::Handle object to test whether the file or directory exists.
It is also possible to use the colon pair syntax to achieve the same thing:
if "path/to/file".IO ~~ :e
my = "path/to/file";if .IO ~~ :e
Similarly to the file existence check, one can also check to see if a path is a directory. For instance, assuming that the file
testfile and the directory
lib exist, we would obtain from the existence test method
e the same result, namely that both exist:
say "testfile".IO.e; # OUTPUT: «True␤»say "lib".IO.e; # OUTPUT: «True␤»
However, since only one of them is a directory, the directory test method
d will give a different result:
say "testfile".IO.d; # OUTPUT: «False␤»say "lib".IO.d; # OUTPUT: «True␤»
Naturally the tables are turned if we check to see if the path is a file via the file test method
say "testfile".IO.f; # OUTPUT: «True␤»say "lib".IO.f; # OUTPUT: «False␤»
There are other methods that can be used to query a file or directory, some useful ones are:
my = "file";say .IO.modified; # return time of last file (or directory) changesay .IO.accessed; # return last time file (or directory) was readsay .IO.s; # return size of file (or directory inode) in bytes
See more methods and details at IO::Path.
To list the contents of the current directory, use the
dir function. It returns a list of IO::Path objects.
say dir; # OUTPUT: «"/path/to/testfile".IO "/path/to/lib".IO␤»
To list the files and directories in a given directory, simply pass a path as an argument to
say dir "/etc/"; # OUTPUT: «"/etc/ld.so.conf".IO "/etc/shadow".IO ....␤»
To create a new directory, simply call the
mkdir function with the directory name as its argument:
The function returns the name of the created directory on success and
Nil on failure. Thus the standard Perl idiom works as expected:
mkdir "newdir" or die "$!";
rmdir to remove empty directories:
rmdir "newdir" or die "$!";