«

I solved my problem by rewriting, but I'm wondering why I am getting errors
with respect to 'ne' and 'eq' operators.

This code works fine (Perl 5.8.:

$ cat minimal.pl
#!/opt/gnu/bin/perl

use warnings;
use strict;

my $VAL = 'xyz';

my @foo = ( 'abc', 'def', 'ghi', 'xyz', 'jkl', 'xyz', 'uvw' );

foreach my $item ( @foo )
{
next if ( $item ne $VAL );

print "$item\n";
}
$ ./minimal.pl
xyz
xyz


But if I add a test for 'undef' I get warnings:

$ cat ./minimal2.pl
#!/opt/gnu/bin/perl

use warnings;
use strict;

my $VAL = 'xyz';

my @foo = ( 'abc', 'def', 'ghi', 'xyz', 'jkl', 'xyz', 'uvw' );

foreach my $item ( @foo )
{
next if ( undef $item ) or ( $item ne $VAL );

print "$item\n";
}
$ ./minimal2.pl
Use of uninitialized value in string ne at ./minimal2.pl line 12.
Use of uninitialized value in string ne at ./minimal2.pl line 12.
Use of uninitialized value in string ne at ./minimal2.pl line 12.
Use of uninitialized value in string ne at ./minimal2.pl line 12.
Use of uninitialized value in string ne at ./minimal2.pl line 12.
Use of uninitialized value in string ne at ./minimal2.pl line 12.
Use of uninitialized value in string ne at ./minimal2.pl line 12.

Even weirder if I try 'eq':

$ cat ./minimal3.pl
#!/opt/gnu/bin/perl

use warnings;
use strict;

my $VAL = 'xyz';

my @foo = ( 'abc', 'def', 'ghi', 'xyz', 'jkl', 'xyz', 'uvw' );

foreach my $item ( @foo )
{
next if ( undef $item ) or ( $item eq $VAL );

print "$item\n";
}
$ ./minimal3.pl
Use of uninitialized value in string eq at ./minimal3.pl line 12.
Use of uninitialized value in concatenation (.) or string at ./minimal3.pl line 14.

Use of uninitialized value in string eq at ./minimal3.pl line 12.
Use of uninitialized value in concatenation (.) or string at ./minimal3.pl line 14.

Use of uninitialized value in string eq at ./minimal3.pl line 12.
Use of uninitialized value in concatenation (.) or string at ./minimal3.pl line 14.

Use of uninitialized value in string eq at ./minimal3.pl line 12.
Use of uninitialized value in concatenation (.) or string at ./minimal3.pl line 14.

Use of uninitialized value in string eq at ./minimal3.pl line 12.
Use of uninitialized value in concatenation (.) or string at ./minimal3.pl line 14.

Use of uninitialized value in string eq at ./minimal3.pl line 12.
Use of uninitialized value in concatenation (.) or string at ./minimal3.pl line 14.

Use of uninitialized value in string eq at ./minimal3.pl line 12.
Use of uninitialized value in concatenation (.) or string at ./minimal3.pl line 14.

Can anyone explain to me why I see this behavior? It seems like a
perfectly normal chained test.
--
_+_ From the catapult of |If anyone disagrees with any statement I make, I
_|70|___=}- J.D. Baldwin |am quite prepared not only to retract it, but also
\ / |to deny under oath that I ever made it. -T. Lehrer
***~~~~-----------------------------------------------------------------------

J.D. Baldwin <> wrote:
> I solved my problem by rewriting, but I'm wondering why I am getting errors
> with respect to 'ne' and 'eq' operators.

