Schreibweise für GLOB (gelöst) (Allgemeines zu Perl)

[thread]20542[/thread]

Schreibweise für GLOB [gelöst]

Tags: perl5 Ähnliche Threads

Leser: 13

Articles: hide open all | hide show old branches

+5 replies

rosti

2018-11-24 12:55

User since
2011-03-19
3492 Artikel
BenutzerIn

Welche Schreibweise wäre zu bevorzugen?

Code (perl): (dl )

1
2

 ${*self}{FH} = $fh;
 *self->{FH} = $fh;

Oder gibts da Unterschiede?

Bitte mal um Hinweises,

MfG

PS: Solche Schreibweisen finden sich zuhauf in der libnet. So ist es bspw. möglich, *Handles weitere Eigenschaften zuzuweisen, Beispiels:

Code (perl): (dl )

use strict;
use warnings;
use IO::Socket;
use base qw(IO::Socket::INET);
use constant CRLF => "\r\n";

my $host = 'smtp.mail.yahoo.com';
my $m = main->new(PeerAddr => "$host:25", Timeout => 1) or die $@;

# Eigenschaften via Glob anhängen
*m->{FOO} = 'foo'; # einfach Glob
*$m->{FOO} = 123;  # Glob auf Glob
$, = "\n";
print $m->getline,
    *m->{FOO}, ${*m}{FOO},
    *$m->{FOO}, ${*$m}{FOO};
    
$m->print('Helo localhost', CRLF);    
print $m->getline;

# Ausgabe untenstehend
__END__ 
220 smtp.mail.yahoo.com ESMTP ready

foo
foo
123
123
250 smtp403.mail.ir2.yahoo.com Hello localhost [79.254.13.82])

Last edited: 2018-11-24 18:50:19 +0100 (CET)

+4 replies

haj

2018-11-24 20:44

User since
2015-01-07
558 Artikel
BenutzerIn

user image

2018-11-24T11:55:21 rosti
PS: Solche Schreibweisen finden sich zuhauf in der libnet. So ist es bspw. möglich, *Handles weitere Eigenschaften zuzuweisen

Nun wird mir einiges klar.

Die libnet hat einen Stil, der aus heutiger Sicht ein bisschen eigentümlich ist. Das liegt zum einen daran, dass der Code überwiegend vor langer Zeit entstanden ist und zum anderen daran, dass Handles immer noch "merkwürdige" Perl-Daten sind.

Die lexikalische Variable $m ist eine Referenz auf einen anonymen Typeglob. Mit *$m bewirkt man eine De-Referenzierung, ich würde das nicht als "Glob auf Glob" interpretieren. *$m->{FOO} = 123; ist also ein Zugriff auf den Hash-Eintrag im Glob *$m. Man kann, wenn man Spaß dran hat, daneben auch noch den Skalaren und den Array-Slot verwenden:

Code (perl): (dl )

1
2
3

@{*$m} = qw(glib glob);
*$m->[0]   = 'glub';
${*$m} = 'Scalar Ref';

Zum Betrachten der Einträge eignet sich übrigens CPAN:

Data::Dump, der solche anonymen Typeglobs auflöst:

Code (perl): (dl )

use strict;
use base qw(IO::Socket::INET);
use Data::Dump qw(dump);

my $host = 'smtp.mail.yahoo.com';
my $m = main->new(PeerAddr => "$host:25", Timeout => 1) or die $@;

*$m->{FOO} = 123;  # Glob auf Glob

@{*$m} = qw(glib glob);
*$m->[0]   = 'glub';

${*$m} = 'Scalar Ref';

dump  $m;

Ausgabe:

Code: (dl )

do {
  require Symbol;
  my $a = bless(Symbol::gensym(), "main");
  *{$a} = \"Scalar Ref";
  *{$a} = ["glub", "glob"];
  *{$a} = {
    FOO => 123,
    io_socket_domain => 2,
    io_socket_proto => 6,
    io_socket_timeout => 1,
    io_socket_type => 1,
  };
  $a;
}

Es gehört sich allerdings nicht, auf diese Weise in fremden Objekten zu arbeiten, dabei kann auch mal was kaputtgehen.

Im Gegensatz dazu erzeugt *m->{FOO} = 'foo'; einen Eintrag in der lokalen Symbol-Tabelle, man kann genauso %main::m = (FOO => 'foo') schreiben. Man spart sich ein paar Buchstaben, umschifft das use strict; - aber für gute Praxis halte ich das nicht.

+3 replies

rosti

2018-11-25 08:11

User since
2011-03-19
3492 Artikel
BenutzerIn

Interesant, danke Dir

dump zeigt jedoch nicht alles:

Code (perl): (dl )

# Eigenschaften via Glob anhängen
*m->{FOO} = 'foo'; # einfach Glob
print dump $m;


