Hi all!
I have a perl-related question.

I have a file called printers, which has a list of printers in it :

cat printers :

sdt002_psr
sdt002_psr2
sdt002_psrt
sdt002d
sdt002dr
sdt002dr2
sdt002drt


Now I am wondering, if its possible to have an array statement like this :

@printers=(`cat /tmp/test_print1`);

I just dont want to use the other way (eg open (FH, "< $file") or die "Can't open $file for read: $!" and am wondering if its possible to do something like the above (cat), to populate the array?

Thanks in advance!

@yourlist = `cat printerlist`; works, yes.

that's not a portable way of doing things. anyway, that's your choice.

If you know that the file "printerlist" has only a group of lines like that (one item per line, printer names only), you could also do something like this: Save this as "printers_perl" and put the filename "printerlist" in the command line when you run it: ./printers_perl printerlist

If you want to do that anyway, you could just slurp it:

Quicker - thanks for the tip.

Btw, the act of slurping a file without explicitly opening a filehandle and checking to make sure it opened is going to be a built-in feature in Perl 6 (whenever that gets released. You will also be able to specify automatic chomping.

So you will be able to do this:
If you want this in perl 5, you’ll need to “use Perl6::Slurp” to get the same functionality.

Thanks for all the info!

'Slurping' doesnt work for me it looks like..?

I changed my script from

@printers=`cat printers`;
@print_servers=`cat print_servers`;

To

chomp(my @printers=<>);
chomp(my @print_servers=<>);

But when I ran the script it hung....whether I did something wrong here?

Thanks again!

Can you show us a short (but complete) version of your code which has that problem. It's difficult to just guess.


Incidentally, this version works as a demo:

my @t_arr = <>;
chomp(@t_arr);
print join("\n", @t_arr)."\n";

how did you run the script? did you provide a file name as input?

I basically have this in my script :

#/opt/perl/5.8.0/bin/perl

chomp(my @printers=<>);
chomp(my @print_servers=<>);

for my $i (0..$#printers) {
$hash{$printers[$i]} = $print_servers[$i];
}


use Data:umper;
print Dumper \%hash;

----------------

Then I ran it on the shell using 'perl filename' and it hung..

Thanks a lot for your help

also this, should be

So you want to slurp two separate files? Because of the way the default filehandle (“<>”) works, the first slurp will slurp the entirety of ALL the files specified in @ARGV. The second slurp will just wait for more input (presumably from STDIN). There are a few remedies to this problem:

1. Go back to using the non-portable `cat filename` construct.
2. Use Perl6::Slurp.
3. Go about opening filehandles, and slurp them individually. This is not always as annoying as it seems:
   
   Code:

   my ($printers, $print_servers) = do {
   	open(my $pr, $ARGV[0]) && open(my $ps, $ARGV[1]) || die "$!";
   	([<$pr>], [<$ps>]);
   };
   
   # use $printers and $print_servers as array references (e.g., $printers->[0], etc.)

   So pretty much three lines, and it doesn’t look too bad. If you notice, $pr and $ps go out of scope after the block, so the files are automatically closed. A downside (not too problematic) is that you get array references instead of real arrays.
4. Manipulate @ARGV, and then slurp. The default filehandle “<>” picks input from the files listed in @ARGV, and if there are no such files, then from STDIN. So if you manipulate @ARGV prior to slurping, you can control what happens to it. So (assuming you want the first file in @printers and the second in @print_servers), you might do something like:
   
   Code:

   my $temp=pop @ARGV;
   chomp(my @printers=<>);
   push(@ARGV,$temp);
   chomp(my @print_servers=<>);

   If you don’t want $temp to litter the namespace, you could probably pull off putting the construct in a “do” block.
5. If you are sure that the files are the same size, you can use slices to access them directly:
   
   Code:

   chomp(my @both=<>);
   my @printers=@both[0..@both/2-1];
   my @print_servers=@both[@both/2..$#both];

   Obviously, this is the most error-prone (e.g., there will be no errors if you happen to be unable to read one of the files, or if you just forget to specify a file).

Btw, you can use hash-slicing to accomplish the same thing as your for loop. So this:
Is equivalent to this:

I completely forgot a simpler (sort of) method: Have the first file as an argument and the second file redirected to STDIN. So you could do something like what you did before:
But instead of executing it like this:
You could execute it like this:
Note that his hack will only work with two files, but the other methods I posted can be extended to the general case.

As a general rule, I like to look for CPAN-modules to do things like this, because the writers of those modules usually are thinking, "how can I do this in a portable, system-independent way?" If you port your program over to Windows, it won't run anymore. Maybe that is not a consideration; maybe it is.

Secondly... as you can see from this thread, "there's more than one way to do it." Pick one, comment it clearly, and make sure that it works in all of the present-and-future situations that your code is likely to encounter. Then, move along to the next objective in your project. "There's more than one way to do it," and you don't have to enumerate them.