Scalar :: Util vs. ref Funktion

Question

Was ist der Unterschied zwischen dem eingebauten ref($object) und Scalar::Util blessed($object)? Ist eine über den anderen bevorzugt?

use strict;
use warnings;

use Scalar::Util qw(blessed isvstring);

my $object = foo->new();

print "Object is a " . blessed($object) . "\n";
print "Object is a " . ref($object) . "\n";

my $version = 5.00.03;

print "Version is a " . ref(\$version) . "\n";
if (isvstring($version)) {
    print "Version is a VSTRING\n";
}

package foo;
sub new {
    my $class = shift;
    my $self = {};

    bless($self, $class);
    return $self;
}

Answer 1

Nach POD, blessed() funktioniert nur auf gesegnet Referenzen (zum Beispiel eine Bezugnahme auf einen bless() Aufruf übergeben).

Es gibt undef auf alles andere, einschließlich Hash / array Refs wo ref() kehrt HASH / ARRAY (und ein paar andere Typen als abgegrenzte in perldoc ref ). Um Referenztyp erhalten Sie können natürlich Anruf Scalar::Util::reftype.

Als ob übereinander verwendet werden soll, ich denke, es hängt zum großen Teil auf dem, was die Logik ist.

• Wenn Sie nur real gesegnet Referenzen von allem unterscheiden will anders, bietet blessed() eine prägnante Art und Weise als ein ref nehmen und dann überprüfen, ob der Wert nicht auf dem Standard diejenige zurück durch unblessed Referenz.

  my $ref_type = ref($my_ref);
  print "USING REF: ";
  if (      $ref_type
         && $ref_type ne ref({})
         && $ref_type ne ref([])
         && $ref_type ne "SCALAR"
         # Could also use a hash with all allowed values of ref() instead
         && $ref_type !~ /^(CODE|REF|GLOB|...)$) { 
      print "I am an object of class $ref_type\n";
  } else {
      print "I'm a reference of type $ref_type\n";
  }
  
  
  # vs... 
  
  
  print "USING SCALAR_UTIL: ";
  my $ref_type = blessed($my_ref);
  print $ref_type ? "I am an object of class $ref_type\n"
                  : "I am a reference of type " . reftype($my_ref) . "\n";
  

• Wenn Sie feine Unterschiede zwischen den beide gesegnet Referenzen und verschiedenen ublessed diejenigen benötigen, ein einzelner ref() Anruf prägnanter als eine Kombination von blessed und reftype.

• Ein Rand Fall, in dem es ein tatsächlichen funktionellen Unterschied zwischen den beiden Ansätzen, wie in den Kommentaren von Eric Strom festgestellt, ist, wenn jemand eine Klasse erstellt, die eine von ref() Spielen Werte fest einprogrammiert (zB bless [], 'HASH' - in diesem Fall werden sie entweder Weg Dumb oder Way Too Clever von Halb).

  my $sssft = bless [], 'HASH'; # sssft = someone_should_suffer_for_this
  ref_description_using_ref($sssft);
  ref_description_using_scalar_util($sssft);
  
  
  # OUTPUT:
  USING REF: I'm a reference of type HASH
  USING SCALAR_UTIL: I am an object of class HASH
  

HAFTUNGSAUSSCHLUSS: Basierend auf Dokumentation, sollte es keinen Unterschied zwischen den beiden, wenn das Argument eine Referenz in eine Klasse gesegnet ist (zum Beispiel gibt es Klassennamen). Aber ich habe nicht geprüft „Scalar :: Util“ Quelle zu bestätigen.