do {
  require Symbol;
  my $a = bless(Symbol::gensym(), "main");
  *{$a} = {
    io_sock_nonblocking => 0,
    io_socket_domain    => 2,
    io_socket_proto     => 6,
    io_socket_timeout   => 1,
    io_socket_type      => 1,
  };
  $a;
}

Also gibt es ja doch Unterschiede? Die andere Sache ist die Verwendung: Ein solcher Glob steht mir in jeder Funktion zur Verfügung, die Alternative wäre eine globale Variable die sich statisch verhält (Klassenvariable).

Verhält sich *self auch statisch (wenn $self die Instanz in einer Methode ist)?

Ich überlege mir wie ich das mal prüfen könnte. In Verwendung untenstehend:

Code (perl): (dl )

package HashFile;
# persistent tied Hash ín File


use strict;
use warnings;
use Tie::Hash;
use IO::File;
use Fcntl qw(:flock);
use base qw(Tie::StdHash);

sub TIEHASH{
    my $class = shift;
    my %opts = (
        flock => 0,
        file  => '',
    @_);
    return eval{
        my $self = $class->SUPER::TIEHASH();
        my $fh = IO::File->new();
        $fh->open($opts{file}, O_CREAT|O_BINARY|O_RDWR) || die $!;
        flock $fh, LOCK_EX if $opts{flock};
        *self->{FH} = $fh;
        *self->{OPTS} = \%opts;
        my $h = $self->_thaw();        
        %$self = %$h;
        $self;
    };
}

sub write{
    my $self = shift;
    $self->_freeze;
}

sub _freeze{
    my $self = shift;
    my $fh = *self->{FH};
    $fh->seek(0,0);
    $fh->truncate(0);
    use bytes;
    while( my ($k, $v) = each %$self){
        my $def = defined $v ? 1 : 0; 
        $v ||= '';
        $fh->print(pack("V", length $k), pack("V", length $v), $k, $v, $def);
    }
}
sub _thaw{
    my $self = shift;
    my $fh = *self->{FH};
    $fh->seek(0,0);
    my %h = ();
    use bytes;
    while( read($fh, my $lens, 8) ){
        my ($klen, $vlen) = unpack "VV", $lens;
        read($fh, my $k, $klen);
        read($fh, my $v, $vlen);
        read($fh, my $def, 1);
        $h{$k} = $def ? $v : undef;
    }
    \%h;
}

sub DESTROY{
    my $self = shift;
    $self->_freeze if *self->{OPTS}{auto};
}
1;#########################################################################
package main;

use strict;
use warnings;
use Data::Dumper;
$Data::Dumper::Sortkeys = 1;

tie my %h, 'HashFile', file => 'hashfile.bin', auto => 1 or die $@;
#%h = (foo => '', bar => 1, baz => undef);
print Dumper \%h;

So wies aussieht ist in der main kein Rankommen an diesen Glob.

.
Last edited: 2018-11-25 08:18:50 +0100 (CET)

+2 replies
haj

2018-11-25 21:03
User since
2015-01-07
558 Artikel
BenutzerIn
2018-11-25T07:11:29 rosti
Interesant, danke Dir

dump zeigt jedoch nicht alles:

Code (perl): (dl )

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# Eigenschaften via Glob anhängen *m->{FOO} = 'foo'; # einfach Glob print dump $m; do { require Symbol; my $a = bless(Symbol::gensym(), "main"); *{$a} = { io_sock_nonblocking => 0, io_socket_domain => 2, io_socket_proto => 6, io_socket_timeout => 1, io_socket_type => 1, }; $a; }

Also gibt es ja doch Unterschiede?
Ich hab's ja schon geschrieben: *m->{FOO} = 'foo'; hat mit der lexikalischen Variable $m gar nichts zu tun! Mit *m erzeugst Du einen Eintrag in der Symboltabelle von main. Guckst Du hier:
Code (perl): (dl )

1 2 3 4 5 6

use strict; use Data::Dump qw/dump/; *m->{FOO} = 'foo'; # einfach Glob dump %main::m; dump $::{m};
Ausgabe:
Code: (dl )

1 2 3 4 5 6

("FOO", "foo") do { my $a = *main::m; $a = { FOO => "foo" }; $a; }
Die Dinger lassen sich wie Klassenvariablen verwenden, weil sie in der Symboltabelle des jeweiligen package drinstehen. Der Lesbarkeit dient das allerdings nicht. Du verbuchselst das auch mit my $self (lexikalischer Skalar, nicht in der Symboltabelle) und *self (Typeglob, spricht für alle Einträge mit dem Namen "self" in der Symboltabelle).

Das hatte mich auch bei Deinem ursprünglichen Artikel so stutzig gemacht: Das übliche Mantra ist my $self = shift; und somit einfach eine andere Baustelle als *self!
- rosti
  
  2018-11-26 08:08
  
  User since
  2011-03-19
  3492 Artikel
  BenutzerIn
  
  Danke!

View all threads created 2018-11-24 12:55.