That's the part that confuses me. What does the "class or object method?" check in the constructor have to do with the "method or function call?" question?
Because a common idiom used to "solve" the "class or object method?" question, can lead to odd behavior when a constructor is called as a function and not a method. Sure, in a perfect world that should never happen, but we dont live in a perfect world, and it would be niave to think your code would execute in a perfect world. Of course, you could also just not care, if they use it wrong, you absolve yourself of all responsability, it's their fault. But I am really talking about defensive coding practices here, ways to strengthen your code in real world scenarios so that it acts as expected in all situations, even those of incorrect usage.
I think these are two different things altogether, but the original post and your previous comment here make me wonder if you think they're different.
They are different things conceptually, but in reality they are 2 different "facets" of the same code. One the intended usage, the other, the un-indentend usage. Again, I am talking defensive coding here, if you don't care what happens when someone mis-uses your code, then this doesn't matter. Personally, I do care.
| [reply] |
Because a common idiom used to "solve" the "class or object method?" question, can lead to odd behavior when a constructor is called as a function and not a method.
I disagree:
#!/usr/bin/perl -w
use strict;
use Test::More tests => 2;
package Foo;
sub new
{
my $class = shift;
bless {}, $class;
}
sub test
{
1;
}
package Bar;
sub new
{
my $class = shift;
$class = ref( $class ) || $class;
bless {}, $class;
}
sub test
{
1;
}
package main;
sub test
{
0;
}
my $foo = Foo::new();
ok( $foo->test() );
my $bar = Bar::new();
ok( $bar->test() );
That's the same behavior regardless of the "class or object?" check. This leads me to conclude that that check has no bearing on the behavior. What leads you to believe otherwise? | [reply]
[d/l] |
Because a common idiom used to "solve" the "class or object method?" question, can lead to odd behavior when a constructor is called as a function and not a method.
I disagree:
How can you disagree with it? Your script proves it. Does not bless {}, ref($class) || $class lead to odd behavior when called as a function (specifically being blessed into main::). Sure it does, and the same goes for bless {}, shift, but that only tells me that both are (maybe) bad, not just bless {}, ref($class) || $class.
To be honest, I am confused by your argument here. You are comparing bless {}, ref($class) || $class with bless {}, shift, saying that they have the same behavior when called as a function and not a method. I agree with that, I have never disagreed. I didn't bring that second idiom up, you did, and in the end, I just see it as having the same problems as the first idiom.
I don't think I ever said that "class or object" is the only possible cause of the odd behavior, it is one of them. And I am not sure why you seem to be implying that bless {}, ref($class) || $class and bless {}, shift are my only (?) two options. I guess I am just not understanding what you are trying to say.
My original point was that practices like bless {}, ref($class) || $class (which includes bless {}, shift) are not really the best since they can create a problem when constructors are called as functions (accidentaly or on purpose).
What leads you to believe otherwise?
I don't believe otherwise, I believe that not checking the specifics of $class is (in some cases) bad no matter how you do/don't it.
| [reply]
[d/l]
[select] |
