20 by wuxiangyu


									Perl File and Directory Access
 Learning Objectives:
 1.   To learn how to change directories being
      accessed in a Perl program
 2.   To learn the Perl’s command involving file
      system management / accessing
Lecture 20 / Slide 2

   Perl File and Directory Access
   Table of Content
       Changing Directories
       Globbing
       Removing a File
       Renaming a File
       Hard Links
       Soft Link
       Making and Removing Directories
       Permissions
       Modifying Permissions
       Recursive Directory Processing
Lecture 20 / Slide 3

   Changing Directories (1)
     You can change the current working directory within
      Perl, just like the cd shell command.
     In Perl, the chdir function, takes a single argument --
      the directory name to change to.
     chdir returns true if you’ve successfully changed
      to the requested directory, and false if you could

                chdir("/etc") || die "cannot cd to /etc";
Lecture 20 / Slide 4

   Changing Directories (2)
     Like other functions, parentheses are optional:
                $ cat cd1
                #!/usr/local/bin/perl5 -w
                print "where to go? ";
                chomp($where = <STDIN>);
                if(chdir $where){
                      print "chdir succeeded, now in $where\n";
                      print "chdir did not succeeded\n";
                $ cd1
                where to go? /bin
                chdir succeeded, now in /bin
Lecture 20 / Slide 5

   Changing Directories (3)
     When your Perl program starts, the current working
      directory will be inherited from the shell that invoked
     However, using chdir in Perl will not change the
      working directory of the shell when your program
     The chdir function without a parameter defaults to
      taking you to your home directory.
Lecture 20 / Slide 6

   Globbing (1)

      The shell takes a * and turns it into a list of all the
       filenames in the current directory.
      Similarly, [a-m]*.cpp turns into a list of all
       filenames in the current directory that begin with a
       letter in the first half of the alphabet, and end in .cpp.
      The expansion of * or /etc/host* into the list of
       matching filenames is called globbing.
Lecture 20 / Slide 7

   Globbing (2)

      Perl supports globbing.
      Just put the globbing pattern between angle brackets or
       use the glob function:
                 @all = <*>;
                 @b = <[a-m]*.cpp>;
                 @c = glob("[a-m]*.cpp");     # same as @b

      In a list context, the glob returns a list of all names that
       match the pattern (or an empty list if none match).
Lecture 20 / Slide 8

   Globbing (3)
      Example:
                 $ ls
                 address     letter1     names   sort
                 $ cat glob1
                 #!/usr/local/bin/perl5 -w
                 @files = <[a-m]*>;
                 foreach $file (@files){
                       print "$file\n";
                 $ glob1
Lecture 20 / Slide 9

   Globbing (4)
      If you use a full pathname in your glob, you will get
       full pathnames as a result:
                 $ cat glob2
                 #!/usr/local/bin/perl5 -w
                 @files = </etc/host*>;
                 foreach $file (@files){
                       print "$file ";
                 print "\n";
                 $ glob2
                 /etc/hostname.le0 /etc/hosts /etc/hosts.allow
Lecture 20 / Slide 10

   Globbing (5)
      If you want just the simple filename, you can use
       substitute to chop off the directory part of the string:
                $ cat glob3
                #!/usr/local/bin/perl5 -w
                @files = </etc/host*>;
                foreach $file (@files){
                      $file =~ s#.*/##; # delete to last slash
                      print "$file ";
                print "\n";
                $ glob3
                hostname.le0 hosts hosts.allow hosts.deny
Lecture 20 / Slide 11

   Globbing (6)
     Multiple patterns are permitted inside the glob:
                @bill_files = <gates* clinton*>;
     The argument to glob is variable interpolated:
        $ cat glob4
        #!/usr/local/bin/perl5 -w
        if(-d "/homes/horner/111"){
            $where = "/homes/horner/111";
            $where = "/homes/horner";
        @files = <$where/*>;
        print "@files\n";
        $ glob4
        /homes/horner/111/letter1 /homes/horner/111/names
Lecture 20 / Slide 12

   Removing a File (1)
    The Perl unlink function deletes a file, exactly like the
     UNIX rm command.
               unlink("bill");     # bye bye bill
    Example:
               $ ls
               letter1     names       unlink1
               $ cat unlink1
               #!/usr/local/bin/perl5 -w
               print "what file to delete? ";
               chomp($what = <STDIN>);
               $ unlink1
               what file to delete? letter1
               $ ls
               names        unlink1
Lecture 20 / Slide 13

   Removing a File (2)
    unlink can take a list of names as well:

               unlink("bill", "gates");
               unlink <*.cpp>;      # delete all .cpp files

    The return value on unlink is the number of files
     successfully deleted.
               foreach $file (<*.cpp>){
                        if(unlink($file) == 0){
                              print "trouble deleting $file\n";
Lecture 20 / Slide 14

   Removing a File (3)
    With no arguments to unlink, $_ is used as the

               foreach (<*.cpp>){
                        if(unlink == 0){
                              print "trouble deleting $_\n";
Lecture 20 / Slide 15

   Renaming a File
    The Perl function rename allows you to rename files.
    Here is how to rename the file gates into cheap:
               rename("gates", "cheap");

    rename returns a true value if successful.
               if(rename("gates", "cheap")){
                        print "Bill is now cheap\n";
                        print "Bill is still gates\n";
Lecture 20 / Slide 16

   Hard Links
    The Perl function link allows you to create a hard
    Here is how to link from the file gates to cheap:
               link("gates", "cheap");

    link returns true if successful.
               if(link("gates", "cheap")){
                        print "Bill is now also cheap\n";
                        print "Bill is still only gates\n";
Lecture 20 / Slide 17

   Soft Links
   The Perl function symlink allows you to create a soft (symbolic)
   Here is how to symbolic link from gates to cheap:
              symlink("gates", "cheap");

   readlink returns the name pointed at by the specified symbolic
              symlink("gates", "cheap");
              $x = readlink("cheap");
              print "cheap points at $x\n";   #cheap points at gates
Lecture 20 / Slide 18

   Making and Removing Directories

    The Perl functions mkdir and rmdir allow you to make and
     remove directories.
    mkdir takes the name of the new directory and a mode that
     determines the permissions
    Use 0755 for the mode to allow user full (rwx) permission, and
     no write permission for group and other (rx only).
               mkdir("gatesdir", 0755);
Lecture 20 / Slide 19


    The leading mode number is always 0, and the other 3 numbers
     are permissions for user, group, and other respectively.
    The mode values are octal, and have the following meanings:
               0   ---
               1   --x
               2   -w-
               3   -wx
               4   r--
               5   r-x
               6   rw-
               7   rwx
Lecture 20 / Slide 20

   Modifying Permissions

    The Perl function chmod allows you to change file and
     directory permissions:

               mkdir("gatesdir", 0755);        #u:rwx g:rx o:rx
               chmod(0750, "gatesdir");        #u:rwx g:rx o:
               chmod(0531, "gates");           #u:rx g:wx o:x
               chmod(0642 , "gates", "cheap"); #u:rw g:r o:w
Lecture 20 / Slide 21

   Recursive Directory Processing

     Here is the skeleton of a program for recursive directory

    #!/usr/local/bin/perl5 -w
    sub dirtree {
      my @files = <$_[0]/*>;    # local variable required
      print "Directory listing for: $_[0]\n";
      foreach (@files){
            print "$_\n";
            dirtree($_) if (-d $_); # recursion

To top