The substitution won't work that way, because you opened the file just for reading. So while you change $data the way you want it, you don't write it back into a file in some way.

An easy way to do an in-place substitution is the use of the -i flag on the command line:

perl -i.orig -pwe 's/red/blue/g' /html/*
[download]

If you don't want to use a one-liner (or -i on the shebang line), you have to open a second file for writing, write the modified the contents to it, delete the source file and then move the file with the modified contents to the original location.

Also, readdir returns both plain files and directories, and you don't check for that. The file list may (depending on the platform) also include "." and ".."! Check with -f to see if it's indeed a file before you try to open it — again, don't forget about the directory.

It might be a little easier to use glob to get the file list, for which the file names will include the directory name. Plus, you can provide a pattern for the file name. Also, glob will not return results for "." or "..", whatever the pattern. (Though, on Unix it might if the pattern for the basename starts with "."; I'm not sure.)

As an optimization for writing code: you could pull out the actual file processing (the sequence of s/// statements) into separate subs, and pass a sub reference to a sub which does the boring stuff, which can be common for all directories and all files. Something like:

process($dir1, sub {
    s/blue/red/;
    s/yellow/green/;
});

sub process {
    my $dir = shift;
    my $sub = shift;
    ... # pretty much like your own code, until we have to process the
+ file contents:
    $sub->();  # note that the file contents is expected to be in $_
    ... # rest of the wrapper code
}
[download]

Yes, you headed in a right direction. In the first directory you rename files and in the second you substitute contents of a files.

well, hint.

foreach $filename (@files) {
    open FILEIN, "<", $filename;
    open FILEOUT, ">", $filename."new";
    
    while (my $data = <FILEIN>) {
        $data =~ s/red/blue/g;
        print FILEOUT $data;
    }
    close FILEIN;
    close FILEOUT;
}
[download]

Twice you do something like this:

   foreach(@array){
      my $item = $_;
      ...
[download]

The common way is just for my $item (@array) {.

Or take advantage of the default loop variable, $_. For example, this:

   foreach(@attchfiles) {   
       my $attchfilename = $_;   
       $attchfilename =~ tr/A-Z/a-z/;    
       rename($_, $attchfilename); 
    }
[download]

Could be simplified as:

   rename($_,lc) for @attchfiles;
[download]

But, you should probably make sure the lowercase file doesn't already exist. Perhaps like so:

   for(@attchfiles){
      if ( -e lc ) {
         # do something appropriate!
      } else {
         rename $_,lc;
      }
   }
[download]

You want to do a number of substitutions to each file in a directory, with different substitutions for each of a large number of directories.

I would suggest putting the directories and associated substitutions into a data structure. It's a little simpler to put at the top of the file, but harder to modify. Reading in a YAML file containing the rules is a little more complicated to get working, but simpler to maintain over the years, if this is something that will be used for a long time.

Since you're a novice, I'll suggest putting the data in the file:

use autodie;
use File::Temp qw(tempfile);
my @RULES = (
             { dir  => '/path/to/dir1',
               mods => [ 'yellow', 'green' ], [ 'red', 'blue' ] ],
             },
             { dir  => '/path/to/dir2',
               mods => [ [ 'puce', 'chartreuse' ], [ 'lime green', 'ma
+genta' ] ],
             },
             );
...
for my $rule ( @RULES ) {
    chdir $rule->{dir};
    for my $file ( glob( .* * ) ) {
       open my $input, '<', $file; 
       my ($output, $outfile) = tempfile(); 
       while ( my $line = <$input> ) {
           chomp $line;
           for my $sub ( @{ $rule->{mods} } ) {
               $line =~ s/$sub->[0]/$sub->[1]/
           }
           print $output $line;
       }
       close $input;
       close $output;
       replace_file( $file, $outfile );
    }
}
[download]

I leave for you the process of verifying the old file is successfully replaced by the new file. The regexes will be recompiled on each search-and-replace, but if they are really literal strings, that won't be too expensive. If there were matches, I would suggest precompiling the exporessions, but I'm not sure that works for search-and-replace.

Thank you very much everyone, my script is now fully functional (after 3 days of wanting to cry).

I really appreciate all your suggestions and criticism though, you gave me a lot of food for thought - now that it is functional I can concentrate on cleaning it up a bit.