Perl – How to Perl script to move files with specific extension from one folder to another and rename the moved files

csvperlperl-module

I have 2 folders DIR1 DIR2 ,i need to move only files with extension ".csv" only from dir1 to dir2

and rename these file copied files with the timestamp in dir2

$dirname = "\\dir1\\"
$dirname2= "\\dir2\\";
$filterstring=".csv";
opendir ( DIR, $dirname ) || die "Error in opening dir $dirname\n";
foreach my $filename (readdir(DIR))
{
      if ($filename =~ m/$filterstring/) {                          
$cfile=$dirname.$filename;
print "\n moving $cfile from $dirname  to $dirname2 \n";
move($cfile,$dirname2);                             
           }}
closedir(DIR);

This above code i dveloped moves files with extension ".csv " and also files with filename "abc_csv_uv.txt"
how do i rectify this problem and then rename the moved files…please advise..need help

Best Answer

use strict;
use File::Copy;
use File::stat;
use POSIX qw(strftime);

my $dirname = "\\dir1\\";
my $dirname2 = "\\dir2\\";
my $filterstring = "\\.csv\$";

opendir ( DIR, $dirname ) || die "Error in opening dir $dirname\n";
foreach my $filename (readdir(DIR)) {
    next if not $filename =~ m/$filterstring/;

    my $old_file = $dirname . $filename;
    my $new_file = $dirname2 . $filename . '.' . strftime("%Y%m%dT%H%M%S", localtime(stat($old_file)->mtime));

    print "Moving $old_file to $new_file\n";
    move($old_file, $new_file);
}
closedir(DIR);

1;

Related Solutions

Perl – In Perl, what is the difference between a .pm (Perl module) and .pl (Perl script) file

At the very core, the file extension you use makes no difference as to how perl interprets those files.

However, putting modules in .pm files following a certain directory structure that follows the package name provides a convenience. So, if you have a module Example::Plot::FourD and you put it in a directory Example/Plot/FourD.pm in a path in your @INC, then use and require will do the right thing when given the package name as in use Example::Plot::FourD.

The file must return true as the last statement to indicate successful execution of any initialization code, so it's customary to end such a file with 1; unless you're sure it'll return true otherwise. But it's better just to put the 1;, in case you add more statements.

If EXPR is a bareword, the require assumes a ".pm" extension and replaces "::" with "/" in the filename for you, to make it easy to load standard modules. This form of loading of modules does not risk altering your namespace.

All use does is to figure out the filename from the package name provided, require it in a BEGIN block and invoke import on the package. There is nothing preventing you from not using use but taking those steps manually.

For example, below I put the Example::Plot::FourD package in a file called t.pl, loaded it in a script in file s.pl.

C:\Temp> cat t.pl
package Example::Plot::FourD;

use strict; use warnings;

sub new { bless {} => shift }

sub something { print "something\n" }

"Example::Plot::FourD"

C:\Temp> cat s.pl
#!/usr/bin/perl
use strict; use warnings;

BEGIN {
    require 't.pl';
}

my $p = Example::Plot::FourD->new;
$p->something;


C:\Temp> s
something

This example shows that module files do not have to end in 1, any true value will do.

Perl – How to call a subroutine from one perl module to another perl module

There's two elements - first is finding the module. Perl has a 'library' path that you can find by:

print join ( "\n", @INC );

This is the places where it looks. It will also check the current working directory, but it's a little bit more difficult using a run time relative path - you need to use the FindBin module for that.

The second element is importing and exporting the subroutine. By default, if you use A; you won't import everything into your local name space because... you don't want to accidentally override one of your internal functions. That way lies madness.

So you either:

use A qw ( somefunction );

Which will 'pull in' that function and define it in your local namespace. The exact behavor of these things can be modified via Exporter and setting @EXPORT and @EXPORT_OK.

Or refer to it by the 'package path'.

A::somefunction(@arguments);

This also works for variables, although you will have to scope them with our rather than my.

Best Answer

Related Solutions

Perl – In Perl, what is the difference between a .pm (Perl module) and .pl (Perl script) file

Perl – How to call a subroutine from one perl module to another perl module

Related Topic