First you need to understand what references are in Perl.
See L<perlref> for that. Second, if you still find the following
reference work too complicated, a tutorial on object-oriented programming
-in Perl can be found in L<perltoot> and L<perltootc>.
+in Perl can be found in L<perltoot> and L<perltooc>.
If you're still with us, then
here are three very simple definitions that you should find reassuring.
}
Or if you expect people to call not just C<< CLASS->new() >> but also
-C<< $obj->new() >>, then use something like this. The initialize()
-method used will be of whatever $class we blessed the
-object into:
+C<< $obj->new() >>, then use something like the following. (Note that using
+this to call new() on an instance does not automatically perform any
+copying. If you want a shallow or deep copy of an object, you'll have to
+specifically allow for that.) The initialize() method used will be of
+whatever $class we blessed the object into:
sub new {
my $this = shift;
A class method expects a class name as the first argument. It
provides functionality for the class as a whole, not for any
individual object belonging to the class. Constructors are often
-class methods, but see L<perltoot> and L<perltootc> for alternatives.
+class methods, but see L<perltoot> and L<perltooc> for alternatives.
Many class methods simply ignore their first argument, because they
already know what package they're in and don't care what package
they were invoked via. (These aren't necessarily the same, because
$self->SUPER::display("Name", @args);
}
+It is important to note that C<SUPER> refers to the superclass(es) of the
+I<current package> and not to the superclass(es) of the object. Also, the
+C<SUPER> pseudo-class can only currently be used as a modifier to a method
+name, but not in any of the other ways that class names are normally used,
+eg:
+
+ something->SUPER::method(...); # OK
+ SUPER::method(...); # WRONG
+ SUPER->method(...); # WRONG
+
Instead of a class name or an object reference, you can also use any
expression that returns either of those on the left side of the arrow.
So the following statement is valid:
C<isa> returns I<true> if its object is blessed into a subclass of C<CLASS>
-You can also call C<UNIVERSAL::isa> as a sub with two arguments. The
-first does not need to be an object or even a reference. This
-allows the ability to check what a reference points to, or whether
+You can also call C<UNIVERSAL::isa> as a subroutine with two arguments.
+The first does not need to be an object or even a reference. This
+allows you to check what a reference points to, or whether
something is a reference of a given type. Example
if(UNIVERSAL::isa($ref, 'ARRAY')) {
#...
}
+To determine if a reference is a blessed object, you can write
+
+ print "It's an object\n" if UNIVERSAL::isa($val, 'UNIVERSAL');
+
=item can(METHOD)
C<can> checks to see if its object has a method called C<METHOD>,
if it does then a reference to the sub is returned, if it does not then
I<undef> is returned.
+C<UNIVERSAL::can> can also be called as a subroutine with two arguments.
+It'll always return I<undef> if its first argument isn't an object or a
+class name. So here's another way to check if a reference is a
+blessed object
+
+ print "It's still an object\n" if UNIVERSAL::can($val, 'can');
+
+You can also use the C<blessed> function of Scalar::Util:
+
+ use Scalar::Util 'blessed';
+
+ my $blessing = blessed $suspected_object;
+
+C<blessed> returns the name of the package the argument has been
+blessed into, or C<undef>.
+
=item VERSION( [NEED] )
C<VERSION> returns the version number of the class (package). If the
node such as one might use in a sophisticated tree structure:
sub new_node {
- my $self = shift;
- my $class = ref($self) || $self;
- my $node = {};
+ my $class = shift;
+ my $node = {};
$node->{LEFT} = $node->{RIGHT} = $node;
$node->{DATA} = [ @_ ];
return bless $node => $class;
warn "time to die...";
exit;
-When run as F</tmp/test>, the following output is produced:
+When run as F</foo/test>, the following output is produced:
- starting program at /tmp/test line 18.
- CREATING SCALAR(0x8e5b8) at /tmp/test line 7.
- CREATING SCALAR(0x8e57c) at /tmp/test line 7.
- leaving block at /tmp/test line 23.
- DESTROYING Subtle=SCALAR(0x8e5b8) at /tmp/test line 13.
- just exited block at /tmp/test line 26.
- time to die... at /tmp/test line 27.
+ starting program at /foo/test line 18.
+ CREATING SCALAR(0x8e5b8) at /foo/test line 7.
+ CREATING SCALAR(0x8e57c) at /foo/test line 7.
+ leaving block at /foo/test line 23.
+ DESTROYING Subtle=SCALAR(0x8e5b8) at /foo/test line 13.
+ just exited block at /foo/test line 26.
+ time to die... at /foo/test line 27.
DESTROYING Subtle=SCALAR(0x8e57c) during global destruction.
Notice that "global destruction" bit there? That's the thread
=head1 SEE ALSO
A kinder, gentler tutorial on object-oriented programming in Perl can
-be found in L<perltoot>, L<perlbootc> and L<perltootc>. You should
+be found in L<perltoot>, L<perlboot> and L<perltooc>. You should
also check out L<perlbot> for other object tricks, traps, and tips, as
well as L<perlmodlib> for some style guides on constructing both
modules and classes.
projects / p5sagit/p5-mst-13.2.git / blobdiff