The basic point is that it is poor programming style (and ineffecient to boot) to have two subroutines that essentially do the exact same thing.

From my standpoint as someone who has learnt to code that painful way (is there any other), I've developped the standard methodology that if I have duplicated code (or code that closely duplicates functionalities I've used elsewhere) then I need to go back and look at condensing the duplicates into a single subroutine.

In this case, then, you might start by changing the subroutine as follows:

sub file_processing {
    my ($array_ref, $script, $arg, $file) = @_;

    open(FILE, $script . ' ' . $arg . ' ' . $file . ' |') or die ("can
+'t do it: $!\n");

    while (<FILE>) { 
        chomp;
        next if /^\#/;
        next if /none/i;
        next if /unkno/i;
        push @{$array_ref}, split ( /\n/, $_);
    }

    close FILE;
}
[download]

Notice, however, that there are some areas that could use some more work:

1. The regexp that matches none/unknown/# could be improved and probably condensed into a single one looking something like this: /(?:#|unknown|none)/
2. The assignment back to $array_ref may not do exactly what you expect/need -- a little testing would be in order

And finally, you'd call this script by doing the following:

&file_processing(\@array1, $script1, $arg1, $file1);
&file_processing(\@array1, $script2, $arg2, $file2);
[download]

Which, of course, using the heuristic of duplicated code = BAD, could be condensed into a single array of arrays that are looped over and passed in in turn.

Does that help?

my $arg1 = "foo";
my $file1 = "file_1.gz;
my $arg2 = "bar";
my $file2 = "file_2.gz";

sub file_processing {
    $script = "/export/home/ssesar/Perl/another_script.pl";
    $open = "$script -e $arg1 $file1";
    open(FILE1, "$open |") or die "can't do it\n";

    while (<FILE1>) { 
        chomp;
        next if /^\#/;
        next if /None/;
        next if /Unkno/;
        next if /unkno/;
        next if /NONE/;
        @_ = split ( /\n/, $_);
        @array1 = @_;
           }
    close FILE1;
}
[download]

2. Then, I want this subroutine to be run a second time with the follo
+wing changes:
<CODE>
$open = "$script -e $arg2 $file2";
    open(FILE2, "$open |") or die "can't do it\n";
while (<FILE2>) {
[download]

@array2 = @_;
[download]

Right, here's what we're saying:

my @array1;
my @array2;

my @args = (
    [ \@array1, "foo", "file_1.gz"],
    [ \@array2, "bar", "file_2.gz"]
);

foreach (@args) {
    &file_processing($args->[0], $args->[1], $args->[2]);
}

sub file_processing {
      my ($array_ref, $arg, $file) = @_;
      my $script = "/export/home/ssesar/Perl/another_script.pl";
      open(FILE, $script . ' ' . $arg . ' ' . $file . ' |') or die ("c
+an't do it: $!\n");

      while (<FILE>) { 
          chomp;
          push @{$array_ref}, $_ unless /^(?:\#|none|unknow)/i;
      }
      close FILE;
  }
[download]

This should do what you want as best as I can tell -- open a file and push into an array (either array 1 or array 2 depending on which iteration) any line that doesn't start with UNKNOW/unknow/#/NONE/none.

Your lines

@_ = split ( /\n/, $_);
@array1 = @_;
[download]

look very strange -- as someone else pointed out, if you're reading in the file line by line (which is what <FILE> implies) then the final split on \n is useless.

In addition, you're only assigning the last value of @_ to @array1 (meaning the other values are lost) unless you've undefined $/, in which case you should just use my $file = <FILE> rather than the while loop.

Hope this helps.