dooberwah asked:

Is this the best way to do it? It runs fine ... and hey, TMTOWTDI, but is it the best (fastest, cleanest, prettiest, safest)? Comments from those wiser than I would be greatly appreciated.

I would hesitate to say that I am wiser, but my knee-jerk reaction is to usually consider best to mean "easiest to read". Of course, "easiest" is subjective. As for your example, the "best" approach will vary depending upon things that you haven't shown. For example, you might just want something in the following form:

    while (<FILE>)
    {
        next if ! /\S/;
        chomp;
        process_stuff( $_ );
    }
[download]

From what you've given us, though, I suspect that I would prefer the following:

    while (<FILE>)
    {
        chomp if /\S/;
        process_stuff( $_ );
    }
[download]

I used $_, but there's no problem with using $line, of course. I was just being lazy :) A more direct comparison shows the difference in being able to read the two:

Yours:
    $line =~ /^$/ or chomp ( $line );
Mine:
    chomp $line if $line =~ /\S/;
[download]

While I could be mistaken, I think the latter is easier to read and that is what is important. Don't worry about fastest or prettiest. Focusing on those will only get you in trouble.

Of course, it's only fair to point my snippet isn't the same as yours. I assumed that you also wouldn't care about chomping a line with all whitespace, but I could be mistaken.

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

Why use a regex that changes the behavior for whitespace-only lines? Matching "something other than newline" can be written as /[^\n]/ or more succinctly as </code>/./</code>

chomp $line if $line =~ /./;
[download]

Note: this wont behave the same as the original for strings consisting entirely of multiple newlines. i.e. original chomped "\n\n\n\n", this will not.;

-Blake

{
  local $/ = "";  # two or more newlines in a row
  @stanzas = <POEM>;
}

# or

{
  local $/ = "\n\n";  # two newlines in a row
  @chunks = <POEM>;  # you might not get the same results
}
[download]

_____________________________________________________
Jeff[japhy]Pinyan: Perl, regex, and perl hacker, who'd like a (from-home) job
s++=END;++y(;-P)}y js++=;shajsj<++y(p-q)}?print:??;

YuckFoo

I don't think that that solution gives the same results.

From perlre:


(?!pattern)
A zero-width negative lookahead assertion. For example /foo(?!bar)/ matches any occurrence of ``foo'' that isn't followed by ``bar''. Note however that lookahead and lookbehind are NOT the same thing. You cannot use this for lookbehind.

Perhaps you mean to use the (?<!pattern) look behind assertion?

More From perlre:


(?<!pattern)
A zero-width negative lookbehind assertion. For example /(?<!bar)foo/ matches any occurrence of ``foo'' that isn't following ``bar''. Works only for fixed-width lookbehind.

-Ben Jacobs (dooberwah)
http://dooberwah.perlmonk.org
"one thing i can tell you is you got to be free"

Actually, lookbehind and lookahead seem to be the same when the assertion itself has zero-width... In the following code, looking ahead for the anchor produces the same results as looking behind for it.

#!/usr/bin/perl -wT
use strict;

# Replace 'See' anywhere in the string
$_ = "See spot run.  See spot jump.";
s/See/MATCH/g;
print "'$_'\n";          # 'MATCH spot run.  MATCH spot jump.'

# Replace 'See' unless lookahead finds the anchor
$_ = "See spot run.  See spot jump.";
s/(?!^)See/MATCH/g;
print "'$_'\n";          # 'See spot run.  MATCH spot jump.'

# Replace 'See' unless lookabehind finds the anchor
$_ = "See spot run.  See spot jump.";
s/(?<!^)See/MATCH/g;     # 'See spot run.  MATCH spot jump.'
print "'$_'\n";
[download]

-Blake

When having a zero-width pattern inside the assertion it doesn't matter in which direction you look. It's zero width. It's like saying that you jump 0 meters up in the air, or 0 meters down into the ground. You're still not moving. Sure, it might make more sense to say you jumped 0 meter up from the ground than down in the ground, but effectively it's still the same thing.

I used look-ahead because if I recall correct it's faster, and it was supposted to be fast. Plus it's one byte shorter, and he wanted prettiness. I consider (?!) prettier than (?<!).

Cheers,
-Anomo