> This code works fine (Perl 5.8.:

> $ cat minimal.pl
> #!/opt/gnu/bin/perl
>
> use warnings;
> use strict;
>
> my $VAL = 'xyz';
>
> my @foo = ( 'abc', 'def', 'ghi', 'xyz', 'jkl', 'xyz', 'uvw' );
>
> foreach my $item ( @foo )
> {
> next if ( $item ne $VAL );
>
> print "$item\n";
> }
> $ ./minimal.pl
> xyz
> xyz


> But if I add a test for 'undef' I get warnings:

> $ cat ./minimal2.pl
> #!/opt/gnu/bin/perl
>
> use warnings;
> use strict;
>
> my $VAL = 'xyz';
>
> my @foo = ( 'abc', 'def', 'ghi', 'xyz', 'jkl', 'xyz', 'uvw' );
>
> foreach my $item ( @foo )
> {
> next if ( undef $item ) or ( $item ne $VAL );

'undef' is an unary operator that undefines what it's applied to,
not a test if the variable is undefined. I guess you meant to use

next if ! defined $item || $item ne $VAL;
or
next unless defined $item && $item eq $val;

Regards, Jens
--
\ Jens Thoms Toerring ___
\__________________________ http://toerring.de

J.D. Baldwin wrote:
> I solved my problem by rewriting, but I'm wondering why I am getting
> errors
> with respect to 'ne' and 'eq' operators.

[...]

> But if I add a test for 'undef' I get warnings:
>
> $ cat ./minimal2.pl
> #!/opt/gnu/bin/perl
>
> use warnings;
> use strict;
>
> my $VAL = 'xyz';
>
> my @foo = ( 'abc', 'def', 'ghi', 'xyz', 'jkl', 'xyz', 'uvw' );
>
> foreach my $item ( @foo )
> {
> next if ( undef $item ) or ( $item ne $VAL );
>
> print "$item\n";
> }
> $ ./minimal2.pl
> Use of uninitialized value in string ne at ./minimal2.pl line 12.
> Use of uninitialized value in string ne at ./minimal2.pl line 12.
> Use of uninitialized value in string ne at ./minimal2.pl line 12.
> Use of uninitialized value in string ne at ./minimal2.pl line 12.
> Use of uninitialized value in string ne at ./minimal2.pl line 12.
> Use of uninitialized value in string ne at ./minimal2.pl line 12.
> Use of uninitialized value in string ne at ./minimal2.pl line 12.

The problem is you're calling undef $item which undefines $item.

What you want to use instead is:

next if ( ! defined $item ) or ( $item ne $VAL );


defined() will tell you if a scalar has been defined or so. For arrays
and hashes, drop the define, as if(@array) and if(%hash) will return
true only if there are items within.

Also see: perldoc -f defined and also: perldoc -f undef
This will help you learn what undef() is used for and about using
defined().

How this helps.

--
szr

J.D. Baldwin wrote:

> next if ( undef $item )

$item == undef

or

!defined($item)

"perldoc -f undef" to see why your command does not do what you want, and
the warnings you get are expected.

--
D.

In article <g5l4ig$c54$>, J.D. Baldwin
<> wrote:

> I solved my problem by rewriting, but I'm wondering why I am getting errors
> with respect to 'ne' and 'eq' operators.
>

> But if I add a test for 'undef' I get warnings:
>
> $ cat ./minimal2.pl
> #!/opt/gnu/bin/perl
>
> use warnings;
> use strict;
>
> my $VAL = 'xyz';
>
> my @foo = ( 'abc', 'def', 'ghi', 'xyz', 'jkl', 'xyz', 'uvw' );
>
> foreach my $item ( @foo )
> {
> next if ( undef $item ) or ( $item ne $VAL );
>
> print "$item\n";
> }

The test for defined-ness is defined, not undef. The operator undef
sets the variable to undef.

perldoc -f defined

--
Jim Gibson

Dave B wrote:
> J.D. Baldwin wrote:
>
>> next if ( undef $item )
>
> $item == undef

That won't work correctly either.

$ perl -le'
for my $item ( 0, 1, "two" ) {
print $item if $item == undef;
}
'
0
two


John
--
Perl isn't a toolbox, but a small machine shop where you
can special-order certain sorts of tools at low cost and
in short order. -- Larry Wall

>>>>> "DB" == Dave B <> writes:

DB> J.D. Baldwin wrote:
>> next if ( undef $item )

DB> $item == undef

very wrong. the only way to test for definedness is with defined. wipe
that idiom out of your brain. just to make it clear, try that with any
false value in $item (and enable warnings too for more results).

uri

--
Uri Guttman ------ -------- http://www.sysarch.com --
----- Perl Code Review , Architecture, Development, Training, Support ------
--------- Free Perl Training --- http://perlhunter.com/college.html ---------
--------- Gourmet Hot Cocoa Mix ---- http://bestfriendscocoa.com ---------

Dave B <> wrote:
>J.D. Baldwin wrote:
>
>> next if ( undef $item )
>
>$item == undef

This doesn't do what you seem to think it is doing.

First of all it will trigger two warnings (for generic $item):
- Use of uninitialized value in numeric eq (==)[*]
- Argument "...." isn't numeric in numeric eq (==) [**]
[*]: because undef is not initialized, surprise, surprise
[**]: because in the generic case $item may contain a string or -gasp-
be undefined instead of number.

And second the numerical value of undef is 0 and therefore this
comparison will yield true whenever the numerical value of $item is 0,
in particular also when $item contains a string that does not start with
a number.

jue

In the previous article, Jens Thoms Toerring <> wrote:
> 'undef' is an unary operator that undefines what it's applied to,
> not a test if the variable is undefined. I guess you meant to use

<slaps forehead>

So much for focusing on the comparison operator.

Thank you (and you others) for setting me straight on this.

undef ne ( ! defined ). Got it.
--
_+_ From the catapult of |If anyone disagrees with any statement I make, I
_|70|___=}- J.D. Baldwin |am quite prepared not only to retract it, but also
\ / |to deny under oath that I ever made it. -T. Lehrer
***~~~~-----------------------------------------------------------------------

Jürgen Exner wrote:

> Dave B <> wrote:
>> J.D. Baldwin wrote:
>>
>>> next if ( undef $item )
>> $item == undef
>
> This doesn't do what you seem to think it is doing.

Thank you, John and Uri for correcting me on this. It seemed to work in a
quick and simple test like perl -e 'print "ok" if $var == undef;' but, as
you correctly point out, that idiom cannot be used in general.

Thanks

--
D.